DevOps Engineer Roadmap 2026: Linux, CI/CD, Docker, Kubernetes, Terraform and Observability, in the Order Jobs Test Them
The 2026 DevOps roadmap as a web page: five phases from Linux and networking to platform engineering, nine skill areas with the proof each one needs, five portfolio projects, a weekly operating system and a 30-60-90 day plan. The PDF is linked below; this page is the same roadmap with the reasoning written out.
By Durgesh Yadav — Senior Data Engineer @ 7-Eleven · Updated 28 Sept 2026. Preparation guidance, not a hiring guarantee.
How long does it take to become a DevOps engineer?
Six to twelve months of consistent part-time work, in five phases: Linux, networking and Git in the first month; CI/CD and containers by month two; cloud and Terraform by month four; Kubernetes with GitOps by month six; then observability, security and platform engineering through month twelve. Each phase in PrepNPlaced's roadmap ends in a public artifact, and five of them make the portfolio you apply with.
What does the 2026 DevOps roadmap look like, phase by phase?
Five phases, each ending in something a hiring manager can open. The order is the order production systems depend on each other: you cannot debug a pipeline without Linux, cannot run Kubernetes without containers, and cannot keep any of it up without observability.
The goal at the end is stated plainly in the PDF: build and operate reliable software delivery platforms, automate infrastructure, deploy safely, monitor systems, secure the supply chain and improve developer productivity. In 2026 that job is advertised as DevOps Engineer, Cloud Engineer, Platform Engineer, Site Reliability Engineer, Infrastructure Engineer, DevSecOps Engineer or Build and Release Engineer; the roadmap covers all seven titles.
Weeks 0-4, Linux, networking and Git: shell, processes, services, permissions, TCP/IP, DNS, HTTP, SSH and Git workflows. Proof: run and troubleshoot services on Linux.
Months 1-2, CI/CD and containers: GitHub Actions or GitLab CI, Dockerfiles, Compose, registries, artifact management, release strategies. Proof: a pipeline that tests, builds and deploys a containerised app.
Months 2-4, cloud and infrastructure as code: AWS, Azure or GCP basics, IAM, VPC, compute, storage, databases, Terraform modules, secrets. Proof: provision cloud infrastructure with Terraform and document it.
Months 4-6, Kubernetes and GitOps: pods, deployments, services, ingress, config, secrets, Helm, autoscaling, Argo CD, policies. Proof: deploy a microservice stack to Kubernetes with GitOps.
Months 6-12, reliability, security and platforms: observability, SLOs, incident response, supply-chain security, platform portals, FinOps, AI-assisted operations. Proof: a production platform portfolio with runbooks and dashboards.
What comes first: Linux, networking or a cloud certification?
Linux and networking, and not a certification. Every later phase is debugged from a shell: a failing pipeline step, a pod stuck in CrashLoopBackOff, a Terraform apply that times out on a security group. The first month is the filesystem, permissions, processes, systemd, logs, package managers, shell scripting, Python for automation and cron, then TCP/IP, DNS, HTTP and TLS, load balancers, proxies, firewalls, CIDR, NAT and service discovery.
The proof for the phase is not a badge. It is one failing service you debugged from its logs to a fix, written up, and one diagram that explains the path of a request through a system you built. Interviewers ask for exactly those two things in the first technical round, whatever the cloud.
Linux proof: debug a failing service from logs to fix, with the commands you ran
Networking proof: explain the path of one request through your own system, hop by hop
Git proof: a branching and review workflow you can defend, not only commands you know
Certifications come later and only where a target employer names one; they never replace the two proofs above
How much of the roadmap is CI/CD and containers?
The whole of month two, and it never stops mattering. CI/CD is where DevOps work is visible to everyone else in the company, so the phase is judged on a running pipeline rather than on vocabulary: pipelines with test stages, artifacts, container builds, deployment strategies (blue/green, canary, feature flags) and a rollback that has been exercised.
Docker is learned inside the same phase because the pipeline ships an image: Dockerfiles, Compose for local stacks, registries, image size and layer caching. The first portfolio project, a CI/CD production pipeline that tests, builds, scans, pushes and deploys a containerised app, is the phase's exit ticket. Add canary or rollback and security scanning as the stretch goal and it doubles as the security phase's first artifact.
Pipeline stages an interviewer expects to see
Lint and unit tests; build the image with a content-addressed tag; scan the image and dependencies; push to a registry; deploy to a staging target; smoke test; promote or roll back. Each stage fails loudly and the README says what happens when it does.
The rollback question
'Your deploy went out and error rates doubled. What now?' The answer is a command you have run before, a dashboard you looked at to decide, and the postmortem you wrote afterwards. The roadmap's observability project supplies all three.
When do Terraform, Kubernetes and GitOps enter, and in what order?
Terraform in months two to four, Kubernetes in months four to six, GitOps as soon as there is a cluster to point Argo CD at. Terraform comes first because a cluster needs a network, IAM and storage to live in, and because state, modules, drift and environment separation are the concepts cloud interviews test hardest.
The Kubernetes phase is the object model in production terms: pods, deployments, services, ingress, ConfigMaps, secrets, horizontal pod autoscaling, volumes, probes, resource limits, Helm for packaging and Argo CD for delivery. The proof is a resilient app on Kubernetes deployed through GitOps, with network policy and resource limits as the stretch. The second and third portfolio projects (a Terraform cloud platform with VPC, compute, database, object storage and IAM; a Kubernetes microservices platform with ingress, HPA, secrets and Helm) come out of these two phases.
GitOps: Argo CD watching a repo, so the cluster's state is a pull request, not a person
Cloud choice: in PrepNPlaced's India Tech Hiring Report (17,748 live postings, 23 August to 27 September 2026) Azure was named in 20.5% of postings and AWS in 18.0%; learn the one your target employers name
What do observability, security and platform engineering add in months six to twelve?
The difference between running software and being trusted to run it. Observability is metrics, logs and traces with Prometheus, Grafana and OpenTelemetry, then the SRE layer on top: SLOs, error budgets, alert fatigue, on-call, postmortems. Security and supply chain is OWASP, container scanning, SBOMs, secret scanning, least-privilege IAM, policy as code, vulnerability management and incident response, wired into the pipeline as gates rather than kept on a separate team's checklist.
Platform engineering is where 2026 hiring is heading, and the PDF's market calibration says so directly: DevOps is converging with platform engineering, DevSecOps, SRE and cloud cost management. Internal developer platforms, golden paths, service catalogs, Backstage, templates and self-service are the topics; a simple developer portal or paved-road template is the proof. FinOps closes the phase: tagging, budgets, rightsizing, autoscaling, storage lifecycle, cost dashboards and GPU cost awareness, with cost controls added to your own architecture as the artifact.
Observability proof: dashboards and alerts tied to user impact, then a simulated incident with a postmortem
Security proof: security gates in your CI/CD pipeline, with one finding fixed
Platform proof: a self-service template that creates and deploys a service
FinOps proof: cost controls on your cloud architecture, with the before and after bill
Which portfolio projects prove you are job-ready?
Five, and none of them tutorial clones. Each project has a README, an architecture diagram, setup steps, screenshots, a demo link where possible, tests or checks, stated limitations and a next-steps list. Hiring managers open the repo before they open the resume; the README is the interview before the interview.
1. CI/CD production pipeline: test, build, scan, push and deploy a containerised app (GitHub Actions, Docker, a registry, a cloud or local server). Stretch: canary or rollback plus security scanning.
2. Terraform cloud platform: provision VPC, compute, database, object storage and IAM on AWS, Azure or GCP. Stretch: modules, remote state and environment separation.
3. Kubernetes microservices platform: services with ingress, HPA, secrets and Helm, delivered by Argo CD. Stretch: network policy and resource limits.
4. Observability stack: metrics, logs, traces and an SLO dashboard for a working app (Prometheus, Grafana, OpenTelemetry). Stretch: run a simulated incident and write the postmortem.
5. Internal developer platform: a self-service template to create and deploy a service (Backstage or GitHub templates, CI/CD, Kubernetes). Stretch: measure the developer-experience improvement.
The portfolio checklist before applying
One CI/CD pipeline with tests, scans and deployment; one Terraform cloud project; one Kubernetes or GitOps project; one observability incident simulation with dashboard and postmortem; diagrams, runbooks and cost notes for all of them.
Resume keywords, when they are true
Linux, Bash or Python, networking, Git, CI/CD, Docker, Kubernetes, Helm, Terraform, AWS, Azure or GCP, Prometheus, Grafana, OpenTelemetry, GitOps, security scanning, incident response, FinOps. Every one of them should point at a repo, a dashboard or a runbook that an interviewer can open.
What does the DevOps interview test, and how do you run the week?
Six things, in most loops: Linux troubleshooting and shell scripting; designing CI/CD for a service with rollback and security gates; explaining Kubernetes objects and debugging a failing deployment; designing cloud infrastructure with IAM, networking and cost controls; discussing observability, SLOs, incidents and postmortems; and explaining Terraform state, drift and module design. The five projects are built so that each question has an artifact behind it.
The week is ten to twelve hours, split so building beats watching: 60% project implementation, 20% documentation, 10% videos or a course for intuition, 10% notes and revision. Minimum weekly output is five commits, one written note, one demo screenshot or video and five to twenty practice problems. Every Sunday: review blockers, update the README, write what you learned, plan the next week and compare it against target job descriptions. Every month: ship one small project or one milestone of the capstone.
The 30-60-90 plan compresses that: days 1-30 finish the basics and publish one small project with notes; days 31-60 build a stronger project with tests and a case study; days 61-90 deploy the capstone, draw the architecture, record the demo and start mock interviews and applications. The mistakes the roadmap warns against are the usual ones: only watching videos, building tutorial clones without explaining trade-offs, skipping documentation, testing, security and observability, shipping AI-generated code you cannot debug, and applying before the portfolio proves the role's core responsibilities.
Related Guides
Keep Preparing
Move between roadmaps, interview questions, and tools without losing your preparation thread.
The roadmap does not require a degree or prior experience, but the market is honest about the odds: in PrepNPlaced's India Tech Hiring Report (17,748 live postings, 23 August to 27 September 2026), only 4.5% of postings across all roles were entry- or junior-level, and DevOps roles skew senior because someone has to be trusted with production. The five projects are how a fresher gets past that filter; a Cloud Engineer or Build and Release title is a common first step.
AWS, Azure or GCP first?
Whichever your target employers name. In the same report Azure appeared in 20.5% of Indian postings and AWS in 18.0%, with GCP behind both, so an Azure-first path is defensible in India even though most global tutorials assume AWS. The Terraform phase transfers: state, modules and drift are the same concepts on every cloud.
Docker or Kubernetes first?
Docker, in month two, because Kubernetes runs the images you build there and every Kubernetes debugging session starts with a container that will not start. Kubernetes waits until months four to six, after Terraform has given you somewhere to run it.
Do I need to learn to code?
Scripting, yes: Bash for the shell and Python for automation are in the first phase, and Terraform is code with state. You do not need data-structures-and-algorithms depth for most DevOps loops, though product companies sometimes add a short coding round; the roadmap's practice-platform list includes LeetCode and NeetCode for that case.
How many hours a week does the roadmap assume?
Ten to twelve, with 60% of that spent building. At that pace the five phases take six to twelve months. With less time, stretch the calendar rather than skipping the proofs; a Kubernetes project you can explain beats three you cannot.
Is the roadmap free, and where is the PDF?
Yes. This page is the web version of the free PDF prepared on 31 May 2026, linked in the button above and on the 2026 Tech Career Roadmaps page, which also carries a Top 50 DevOps Engineer Interview Questions deck. Nothing on this page needs an account.
Next Step
Turn The Guide Into Practice
Use PrepNPlaced tools to turn this learning path into resume proof, targeted practice, and interview-ready explanations.