A written version of the interactive roadmap above — every station, what you'll learn, and a small thing to build — laid out for reading, reference and search.
Foundations Start here
F1. Linux & the Shell
Beginner · 60 min
Almost every server runs Linux, so DevOps starts at the command line. Learn the filesystem, permissions, processes, package managers, and enough shell to move confidently. The terminal is not a fallback here — it is the primary interface to everything you operate.
Skills: Filesystem & permissions · Processes & signals · Package managers · Pipes & redirection
Build it: Given a box you have never seen, find what is eating CPU, which process owns port 8080, and how much disk is left — all from the shell.
✓ Checkpoint: Explain what a signal does to a process, and why kill -9 is the one your service never gets to handle.
F2. Networking Basics
Beginner · 60 min
You cannot operate systems you cannot trace. Learn IP and ports, DNS, TCP vs UDP, HTTP, TLS, and firewalls — enough to answer "why can this box not reach that one?" Networking is the single most common source of production mysteries.
Skills: IP, ports & DNS · TCP/UDP & HTTP · TLS & certificates · Firewalls & routing
Build it: A service returns connection-refused. Walk the path — DNS, port, firewall, process — and pinpoint where the packet dies.
✓ Checkpoint: Trace what happens between typing a URL and the TLS handshake completing. Any gap you cannot narrate is a gap you cannot debug.
F3. Git & Version Control
Beginner · 45 min
Git is the substrate of DevOps — code, config, and increasingly infrastructure all live in it. Learn branching, merging, rebasing, and pull-request workflows, because in a GitOps world a git commit is how you change production. Master it beyond the three commands you know.
Skills: Branching & merging · Rebase vs merge · PR workflows · Tags & history
Build it: Two branches touched the same config. Resolve the conflict, then explain when you would rebase instead of merge — and when you must not.
✓ Checkpoint: Explain when rebase is the right tool and when it rewrites history someone else has already pulled.
F4. Docker & Containers
Intermediate · 75 min
Containers package an app with its dependencies so it runs the same everywhere — the unit modern deployment is built on. Learn images, layers, the Dockerfile, registries, and why containers are not VMs. This is the gateway to everything orchestrated.
Skills: Images & layers · Dockerfiles · Registries · Containers vs VMs
Build it: Containerize an app in a multi-stage Dockerfile so the final image is small. Why does layer order decide your build cache hit rate?
✓ Checkpoint: Explain why Docker layer order changes build time, and which line in your Dockerfile invalidates the cache most often.
F5. Cloud Fundamentals
Intermediate · 60 min
DevOps runs on the cloud. Learn the core primitives every provider shares — compute, storage, networking (VPC), identity (IAM), and the managed-service tradeoff. The provider changes; the mental model — pay for what you use, everything is an API — does not.
Skills: Compute / storage / VPC · IAM & least privilege · Managed vs self-hosted · Regions & availability zones
Build it: Design the minimal cloud footprint for a web app: which pieces are managed services, and where does IAM draw the security boundary?
✓ Checkpoint: Explain the shared responsibility line for a managed service you use, and name what you wrongly assumed the provider handles.
F6. Scripting: Bash & Python
Intermediate · 55 min
DevOps is automation, and automation is code. Learn enough Bash to glue commands and enough Python to write real tooling — parsing, calling APIs, handling errors. The rule: if you did it twice by hand, script it the third time.
Skills: Bash glue & exit codes · Python for tooling · Calling APIs · Idempotent scripts
Build it: Write a script that rotates old log files and alerts if disk crosses 80%. Make it safe to re-run — idempotent, no double action.
✓ Checkpoint: Explain what makes a script idempotent, and why that matters more than whether it is short.
Core DevOps The craft
T1. CI/CD Pipelines
Intermediate · 65 min
Continuous integration and delivery turn every commit into a tested, deployable artifact automatically. Learn pipeline stages (build, test, scan, deploy), caching, parallelism, and gates. A good pipeline makes shipping boring — which is exactly the point.
Skills: Pipeline stages · Build caching & parallelism · Quality gates · Artifacts between stages
Build it: Design a pipeline that lints, tests, builds an image, scans it, and deploys to staging — and blocks promotion on any failed gate.
✓ Checkpoint: Explain what belongs in a quality gate that blocks a merge, and what belongs in a job that only reports.
T2. Infrastructure as Code
Advanced · 70 min
Click-ops does not scale or reproduce. Infrastructure as Code (Terraform, Pulumi) declares your cloud in version-controlled files, so infra is reviewable, repeatable, and diffable. Learn state, plan/apply, modules, and drift — infra becomes just more code.
Skills: Declarative infra (Terraform) · State & drift · plan / apply · Modules & reuse
Build it: Provision a VPC + database with Terraform. Someone changes it in the console — how does the next plan reveal and reconcile the drift?
✓ Checkpoint: Explain what Terraform state is protecting, and what happens when two engineers apply at the same time.
T3. Configuration Management
Advanced · 55 min
Once machines exist, they must be configured consistently. Tools like Ansible push a desired state — packages, files, services — declaratively and idempotently across fleets. Learn playbooks, inventory, and why idempotence is the whole game.
Skills: Declarative config (Ansible) · Idempotence · Inventory & roles · Immutable vs mutable infra
Build it: Write a playbook that installs and configures a service on 50 hosts. Run it twice — nothing should change the second time. Why?
✓ Checkpoint: Explain the difference between configuring a server and replacing it, and why immutable infrastructure sidesteps drift.
T4. Kubernetes
Advanced · 90 min
Kubernetes orchestrates containers at scale by chasing a declared desired state — scheduling, self-healing, rolling out, and load-balancing pods across a cluster. It is the central skill of modern DevOps. Learn pods, deployments, services, and the reconciliation loop.
Skills: Pods & deployments · Services & networking · Desired-state control loop · Scaling & rollouts
Build it: Declare 3 replicas behind a service. Kill a pod and push a new image — show how the control loop keeps you available through both.
✓ Checkpoint: Explain what the control loop does when you delete a pod by hand, and why that is the whole idea.
T5. Secrets & Security
Advanced · 55 min
Pipelines and clusters hold the keys to everything. Learn secret management (Vault, cloud KMS), least-privilege IAM, image and dependency scanning, and supply-chain basics. DevSecOps means security is a step in the pipeline, not a review at the end.
Skills: Secret management · Least-privilege IAM · Image & dependency scanning · Supply-chain security
Build it: A database password is hard-coded in a repo. Move it to a secret store and inject it at deploy time — with no human ever seeing it.
✓ Checkpoint: Explain why a secret in an environment variable is better than one in the image and still not good enough.
T6. Artifacts & Registries
Intermediate · 45 min
Between build and deploy live artifacts — container images, packages, binaries — stored in registries with versions and provenance. Learn tagging, immutability, promotion across environments, and why "deploy the exact bytes you tested" matters.
Skills: Image & package registries · Semantic tagging · Immutability & promotion · Provenance
Build it: The image that passed staging tests must be the one that reaches prod. How do you guarantee it is byte-identical, not a rebuild?
✓ Checkpoint: Explain why promoting the same immutable artifact beats rebuilding per environment.
Production Operate & scale
P1. Observability
Advanced · 65 min
You cannot operate what you cannot see. Instrument the three pillars — metrics (is something wrong?), logs (what happened?), traces (where?) — with dashboards and the golden signals. Observability is what turns a 3am page into a guided fix.
Skills: Metrics / logs / traces · Dashboards · Golden signals · Structured logging
Build it: Latency spiked. Show which metric alerts you, which trace localizes the slow hop, and which log lines explain the root cause.
✓ Checkpoint: Explain which of metrics, logs and traces answers “is it broken”, “why”, and “where” — and why you need all three.
P2. GitOps & Progressive Delivery
Advanced · 60 min
GitOps makes the git repo the single source of truth: a controller continuously reconciles the cluster to match it, so deploys are pull requests and rollbacks are reverts. Pair it with progressive delivery — canary and blue-green — to release safely.
Skills: GitOps reconciliation · Canary & blue-green · Automated rollback · Feature flags
Build it: Roll out a risky change to 5% of traffic, watch error rate, and auto-roll-back on breach — all driven by a commit to git.
✓ Checkpoint: Explain what GitOps reconciliation does when someone changes the cluster by hand.
P3. Incident Response & On-call
Advanced · 55 min
Production breaks; the discipline is how you respond. Learn on-call rotations, alerting that pages on symptoms not noise, incident command, and blameless postmortems that turn outages into permanent fixes. Reliability is a practice, not a state.
Skills: On-call rotations · Alerting on symptoms · Incident command · Blameless postmortems
Build it: Write the runbook for a "checkout down" alert: who is paged, the first three checks, and how the postmortem prevents a repeat.
✓ Checkpoint: Explain why alerting on symptoms beats alerting on causes, and what a page at 3am should mean.
P4. SLOs & SRE
Advanced · 60 min
Site Reliability Engineering makes reliability measurable. Define SLIs, set SLOs, and spend the resulting error budget to balance new features against stability. When the budget is gone, you stop shipping risk and fix reliability — data, not opinions, decides.
Skills: SLIs / SLOs · Error budgets · Toil reduction · Reliability vs velocity
Build it: Set a 99.9% SLO for an API and derive its monthly error budget in minutes. When the budget is spent, what must the team change?
✓ Checkpoint: Explain what an error budget lets you say no to — and what it lets you say yes to.
P5. Networking at Scale
Advanced · 60 min
Production traffic needs steering. Learn load balancers (L4/L7), DNS-based routing, CDNs at the edge, TLS termination, and service mesh basics. This is where "it works on one box" becomes "it works for millions across regions."
Skills: Load balancing (L4/L7) · DNS routing · CDN & edge · Service mesh basics
Build it: Serve a global app: put a CDN at the edge, load-balance regional backends, and route users to the nearest healthy region.
✓ Checkpoint: Explain the difference between L4 and L7 load balancing in terms of what the balancer can see.
P6. Cost & Capacity
Advanced · 50 min
The cloud bill is a feature you own. Learn capacity planning, autoscaling, right-sizing, spot vs reserved, and FinOps basics — spotting the idle resources and over-provisioned clusters quietly burning money. Efficiency is reliability you can afford.
Skills: Capacity planning · Autoscaling & right-sizing · Spot vs reserved · FinOps & cost visibility
Build it: A cluster costs 3x what traffic justifies. Find the waste — idle nodes, over-provisioned requests — and set autoscaling that tracks demand.
✓ Checkpoint: Explain when spot instances are appropriate and what your workload must tolerate to use them.