Go from Linux and Git to shipping secure, observable software on Kubernetes and the cloud, on demand.
The end-to-end DevOps roadmap for 2026: Linux, Git, CI/CD, containers, Kubernetes, infrastructure as code, cloud, observability and security, tied together by DORA metrics and a culture of small, safe, frequent change. Built around hands-on projects you can show in interviews.
DevOps is the set of cultural practices, engineering habits and automation that lets teams ship changes to production quickly and safely. A DevOps engineer builds and runs the delivery system itself: version control workflows, CI/CD pipelines, container platforms, infrastructure as code, observability and the guardrails that keep it all secure.
In 2026 the discipline matters more, not less. DORA's 2025 research found that around 90% of technology professionals now use AI at work, and that AI amplifies whatever system it lands in: teams with small batches, strong version control, fast feedback and good internal platforms ship faster, while teams without them simply ship instability faster. The fundamentals in this path are exactly those amplifying capabilities.
This is the broad, foundational path. It connects to the neighbouring Ops disciplines rather than replacing them: SRE goes deeper on reliability and SLOs, platform engineering turns DevOps practices into a self-service product, DevSecOps goes deeper on security, and GitOps specialises the deployment model on Kubernetes. Finish this path first and any of those becomes a natural next step.
7 stages · 25 topics · ~296 hours of focused learning. Work through the stages in order; optional topics are electives you can come back to.
The DevOps mindset plus the operating system, networking and scripting skills that every later stage builds on.
Learn why DevOps exists: shortening the path from idea to production while keeping systems stable. Study the CALMS model, the Three Ways, value streams and team structures, because tools adopted without these habits rarely improve delivery.
Almost every server, container and CI runner you touch runs Linux. Get fluent with the shell, processes, services, permissions and logs so you can debug systems instead of guessing.
Most production incidents involve DNS, TLS, load balancers or firewalls. Learn how traffic actually flows from a client to your service so you can design networks in the cloud and troubleshoot them under pressure.
Automation is the core DevOps skill. Use Bash for glue and quick system tasks, and Python for anything that parses data, calls APIs or needs tests, writing scripts that are safe to run twice.
Milestone: You can explain what DevOps optimises for, administer a Linux server from the shell, debug basic network issues and automate a routine task with a script.
Git as the single source of truth for code, configuration and infrastructure, plus the workflows that keep a team merging small changes often.
Everything in modern delivery starts with a commit: application code, pipelines, infrastructure and deployment config. Learn Git well enough to branch, merge, rebase and recover from mistakes without fear.
DORA research consistently links trunk-based development with higher delivery performance. Learn to keep branches short-lived, review changes in small pull requests and enforce quality with branch protection and required checks.
AI coding assistants and agents are now part of most developer workflows, and DORA's 2025 research shows they amplify both good and bad practices. Learn to use them inside a disciplined workflow: small reviewed changes, tests in CI and clear rules on what code and data may be shared.
Milestone: You can run a team repository with protected branches, pull-request reviews, required checks and a trunk-based workflow.
Automate build, test, packaging and release so every commit produces a trustworthy, deployable artifact.
CI gives every change fast, automated feedback. Learn to write pipelines as versioned YAML, keep them fast with caching and parallelism, and connect them to the cloud with short-lived OIDC credentials instead of stored keys.
Pipelines are only as trustworthy as their tests. Build a balanced test suite and add static analysis and coverage gates so problems are caught in the pull request rather than in production.
Every build should produce a versioned, immutable artifact you can trace back to its source. Learn registries, SBOMs, signing and provenance, which customers and regulations such as the EU Cyber Resilience Act now expect.
Continuous delivery means every change is always releasable. Learn deployment pipelines across environments and release techniques that shrink blast radius, so deploying becomes routine and rollback is boring.
Milestone: You can build a pipeline that tests, scans, signs and publishes an artifact, then deploys it with a low-risk release strategy.
Package applications as containers and run them on Kubernetes, the default runtime platform for modern services.
Containers are the standard unit of delivery. Learn to build small, secure images with multi-stage builds and minimal base images, and to run them locally with Docker or rootless Podman.
Kubernetes is where most containerised workloads run. Learn the core objects, scheduling, networking and access control well enough to deploy, scale and debug applications, and use Gateway API for traffic now that Ingress NGINX has been retired.
Real applications need the same manifests deployed to many environments with small differences. Learn Helm for packaging and sharing software and Kustomize for patching plain YAML, and when to use each.
GitOps uses an in-cluster agent to pull the desired state from Git and continuously reconcile it, which gives you audit trails, easy rollback and drift correction. Learn the principles and deploy your app with Argo CD or Flux; the dedicated GitOps path goes much deeper.
Milestone: You can containerise a multi-service app and run it on Kubernetes with Helm or Kustomize, deployed and kept in sync through GitOps.
Provision and configure cloud infrastructure reproducibly with code and pull requests instead of consoles and tickets.
Go deep on one hyperscaler first; the concepts transfer. Focus on identity, networking and managed services, and use the provider's Well-Architected guidance to make sound security, reliability and cost decisions.
Terraform and its open-source fork OpenTofu (a CNCF project since 2025) share the same HCL language and workflow. Learn to write reusable modules, manage state safely and run plan and apply through pull requests.
Not everything is a container: VMs, network devices and legacy servers still need consistent configuration. Ansible's agentless, idempotent playbooks remain the most common tool for that job.
Milestone: You can provision a production-style cloud environment (network, identity and managed Kubernetes) with reviewed, versioned infrastructure code.
See what your systems are doing in production and run them to explicit reliability targets.
Metrics tell you when something is wrong and how wrong. Learn Prometheus and PromQL, build Grafana dashboards around the RED and USE methods, and alert on user-facing symptoms rather than every CPU spike.
OpenTelemetry is now the vendor-neutral standard for emitting metrics, logs and traces. Learn to instrument services once, route telemetry through the Collector and correlate signals to find the cause of slow or failing requests.
Reliability is a feature you can define and budget. Learn SLIs, SLOs and error budgets to balance speed against stability, and practise incident response and blameless postmortems so the same failure does not happen twice.
Milestone: You can instrument a service with OpenTelemetry, build dashboards and SLO-based alerts, and lead a blameless incident review.
Build security and policy into the pipeline, offer self-service golden paths, and use data to keep improving delivery.
Security checks are cheapest when they run on every pull request. Add static analysis, dependency, secret, container and IaC scanning to your pipelines, and set up triage so findings get fixed rather than ignored.
Long-lived credentials and manual reviews do not scale. Use a secrets manager with short-lived credentials and workload identity, and codify rules such as 'no privileged containers' as policies enforced in CI and at Kubernetes admission.
Platform engineering packages everything in this path into a self-service internal developer platform, so product teams get secure, compliant defaults without filing tickets. Learn to treat the platform as a product and build golden paths with templates and a service catalog.
What gets measured gets improved, if you measure the right things. Learn the five DORA metrics across throughput and instability, how to collect them from your pipelines, and how to use them for team learning rather than ranking.
Milestone: You can run a secure, policy-guarded delivery platform with a golden path and report DORA metrics that drive concrete improvements.
38 tools and platforms used across this path. Focus on concepts first — tools change, principles don’t.
Build these to prove your skills. Publish each one on GitHub with a clear README and architecture diagram.
Build a Git repository of Bash and Python scripts that bootstrap a fresh Linux VM (users, SSH hardening, firewall, a systemd service) and report its health. Add ShellCheck and unit tests that run in GitHub Actions on every pull request.
Containerise a small web service with a multi-stage Dockerfile and build a pipeline that runs tests, SonarQube analysis and Trivy scans, generates an SBOM, signs the image with cosign and pushes it to a registry. The build must fail on critical vulnerabilities.
Provision a VPC, IAM roles and a managed Kubernetes cluster with Terraform or OpenTofu modules, remote encrypted state and plan output posted to every pull request. Add a nightly job that detects and reports drift.
Deploy a three-service application to Kubernetes using Helm and Kustomize, managed by Argo CD from a config repository. Add a canary release with automated metric analysis and demonstrate an automatic rollback when the error rate breaches a threshold.
Instrument the application with OpenTelemetry, send metrics, logs and traces to Prometheus, Loki and Tempo, and build Grafana dashboards with SLO burn-rate alerts. Run a game day that injects a failure and publish a blameless postmortem.
Create a Backstage software template that scaffolds a new service with a repository, CI pipeline, Kubernetes manifests and Kyverno policies. Collect deployment and incident events to report all five DORA metrics on a dashboard.
Certifications that validate this path’s skills. Always confirm the current exam version on the official page before booking.
Amazon Web Services
The flagship AWS DevOps credential (exam DOP-C02), covering CI/CD, IaC, monitoring and incident response on AWS.
Official pageMicrosoft
Validates source control, pipelines, security and instrumentation with Azure DevOps and GitHub; requires an Azure associate-level certification first.
Official pageGoogle Cloud
Combines CI/CD, SRE practices and observability on Google Cloud, a good match for the later stages of this path.
Official pageCNCF / Linux Foundation
Hands-on, performance-based proof that you can install, operate and troubleshoot Kubernetes clusters.
Official pageHashiCorp
The current 004 exam tests Terraform 1.12 workflows, modules and state, matching the infrastructure as code stage.
Official pageDevOpsSchool
A vendor-neutral, project-based certification covering the end-to-end DevOps toolchain taught in this path.
Official pageRoles that hire for these skills.
Builds and maintains CI/CD pipelines, infrastructure as code and deployment automation. Works with development teams to shorten lead time and keep releases safe.
Owns build systems, artifact repositories, versioning and release orchestration. Makes every commit produce a traceable, deployable artifact.
Designs and provisions cloud networks, identity, compute and managed Kubernetes with Terraform or OpenTofu. Balances security, reliability and cost.
Turns DevOps practices into a self-service internal platform with golden paths, templates and paved roads. Treats developers as customers and the platform as a product.
Runs production services against SLOs, leads incident response and postmortems, and engineers away toil. Often the next step after a DevOps role.
Yes. Platform engineering and AI build on DevOps rather than replace it: someone still has to design pipelines, infrastructure, observability and guardrails. DORA's 2025 research found AI amplifies existing practices, so engineers who can build strong delivery foundations are more valuable, not less.
You need to be comfortable scripting and reading code, but you do not need to be a senior software developer. Bash and Python cover most automation, and you will write a lot of YAML and HCL. Being able to read application code helps enormously when debugging builds and production issues.
At about 10 hours a week, this path takes roughly eight months including projects. People with a Linux or development background often move faster. Getting job-ready depends more on finished, demonstrable projects than on the number of tools you have touched.
Pick the one most used by employers in your target market or by your current company; AWS has the largest share, and Azure is strong in enterprises that run Microsoft software. Go deep on one first, because identity, networking and managed services concepts transfer between providers.
DevOps is the overall culture and practice of delivering software quickly and safely. SRE applies software engineering to operations with explicit reliability targets such as SLOs and error budgets. Platform engineering builds an internal product that gives developers self-service, paved-road access to DevOps capabilities.
If you are early in your career, start with a cloud associate certification or the HashiCorp Terraform Associate, then aim for CKA. Once you have hands-on experience, the AWS DevOps Engineer Professional, Microsoft AZ-400 or Google Professional Cloud DevOps Engineer match the cloud you use most.
Learn the shared HCL language and workflow, and you will be productive with both. Terraform is still the most widely deployed and has the HashiCorp certification, while OpenTofu is an open-source CNCF project adding features such as built-in state encryption; check which one your target employers use.
Join DevOpsSchool instructor-led programs with hands-on labs, real-world projects and certification guidance.
Roadmap reviewed October 2026 · Last updated 26 Oct 2026 · JSON