How to become a DevOps Engineer / SRE

A complete, honest roadmap for the skills DevOps engineers and site reliability engineers actually use, from Linux and networking through automation, CI/CD, containers, infrastructure as code, cloud, observability, reliability engineering, security, and AI. It runs top to bottom, foundational to advanced, so you always know what comes next. Free to read, no signup required.

1. 01

   Step 01Foundations: Linux, networking & scripting

   DevOps and SRE work sits on top of systems fundamentals. You can’t automate or keep reliable what you don’t understand, so start here.

   • Linux: The command line, processes, permissions, and the filesystem, since most infrastructure runs on Linux.
   • Networking: How traffic moves: IP, DNS, HTTP, TLS, ports, and load balancing, which underpins everything you operate.
   • Scripting: Automating routine tasks with shell and a language like Python, the first habit of the whole discipline.
   • How systems run: Understanding what happens when a request hits a server, so you can reason about failures.

   DevOps and SRE are closely related. DevOps is broadly the culture and practice of building and running software together; SRE is a specific, reliability-focused approach to it. This roadmap covers the skills both rely on.

   LinuxNetworkingDNS & TLSShell scriptingSystems basics
2. 02

   Step 02Programming & automation

   The core instinct of the field is to automate everything repeatable. Real programming ability is what lets you do that well.

   • A language: Genuine fluency in one language (Python and Go are common) for tooling, automation, and glue.
   • Automating toil: Replacing manual, repetitive work with reliable scripts and tools, which is the everyday job.
   • APIs: Working with APIs to control infrastructure and stitch systems together programmatically.
   • Software habits: Testing and clean code, because your automation runs the systems everyone else depends on.

   Python / GoAutomationAPIsTestingTooling
3. 03

   Step 03Version control & collaboration

   Everything is code now, including infrastructure. Git is where it lives and how teams work on it together.

   • Git: Branching, pull requests, and reviewing changes, assumed on day one of any team.
   • Everything as code: Treating infrastructure, configuration, and pipelines as versioned code, not manual clicks.
   • GitOps: Driving deployments and infrastructure changes through Git, so the repo is the source of truth.

   GitPull requestsEverything as codeGitOps
4. 04

   Step 04CI/CD

   Continuous integration and delivery is the assembly line of modern software. Automating the path from commit to production reliably is a central DevOps skill.

   • Pipelines: Automatically building, testing, and deploying on every change, so releases are routine rather than risky.
   • Quality gates: Running tests, linting, and security scans in the pipeline so broken code never reaches production.
   • Deployment strategies: Blue-green, canary, and rolling deploys that release safely and roll back cleanly when needed.
   • Fast, safe releases: Making deployment frequent and boring, which is a sign of a healthy engineering organisation.

   CI/CD pipelinesQuality gatesBlue-green & canaryRollbacks
5. 05

   Step 05Containers & orchestration

   Containers changed how software is packaged and run, and orchestration is how it runs at scale. Both are core to nearly every DevOps role today.

   • Docker: Packaging an app with its dependencies so it runs the same everywhere. Learn images, containers, and Dockerfiles.
   • Kubernetes: Orchestrating containers across many machines: pods, deployments, services, scaling, and self-healing.
   • Networking & storage: How containers talk to each other and persist data, which is where a lot of real complexity lives.
   • Concepts before YAML: Understanding what the orchestrator is doing, so the configuration isn’t a black box when it breaks.

   DockerKubernetesPods & deploymentsScalingSelf-healing
6. 06

   Step 06Infrastructure as code

   Provisioning infrastructure by hand doesn’t scale and can’t be trusted. Describing it as code makes it repeatable, reviewable, and recoverable.

   • Declarative infrastructure: Describing the desired state of your infrastructure in code, with tools like Terraform, rather than clicking through a console.
   • Configuration management: Keeping servers and services in a known, consistent state automatically.
   • Reproducible environments: Standing up identical environments on demand, so dev, staging, and prod actually match.
   • Reviewable changes: Treating infrastructure changes like code changes: reviewed, versioned, and safe to roll back.

   TerraformConfig managementDeclarative infraReproducible environments
7. 07

   Step 07Cloud platforms

   Most infrastructure now lives in the cloud. Learn the building blocks of one major platform deeply, since the concepts carry across all of them.

   • Core services: Compute, storage, networking, and databases on a major cloud (AWS, Azure, or Google Cloud).
   • Managed services: Using managed offerings so you run less undifferentiated infrastructure yourself.
   • The shared responsibility model: Knowing what the cloud secures and operates and what remains your job.
   • Cost awareness: Designing with the bill in mind, since cloud costs scale quickly when nobody is watching.

   AWS / Azure / GCPCore servicesManaged servicesShared responsibilityCost
8. 08

   Step 08Observability & monitoring

   You can’t operate what you can’t see. Observability is how you know a system is healthy, and how you find out why when it isn’t.

   • Metrics, logs & traces: The three pillars: how much and how fast, what happened, and a request’s path across services.
   • Dashboards: Building views that show system health at a glance, for both routine checks and incidents.
   • Alerting: Alerts that page a human only when it truly matters, since alert fatigue is a real failure mode.
   • Debugging in production: Using observability to find the cause of a real problem quickly, under pressure.

   Metrics / logs / tracesPrometheus & GrafanaDashboardsAlerting
9. 09

   Step 09Reliability engineering

   This is the heart of SRE: engineering systems and practices that keep services reliable, and responding well when they aren’t.

   • SLOs, SLIs & error budgets: Defining what reliable means in measurable terms, and using an error budget to balance speed and stability.
   • Resilience patterns: Timeouts, retries with backoff, circuit breakers, and graceful degradation so failures stay contained.
   • Incident response: On-call, triage, and a calm process for handling outages when they happen.
   • Blameless postmortems: Learning from incidents by fixing systems rather than blaming people, so the same failure doesn’t recur.

   Reliability is engineered, not wished for. The discipline of SLOs, error budgets, and blameless postmortems is what turns firefighting into steady, measurable improvement.

   SLOs & SLIsError budgetsResilienceIncident responsePostmortems
10. 10

    Step 10Security, scaling & performance

    As systems grow, keeping them secure, fast, and affordable becomes central. Security in particular is now part of the pipeline, not an afterthought.

    • Security in the pipeline: Managing secrets, least-privilege access, and scanning, so security is built in rather than bolted on.
    • Scaling: Load balancing, autoscaling, and capacity planning so a system holds up as demand grows.
    • Performance: Finding and fixing bottlenecks so services stay fast under real load.
    • Cost & efficiency: Right-sizing resources so reliability and scale don’t come with an unbounded bill.

    DevSecOpsSecretsAutoscalingLoad balancingCost control
11. 11

    Step 11AI & the modern DevOps/SRE

    AI is entering operations from both sides: as a tool that helps run systems, and as workloads you now have to run. Understanding both is increasingly expected.

    • AI in operations: Using AI to help with alerts, log analysis, and writing automation, while keeping a human in control of production.
    • Running AI infrastructure: Operating the compute, GPUs, and pipelines that AI workloads need, which is a fast-growing demand.
    • AI coding tools: Using assistants to write scripts and configuration faster, with careful review since this is production.

    AI can help operate systems, but it raises the stakes on the fundamentals. You can only trust automation, AI-driven or not, if you understand the systems it’s touching.

    AIOpsAI infrastructureGPUsAI coding tools