{
    "schema": 1,
    "slug": "devops",
    "title": "DevOps",
    "full_name": "DevOps Engineering",
    "category": "Delivery & Automation",
    "tagline": "Go from Linux and Git to shipping secure, observable software on Kubernetes and the cloud, on demand.",
    "summary": "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.",
    "description": "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.\n\nIn 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.\n\nThis 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.",
    "icon": "all_inclusive",
    "accent": "#3B82F6",
    "level": "Beginner → Advanced",
    "duration_weeks": 32,
    "weekly_hours": 10,
    "audience": [
        "Developers who want to own how their code is built, deployed and run",
        "System administrators and support engineers moving into automation and cloud",
        "Fresh graduates and career changers targeting their first DevOps or cloud role",
        "QA and release engineers who want to automate testing and delivery end to end",
        "Tech leads who need a clear map of modern delivery practices for their team"
    ],
    "prerequisites": [
        "Comfort using a computer and installing software from the command line",
        "Basic programming knowledge in any language (variables, loops, functions)",
        "A laptop that can run Docker and a local Kubernetes cluster such as kind (8 GB RAM minimum, 16 GB recommended)",
        "A free-tier account on one cloud provider (AWS, Microsoft Azure or Google Cloud)"
    ],
    "outcomes": [
        "Administer Linux servers and automate routine operations with Bash and Python",
        "Run a trunk-based Git workflow with protected branches, code review and required checks",
        "Build CI/CD pipelines that test, scan, sign and publish artifacts with SBOMs and provenance",
        "Containerise applications and deploy them to Kubernetes with Helm, Kustomize and GitOps",
        "Provision cloud infrastructure with Terraform or OpenTofu using reviewed, versioned modules",
        "Instrument services with OpenTelemetry and operate them against SLOs with actionable alerts",
        "Embed security scanning, secrets management and policy as code into the delivery pipeline",
        "Measure delivery performance with the five DORA metrics and use them to drive improvement"
    ],
    "trends": [
        "DORA's 2025 State of AI-assisted Software Development report found AI adoption near 90% and showed it raises throughput but also instability unless teams work in small batches with strong version control and quality platforms.",
        "DORA now tracks five delivery metrics, adding deployment rework rate to the original four and grouping them into throughput and instability.",
        "Platform engineering has gone mainstream: DORA reports that about 90% of organisations now use internal platforms, and CNCF launched platform engineering certifications (CNPA and CNPE).",
        "Software supply chain security is now a compliance topic: SBOMs, Sigstore signing and SLSA provenance are expected, and the EU Cyber Resilience Act's vulnerability reporting duties began in September 2026.",
        "Kubernetes networking is shifting to Gateway API after the community retired Ingress NGINX in March 2026, and OpenTelemetry has become the default way to instrument services.",
        "AI agents connected through the Model Context Protocol (MCP) are starting to open pull requests and triage incidents, which makes reviewable, Git-based workflows and guardrails even more important."
    ],
    "roles": [
        {
            "title": "DevOps Engineer",
            "description": "Builds and maintains CI/CD pipelines, infrastructure as code and deployment automation. Works with development teams to shorten lead time and keep releases safe."
        },
        {
            "title": "Build and Release Engineer",
            "description": "Owns build systems, artifact repositories, versioning and release orchestration. Makes every commit produce a traceable, deployable artifact."
        },
        {
            "title": "Cloud Infrastructure Engineer",
            "description": "Designs and provisions cloud networks, identity, compute and managed Kubernetes with Terraform or OpenTofu. Balances security, reliability and cost."
        },
        {
            "title": "Platform Engineer",
            "description": "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."
        },
        {
            "title": "Site Reliability Engineer",
            "description": "Runs production services against SLOs, leads incident response and postmortems, and engineers away toil. Often the next step after a DevOps role."
        }
    ],
    "stages": [
        {
            "title": "Foundations: Culture, Linux & Scripting",
            "level": "Beginner",
            "duration_weeks": 5,
            "description": "The DevOps mindset plus the operating system, networking and scripting skills that every later stage builds on.",
            "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.",
            "topics": [
                {
                    "title": "DevOps Culture, SDLC & Flow",
                    "description": "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.",
                    "est_hours": 8,
                    "optional": false,
                    "concepts": [
                        "SDLC, Agile and Kanban",
                        "CALMS and the Three Ways",
                        "value stream mapping",
                        "small batches and fast feedback",
                        "blameless culture",
                        "Team Topologies",
                        "DevOps vs SRE vs platform engineering"
                    ],
                    "tools": [],
                    "resources": [
                        {
                            "title": "DORA Capabilities Catalog",
                            "url": "https://dora.dev/capabilities/",
                            "type": "docs",
                            "free": true
                        },
                        {
                            "title": "Team Topologies: Key Concepts",
                            "url": "https://teamtopologies.com/key-concepts",
                            "type": "article",
                            "free": true
                        },
                        {
                            "title": "DevOps Training and Certification Course — DevOpsSchool",
                            "url": "https://www.devopsschool.com/courses/devops/",
                            "type": "course",
                            "free": false
                        }
                    ]
                },
                {
                    "title": "Linux & the Shell",
                    "description": "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.",
                    "est_hours": 20,
                    "optional": false,
                    "concepts": [
                        "filesystem hierarchy and permissions",
                        "processes and signals",
                        "systemd services and journald",
                        "package management",
                        "users, sudo and SSH keys",
                        "text processing with grep, sed and awk",
                        "namespaces and cgroups"
                    ],
                    "tools": [
                        "Linux",
                        "Bash"
                    ],
                    "resources": [
                        {
                            "title": "The Linux Command Line (free book)",
                            "url": "https://linuxcommand.org/tlcl.php",
                            "type": "book",
                            "free": true
                        },
                        {
                            "title": "Linux SysAdmin (LFCS) Training — DevOpsSchool",
                            "url": "https://www.devopsschool.com/courses/linux/",
                            "type": "course",
                            "free": false
                        }
                    ]
                },
                {
                    "title": "Networking Essentials for DevOps",
                    "description": "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.",
                    "est_hours": 10,
                    "optional": false,
                    "concepts": [
                        "TCP/IP, ports and sockets",
                        "subnets and CIDR",
                        "DNS resolution and record types",
                        "HTTP/1.1, HTTP/2 and HTTP/3",
                        "TLS and certificates",
                        "load balancers and reverse proxies",
                        "troubleshooting with curl, dig, ss and tcpdump"
                    ],
                    "tools": [],
                    "resources": [
                        {
                            "title": "MDN: Overview of HTTP",
                            "url": "https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/Overview",
                            "type": "docs",
                            "free": true
                        },
                        {
                            "title": "High Performance Browser Networking (free book)",
                            "url": "https://hpbn.co/",
                            "type": "book",
                            "free": true
                        }
                    ]
                },
                {
                    "title": "Scripting & Automation with Bash and Python",
                    "description": "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.",
                    "est_hours": 12,
                    "optional": false,
                    "concepts": [
                        "exit codes and set -euo pipefail",
                        "functions, loops and arguments",
                        "Python virtual environments and packages",
                        "working with JSON, YAML and REST APIs",
                        "building small CLIs",
                        "linting with ShellCheck",
                        "idempotent scripts"
                    ],
                    "tools": [
                        "Bash",
                        "Python"
                    ],
                    "resources": [
                        {
                            "title": "The Python Tutorial (official)",
                            "url": "https://docs.python.org/3/tutorial/",
                            "type": "docs",
                            "free": true
                        },
                        {
                            "title": "Bash Scripting Training and Certification Course — DevOpsSchool",
                            "url": "https://www.devopsschool.com/courses/bashscripting/",
                            "type": "course",
                            "free": false
                        },
                        {
                            "title": "Python & Django Training — DevOpsSchool",
                            "url": "https://www.devopsschool.com/courses/python/",
                            "type": "course",
                            "free": false
                        }
                    ]
                }
            ]
        },
        {
            "title": "Version Control & Collaboration",
            "level": "Beginner",
            "duration_weeks": 3,
            "description": "Git as the single source of truth for code, configuration and infrastructure, plus the workflows that keep a team merging small changes often.",
            "milestone": "You can run a team repository with protected branches, pull-request reviews, required checks and a trunk-based workflow.",
            "topics": [
                {
                    "title": "Git Fundamentals",
                    "description": "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.",
                    "est_hours": 14,
                    "optional": false,
                    "concepts": [
                        "commits, branches and HEAD",
                        "merge vs rebase",
                        "resolving conflicts",
                        "remotes: fetch, pull and push",
                        "tags and semantic versioning",
                        "undoing work with revert, reset and reflog",
                        "signed commits"
                    ],
                    "tools": [
                        "Git"
                    ],
                    "resources": [
                        {
                            "title": "Pro Git (free book)",
                            "url": "https://git-scm.com/book/en/v2",
                            "type": "book",
                            "free": true
                        },
                        {
                            "title": "Git Training and Certification Course — DevOpsSchool",
                            "url": "https://www.devopsschool.com/courses/git/",
                            "type": "course",
                            "free": false
                        }
                    ]
                },
                {
                    "title": "Branching Strategy, Pull Requests & Code Review",
                    "description": "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.",
                    "est_hours": 8,
                    "optional": false,
                    "concepts": [
                        "trunk-based development",
                        "short-lived feature branches",
                        "pull and merge requests",
                        "branch protection and required checks",
                        "CODEOWNERS",
                        "feature flags instead of long-lived branches",
                        "conventional commits"
                    ],
                    "tools": [
                        "GitHub",
                        "GitLab"
                    ],
                    "resources": [
                        {
                            "title": "Trunk Based Development",
                            "url": "https://trunkbaseddevelopment.com/",
                            "type": "guide",
                            "free": true
                        },
                        {
                            "title": "DORA Capability: Trunk-based development",
                            "url": "https://dora.dev/capabilities/trunk-based-development/",
                            "type": "article",
                            "free": true
                        },
                        {
                            "title": "GitHub Training and Certification Course — DevOpsSchool",
                            "url": "https://www.devopsschool.com/courses/github/",
                            "type": "course",
                            "free": false
                        }
                    ]
                },
                {
                    "title": "AI-Assisted Development with Guardrails",
                    "description": "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.",
                    "est_hours": 6,
                    "optional": true,
                    "concepts": [
                        "AI as an amplifier of existing practices",
                        "generating code, tests and docs",
                        "reviewing AI-generated changes",
                        "agent-authored pull requests",
                        "Model Context Protocol (MCP) basics",
                        "secret and data leakage risks",
                        "measuring impact on throughput and instability"
                    ],
                    "tools": [],
                    "resources": [
                        {
                            "title": "DORA 2025 State of AI-assisted Software Development",
                            "url": "https://dora.dev/research/2025/dora-report/",
                            "type": "report",
                            "free": true
                        },
                        {
                            "title": "Model Context Protocol documentation",
                            "url": "https://modelcontextprotocol.io/",
                            "type": "docs",
                            "free": true
                        }
                    ]
                }
            ]
        },
        {
            "title": "CI/CD & Software Supply Chain",
            "level": "Intermediate",
            "duration_weeks": 5,
            "description": "Automate build, test, packaging and release so every commit produces a trustworthy, deployable artifact.",
            "milestone": "You can build a pipeline that tests, scans, signs and publishes an artifact, then deploys it with a low-risk release strategy.",
            "topics": [
                {
                    "title": "Continuous Integration & Pipelines as Code",
                    "description": "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.",
                    "est_hours": 16,
                    "optional": false,
                    "concepts": [
                        "stages, jobs and runners",
                        "workflow YAML syntax",
                        "caching and build matrices",
                        "reusable workflows and templates",
                        "OIDC federation to cloud providers",
                        "hosted vs self-hosted runners",
                        "path filters for monorepos"
                    ],
                    "tools": [
                        "GitHub Actions",
                        "GitLab CI/CD",
                        "Jenkins"
                    ],
                    "resources": [
                        {
                            "title": "GitHub Actions documentation",
                            "url": "https://docs.github.com/en/actions",
                            "type": "docs",
                            "free": true
                        },
                        {
                            "title": "GitLab CI/CD documentation",
                            "url": "https://docs.gitlab.com/ci/",
                            "type": "docs",
                            "free": true
                        },
                        {
                            "title": "Continuous Integration & Delivery Training — DevOpsSchool",
                            "url": "https://www.devopsschool.com/courses/continuous-integration/",
                            "type": "course",
                            "free": false
                        }
                    ]
                },
                {
                    "title": "Test Automation & Quality Gates",
                    "description": "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.",
                    "est_hours": 10,
                    "optional": false,
                    "concepts": [
                        "the test pyramid",
                        "unit, integration and contract tests",
                        "ephemeral test environments",
                        "static analysis and code coverage",
                        "quality gates on pull requests",
                        "managing flaky tests"
                    ],
                    "tools": [
                        "SonarQube"
                    ],
                    "resources": [
                        {
                            "title": "DORA Capability: Test automation",
                            "url": "https://dora.dev/capabilities/test-automation/",
                            "type": "article",
                            "free": true
                        },
                        {
                            "title": "SonarQube Server documentation",
                            "url": "https://docs.sonarsource.com/sonarqube-server/",
                            "type": "docs",
                            "free": true
                        },
                        {
                            "title": "SonarQube Training and Certification Course — DevOpsSchool",
                            "url": "https://www.devopsschool.com/courses/sonarqube/",
                            "type": "course",
                            "free": false
                        }
                    ]
                },
                {
                    "title": "Artifacts & Supply Chain Security",
                    "description": "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.",
                    "est_hours": 10,
                    "optional": false,
                    "concepts": [
                        "immutable, versioned artifacts",
                        "container and package registries",
                        "SBOMs in SPDX and CycloneDX",
                        "keyless signing with cosign",
                        "SLSA build provenance",
                        "dependency and image vulnerability scanning",
                        "automated dependency updates"
                    ],
                    "tools": [
                        "Trivy",
                        "Sigstore"
                    ],
                    "resources": [
                        {
                            "title": "SLSA: Supply-chain Levels for Software Artifacts",
                            "url": "https://slsa.dev/",
                            "type": "docs",
                            "free": true
                        },
                        {
                            "title": "Sigstore documentation",
                            "url": "https://docs.sigstore.dev/",
                            "type": "docs",
                            "free": true
                        },
                        {
                            "title": "Trivy documentation",
                            "url": "https://trivy.dev/",
                            "type": "docs",
                            "free": true
                        }
                    ]
                },
                {
                    "title": "Continuous Delivery & Release Strategies",
                    "description": "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.",
                    "est_hours": 10,
                    "optional": false,
                    "concepts": [
                        "deployment pipelines and environments",
                        "blue-green and canary releases",
                        "feature flags and decoupling deploy from release",
                        "automated rollback",
                        "database migrations in CD",
                        "approvals and lightweight change management"
                    ],
                    "tools": [
                        "OpenFeature"
                    ],
                    "resources": [
                        {
                            "title": "DORA Capability: Continuous delivery",
                            "url": "https://dora.dev/capabilities/continuous-delivery/",
                            "type": "article",
                            "free": true
                        },
                        {
                            "title": "OpenFeature documentation",
                            "url": "https://openfeature.dev/docs/reference/intro/",
                            "type": "docs",
                            "free": true
                        },
                        {
                            "title": "Continuous Deployment Training and Certification Course — DevOpsSchool",
                            "url": "https://www.devopsschool.com/courses/continuous-deployment/",
                            "type": "course",
                            "free": false
                        }
                    ]
                }
            ]
        },
        {
            "title": "Containers & Kubernetes",
            "level": "Intermediate",
            "duration_weeks": 6,
            "description": "Package applications as containers and run them on Kubernetes, the default runtime platform for modern services.",
            "milestone": "You can containerise a multi-service app and run it on Kubernetes with Helm or Kustomize, deployed and kept in sync through GitOps.",
            "topics": [
                {
                    "title": "Containers with Docker & Podman",
                    "description": "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.",
                    "est_hours": 14,
                    "optional": false,
                    "concepts": [
                        "images, layers and registries",
                        "Dockerfiles and multi-stage builds",
                        "minimal and distroless base images",
                        "rootless containers",
                        "volumes and container networking",
                        "Compose for local development",
                        "OCI image and runtime specs"
                    ],
                    "tools": [
                        "Docker",
                        "Podman"
                    ],
                    "resources": [
                        {
                            "title": "Docker: Get started",
                            "url": "https://docs.docker.com/get-started/",
                            "type": "tutorial",
                            "free": true
                        },
                        {
                            "title": "Podman documentation",
                            "url": "https://podman.io/docs",
                            "type": "docs",
                            "free": true
                        },
                        {
                            "title": "Docker Training and Certification Course — DevOpsSchool",
                            "url": "https://www.devopsschool.com/courses/docker/",
                            "type": "course",
                            "free": false
                        }
                    ]
                },
                {
                    "title": "Kubernetes Core",
                    "description": "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.",
                    "est_hours": 26,
                    "optional": false,
                    "concepts": [
                        "control plane and nodes",
                        "Pods, Deployments, StatefulSets and Jobs",
                        "Services and Gateway API",
                        "ConfigMaps and Secrets",
                        "requests, limits and autoscaling",
                        "probes and rolling updates",
                        "RBAC and namespaces",
                        "persistent volumes and storage classes"
                    ],
                    "tools": [
                        "Kubernetes"
                    ],
                    "resources": [
                        {
                            "title": "Kubernetes Basics (official tutorial)",
                            "url": "https://kubernetes.io/docs/tutorials/kubernetes-basics/",
                            "type": "tutorial",
                            "free": true
                        },
                        {
                            "title": "Gateway API documentation",
                            "url": "https://gateway-api.sigs.k8s.io/",
                            "type": "docs",
                            "free": true
                        },
                        {
                            "title": "Kubernetes & Helm Training — DevOpsSchool",
                            "url": "https://www.devopsschool.com/courses/kubernetes/",
                            "type": "course",
                            "free": false
                        }
                    ]
                },
                {
                    "title": "Packaging with Helm & Kustomize",
                    "description": "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.",
                    "est_hours": 10,
                    "optional": false,
                    "concepts": [
                        "Helm charts, templates and values",
                        "chart repositories and OCI registries",
                        "Helm 4 and server-side apply",
                        "Kustomize bases, overlays and patches",
                        "Helm vs Kustomize trade-offs",
                        "per-environment configuration"
                    ],
                    "tools": [
                        "Helm",
                        "Kustomize"
                    ],
                    "resources": [
                        {
                            "title": "Helm documentation",
                            "url": "https://helm.sh/docs/",
                            "type": "docs",
                            "free": true
                        },
                        {
                            "title": "Kustomize reference",
                            "url": "https://kubectl.docs.kubernetes.io/references/kustomize/",
                            "type": "docs",
                            "free": true
                        }
                    ]
                },
                {
                    "title": "GitOps Continuous Delivery",
                    "description": "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.",
                    "est_hours": 8,
                    "optional": false,
                    "concepts": [
                        "OpenGitOps principles",
                        "pull-based vs push-based deployment",
                        "reconciliation and drift",
                        "sync policies and self-heal",
                        "separating app and config repositories",
                        "rollback by Git revert"
                    ],
                    "tools": [
                        "Argo CD",
                        "Flux"
                    ],
                    "resources": [
                        {
                            "title": "OpenGitOps principles",
                            "url": "https://opengitops.dev/",
                            "type": "docs",
                            "free": true
                        },
                        {
                            "title": "Argo CD documentation",
                            "url": "https://argo-cd.readthedocs.io/en/stable/",
                            "type": "docs",
                            "free": true
                        },
                        {
                            "title": "GitOps Training and Certification Course — DevOpsSchool",
                            "url": "https://www.devopsschool.com/courses/gitops/",
                            "type": "course",
                            "free": false
                        }
                    ]
                }
            ]
        },
        {
            "title": "Cloud & Infrastructure as Code",
            "level": "Intermediate",
            "duration_weeks": 5,
            "description": "Provision and configure cloud infrastructure reproducibly with code and pull requests instead of consoles and tickets.",
            "milestone": "You can provision a production-style cloud environment (network, identity and managed Kubernetes) with reviewed, versioned infrastructure code.",
            "topics": [
                {
                    "title": "Cloud Fundamentals (pick one provider)",
                    "description": "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.",
                    "est_hours": 18,
                    "optional": false,
                    "concepts": [
                        "identity and access management with least privilege",
                        "VPCs, subnets and private networking",
                        "compute, serverless and managed Kubernetes",
                        "object storage and managed databases",
                        "shared responsibility model",
                        "tagging and cost awareness",
                        "Well-Architected reviews"
                    ],
                    "tools": [
                        "AWS",
                        "Microsoft Azure",
                        "Google Cloud"
                    ],
                    "resources": [
                        {
                            "title": "AWS Well-Architected",
                            "url": "https://aws.amazon.com/architecture/well-architected/",
                            "type": "docs",
                            "free": true
                        },
                        {
                            "title": "Azure Well-Architected Framework",
                            "url": "https://learn.microsoft.com/en-us/azure/well-architected/",
                            "type": "docs",
                            "free": true
                        },
                        {
                            "title": "Google Cloud Well-Architected Framework",
                            "url": "https://docs.cloud.google.com/architecture/framework",
                            "type": "docs",
                            "free": true
                        }
                    ]
                },
                {
                    "title": "Infrastructure as Code with Terraform & OpenTofu",
                    "description": "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.",
                    "est_hours": 18,
                    "optional": false,
                    "concepts": [
                        "providers, resources and data sources",
                        "variables, outputs and modules",
                        "remote state, locking and state encryption",
                        "plan and apply in pull requests",
                        "import and refactoring with moved blocks",
                        "testing infrastructure code",
                        "drift detection"
                    ],
                    "tools": [
                        "Terraform",
                        "OpenTofu"
                    ],
                    "resources": [
                        {
                            "title": "Terraform tutorials (HashiCorp)",
                            "url": "https://developer.hashicorp.com/terraform/tutorials",
                            "type": "tutorial",
                            "free": true
                        },
                        {
                            "title": "OpenTofu documentation",
                            "url": "https://opentofu.org/docs/",
                            "type": "docs",
                            "free": true
                        },
                        {
                            "title": "Terraform Training and Certification Course — DevOpsSchool",
                            "url": "https://www.devopsschool.com/courses/terraform/",
                            "type": "course",
                            "free": false
                        }
                    ]
                },
                {
                    "title": "Configuration Management with Ansible",
                    "description": "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.",
                    "est_hours": 10,
                    "optional": false,
                    "concepts": [
                        "inventories and dynamic inventory",
                        "playbooks, roles and collections",
                        "idempotency",
                        "variables and Jinja2 templates",
                        "Ansible Vault",
                        "immutable images vs configuration management"
                    ],
                    "tools": [
                        "Ansible"
                    ],
                    "resources": [
                        {
                            "title": "Ansible documentation",
                            "url": "https://docs.ansible.com/",
                            "type": "docs",
                            "free": true
                        },
                        {
                            "title": "Ansible Training and Certification Course — DevOpsSchool",
                            "url": "https://www.devopsschool.com/courses/ansible/",
                            "type": "course",
                            "free": false
                        }
                    ]
                }
            ]
        },
        {
            "title": "Observability & Reliability",
            "level": "Advanced",
            "duration_weeks": 4,
            "description": "See what your systems are doing in production and run them to explicit reliability targets.",
            "milestone": "You can instrument a service with OpenTelemetry, build dashboards and SLO-based alerts, and lead a blameless incident review.",
            "topics": [
                {
                    "title": "Metrics, Dashboards & Alerting",
                    "description": "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.",
                    "est_hours": 12,
                    "optional": false,
                    "concepts": [
                        "Prometheus data model and PromQL",
                        "exporters and service discovery",
                        "RED and USE methods",
                        "Grafana dashboards",
                        "Alertmanager routing",
                        "symptom-based alerting and alert fatigue"
                    ],
                    "tools": [
                        "Prometheus",
                        "Grafana"
                    ],
                    "resources": [
                        {
                            "title": "Prometheus overview",
                            "url": "https://prometheus.io/docs/introduction/overview/",
                            "type": "docs",
                            "free": true
                        },
                        {
                            "title": "Grafana documentation",
                            "url": "https://grafana.com/docs/grafana/latest/",
                            "type": "docs",
                            "free": true
                        },
                        {
                            "title": "Prometheus Training and Certification Course — DevOpsSchool",
                            "url": "https://www.devopsschool.com/courses/prometheus/",
                            "type": "course",
                            "free": false
                        }
                    ]
                },
                {
                    "title": "OpenTelemetry, Logs & Traces",
                    "description": "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.",
                    "est_hours": 12,
                    "optional": false,
                    "concepts": [
                        "OpenTelemetry SDKs and auto-instrumentation",
                        "Collector pipelines",
                        "distributed tracing and context propagation",
                        "structured logging",
                        "log aggregation",
                        "correlating metrics, logs and traces",
                        "sampling and telemetry cost control"
                    ],
                    "tools": [
                        "OpenTelemetry",
                        "Loki",
                        "Tempo",
                        "Jaeger"
                    ],
                    "resources": [
                        {
                            "title": "OpenTelemetry documentation",
                            "url": "https://opentelemetry.io/docs/",
                            "type": "docs",
                            "free": true
                        },
                        {
                            "title": "Grafana Loki documentation",
                            "url": "https://grafana.com/docs/loki/latest/",
                            "type": "docs",
                            "free": true
                        },
                        {
                            "title": "OpenTelemetry Training and Certification Course — DevOpsSchool",
                            "url": "https://www.devopsschool.com/courses/opentelemetry/",
                            "type": "course",
                            "free": false
                        }
                    ]
                },
                {
                    "title": "SRE Practices: SLOs & Incident Response",
                    "description": "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.",
                    "est_hours": 10,
                    "optional": false,
                    "concepts": [
                        "SLIs, SLOs and error budgets",
                        "burn-rate alerts",
                        "on-call and escalation",
                        "incident command",
                        "blameless postmortems",
                        "toil reduction",
                        "chaos engineering basics"
                    ],
                    "tools": [
                        "PagerDuty"
                    ],
                    "resources": [
                        {
                            "title": "Site Reliability Engineering (free book, Google)",
                            "url": "https://sre.google/sre-book/table-of-contents/",
                            "type": "book",
                            "free": true
                        },
                        {
                            "title": "The Site Reliability Workbook (free book, Google)",
                            "url": "https://sre.google/workbook/table-of-contents/",
                            "type": "book",
                            "free": true
                        },
                        {
                            "title": "SRE Training and Certification Course — DevOpsSchool",
                            "url": "https://www.devopsschool.com/courses/sre/",
                            "type": "course",
                            "free": false
                        }
                    ]
                }
            ]
        },
        {
            "title": "DevSecOps, Platforms & Continuous Improvement",
            "level": "Advanced",
            "duration_weeks": 4,
            "description": "Build security and policy into the pipeline, offer self-service golden paths, and use data to keep improving delivery.",
            "milestone": "You can run a secure, policy-guarded delivery platform with a golden path and report DORA metrics that drive concrete improvements.",
            "topics": [
                {
                    "title": "Shift-Left Security in the Pipeline",
                    "description": "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.",
                    "est_hours": 10,
                    "optional": false,
                    "concepts": [
                        "SAST and software composition analysis",
                        "secret scanning",
                        "container and IaC scanning",
                        "OWASP Top 10 awareness",
                        "vulnerability triage and fix SLAs",
                        "threat modelling basics",
                        "DAST in staging"
                    ],
                    "tools": [
                        "Trivy",
                        "Snyk",
                        "SonarQube"
                    ],
                    "resources": [
                        {
                            "title": "OWASP DevSecOps Guideline",
                            "url": "https://owasp.org/projects/devsecops-guideline",
                            "type": "guide",
                            "free": true
                        },
                        {
                            "title": "DevSecOps Training and Certification Course — DevOpsSchool",
                            "url": "https://www.devopsschool.com/courses/devsecops/",
                            "type": "course",
                            "free": false
                        }
                    ]
                },
                {
                    "title": "Secrets Management & Policy as Code",
                    "description": "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.",
                    "est_hours": 10,
                    "optional": false,
                    "concepts": [
                        "dynamic secrets and short-lived credentials",
                        "workload identity and OIDC",
                        "Vault secrets engines and auth methods",
                        "Kubernetes admission control",
                        "Kyverno policies",
                        "OPA and Rego",
                        "policy checks in CI vs at admission"
                    ],
                    "tools": [
                        "Vault",
                        "OPA",
                        "Kyverno"
                    ],
                    "resources": [
                        {
                            "title": "Vault documentation",
                            "url": "https://developer.hashicorp.com/vault/docs",
                            "type": "docs",
                            "free": true
                        },
                        {
                            "title": "Kyverno documentation",
                            "url": "https://kyverno.io/docs/",
                            "type": "docs",
                            "free": true
                        },
                        {
                            "title": "HashiCorp Vault Training and Certification Course — DevOpsSchool",
                            "url": "https://www.devopsschool.com/courses/vault/",
                            "type": "course",
                            "free": false
                        }
                    ]
                },
                {
                    "title": "Platform Engineering & Golden Paths",
                    "description": "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.",
                    "est_hours": 8,
                    "optional": false,
                    "concepts": [
                        "internal developer platforms",
                        "platform as a product",
                        "golden paths and software templates",
                        "service catalog and ownership",
                        "self-service infrastructure APIs",
                        "developer experience feedback"
                    ],
                    "tools": [
                        "Backstage"
                    ],
                    "resources": [
                        {
                            "title": "CNCF Platforms White Paper",
                            "url": "https://tag-app-delivery.cncf.io/whitepapers/platforms/",
                            "type": "article",
                            "free": true
                        },
                        {
                            "title": "What is Backstage?",
                            "url": "https://backstage.io/docs/overview/what-is-backstage/",
                            "type": "docs",
                            "free": true
                        }
                    ]
                },
                {
                    "title": "Measuring & Improving Delivery with DORA Metrics",
                    "description": "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.",
                    "est_hours": 6,
                    "optional": false,
                    "concepts": [
                        "change lead time and deployment frequency",
                        "failed deployment recovery time",
                        "change fail rate and deployment rework rate",
                        "throughput vs instability",
                        "DORA AI Capabilities Model",
                        "value stream management",
                        "avoiding metric gaming"
                    ],
                    "tools": [],
                    "resources": [
                        {
                            "title": "DORA's software delivery performance metrics",
                            "url": "https://dora.dev/guides/dora-metrics/",
                            "type": "guide",
                            "free": true
                        },
                        {
                            "title": "DORA 2025 State of AI-assisted Software Development",
                            "url": "https://dora.dev/research/2025/dora-report/",
                            "type": "report",
                            "free": true
                        }
                    ]
                }
            ]
        }
    ],
    "projects": [
        {
            "title": "Linux Ops Toolkit in Git",
            "description": "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.",
            "difficulty": "Beginner",
            "skills": [
                "Linux",
                "Bash",
                "Python",
                "Git",
                "GitHub Actions"
            ]
        },
        {
            "title": "Secure CI Pipeline for a Containerised App",
            "description": "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.",
            "difficulty": "Intermediate",
            "skills": [
                "Docker",
                "GitHub Actions",
                "SonarQube",
                "Trivy",
                "SBOM",
                "Sigstore"
            ]
        },
        {
            "title": "Cloud Landing Zone with Infrastructure as Code",
            "description": "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.",
            "difficulty": "Intermediate",
            "skills": [
                "Terraform",
                "OpenTofu",
                "AWS",
                "Kubernetes",
                "CI/CD"
            ]
        },
        {
            "title": "GitOps Delivery with Canary Releases",
            "description": "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.",
            "difficulty": "Advanced",
            "skills": [
                "Kubernetes",
                "Helm",
                "Kustomize",
                "Argo CD",
                "Argo Rollouts",
                "Prometheus"
            ]
        },
        {
            "title": "Observability and SLO Stack",
            "description": "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.",
            "difficulty": "Advanced",
            "skills": [
                "OpenTelemetry",
                "Prometheus",
                "Grafana",
                "Loki",
                "Tempo",
                "SRE"
            ]
        },
        {
            "title": "Golden Path Platform with a DORA Dashboard",
            "description": "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.",
            "difficulty": "Advanced",
            "skills": [
                "Backstage",
                "Kyverno",
                "GitHub Actions",
                "Kubernetes",
                "DORA metrics"
            ]
        }
    ],
    "certifications": [
        {
            "name": "AWS Certified DevOps Engineer – Professional",
            "provider": "Amazon Web Services",
            "url": "https://aws.amazon.com/certification/certified-devops-engineer-professional/",
            "level": "Professional",
            "note": "The flagship AWS DevOps credential (exam DOP-C02), covering CI/CD, IaC, monitoring and incident response on AWS."
        },
        {
            "name": "Microsoft Certified: DevOps Engineer Expert (AZ-400)",
            "provider": "Microsoft",
            "url": "https://learn.microsoft.com/en-us/credentials/certifications/devops-engineer/",
            "level": "Expert",
            "note": "Validates source control, pipelines, security and instrumentation with Azure DevOps and GitHub; requires an Azure associate-level certification first."
        },
        {
            "name": "Google Cloud Professional Cloud DevOps Engineer",
            "provider": "Google Cloud",
            "url": "https://cloud.google.com/learn/certification/cloud-devops-engineer",
            "level": "Professional",
            "note": "Combines CI/CD, SRE practices and observability on Google Cloud, a good match for the later stages of this path."
        },
        {
            "name": "Certified Kubernetes Administrator (CKA)",
            "provider": "CNCF / Linux Foundation",
            "url": "https://training.linuxfoundation.org/certification/certified-kubernetes-administrator-cka/",
            "level": "Professional",
            "note": "Hands-on, performance-based proof that you can install, operate and troubleshoot Kubernetes clusters."
        },
        {
            "name": "HashiCorp Certified: Terraform Associate (004)",
            "provider": "HashiCorp",
            "url": "https://developer.hashicorp.com/certifications/terraform-associate",
            "level": "Associate",
            "note": "The current 004 exam tests Terraform 1.12 workflows, modules and state, matching the infrastructure as code stage."
        },
        {
            "name": "DevOps Certified Professional (DCP)",
            "provider": "DevOpsSchool",
            "url": "https://www.devopsschool.com/certification/devops-certified-professional-dcp.html",
            "level": "Professional",
            "note": "A vendor-neutral, project-based certification covering the end-to-end DevOps toolchain taught in this path."
        }
    ],
    "tools_catalog": [
        {
            "name": "Ansible",
            "category": "Infrastructure as Code & Automation",
            "website": "https://docs.ansible.com/",
            "ds_course_url": "https://www.devopsschool.com/courses/ansible/"
        },
        {
            "name": "Argo CD",
            "category": "GitOps",
            "website": "https://argo-cd.readthedocs.io/",
            "ds_course_url": "https://www.devopsschool.com/courses/argo/"
        },
        {
            "name": "AWS",
            "category": "Cloud Platforms & Governance",
            "website": "https://aws.amazon.com/",
            "ds_course_url": "https://www.devopsschool.com/courses/aws/"
        },
        {
            "name": "Backstage",
            "category": "Platform Engineering",
            "website": "https://backstage.io/",
            "ds_course_url": ""
        },
        {
            "name": "Bash",
            "category": "Foundations & Languages",
            "website": "https://www.gnu.org/software/bash/",
            "ds_course_url": "https://www.devopsschool.com/courses/bashscripting/"
        },
        {
            "name": "Docker",
            "category": "Containers & Kubernetes",
            "website": "https://www.docker.com/",
            "ds_course_url": "https://www.devopsschool.com/courses/docker/"
        },
        {
            "name": "Flux",
            "category": "GitOps",
            "website": "https://fluxcd.io/",
            "ds_course_url": "https://www.devopsschool.com/courses/flux/"
        },
        {
            "name": "Git",
            "category": "Foundations & Languages",
            "website": "https://git-scm.com/",
            "ds_course_url": "https://www.devopsschool.com/courses/git/"
        },
        {
            "name": "GitHub",
            "category": "Foundations & Languages",
            "website": "https://github.com/",
            "ds_course_url": "https://www.devopsschool.com/courses/github/"
        },
        {
            "name": "GitHub Actions",
            "category": "CI/CD & Release",
            "website": "https://github.com/features/actions",
            "ds_course_url": "https://www.devopsschool.com/courses/github/"
        },
        {
            "name": "GitLab",
            "category": "Foundations & Languages",
            "website": "https://about.gitlab.com/",
            "ds_course_url": "https://www.devopsschool.com/courses/gitlab/"
        },
        {
            "name": "GitLab CI/CD",
            "category": "CI/CD & Release",
            "website": "https://docs.gitlab.com/ci/",
            "ds_course_url": "https://www.devopsschool.com/courses/gitlab/"
        },
        {
            "name": "Google Cloud",
            "category": "Cloud Platforms & Governance",
            "website": "https://cloud.google.com/",
            "ds_course_url": "https://www.devopsschool.com/courses/googlecloud/"
        },
        {
            "name": "Grafana",
            "category": "Observability",
            "website": "https://grafana.com/",
            "ds_course_url": "https://www.devopsschool.com/courses/grafana/"
        },
        {
            "name": "Helm",
            "category": "Containers & Kubernetes",
            "website": "https://helm.sh/",
            "ds_course_url": "https://www.devopsschool.com/courses/kubernetes/"
        },
        {
            "name": "Jaeger",
            "category": "Observability",
            "website": "https://www.jaegertracing.io/",
            "ds_course_url": "https://www.devopsschool.com/courses/jaeger/"
        },
        {
            "name": "Jenkins",
            "category": "CI/CD & Release",
            "website": "https://www.jenkins.io/",
            "ds_course_url": "https://www.devopsschool.com/courses/jenkins/"
        },
        {
            "name": "Kubernetes",
            "category": "Containers & Kubernetes",
            "website": "https://kubernetes.io/",
            "ds_course_url": "https://www.devopsschool.com/courses/kubernetes/"
        },
        {
            "name": "Kustomize",
            "category": "Containers & Kubernetes",
            "website": "https://kustomize.io/",
            "ds_course_url": ""
        },
        {
            "name": "Kyverno",
            "category": "Policy as Code & Secrets",
            "website": "https://kyverno.io/",
            "ds_course_url": ""
        },
        {
            "name": "Linux",
            "category": "Foundations & Languages",
            "website": "https://www.kernel.org/",
            "ds_course_url": "https://www.devopsschool.com/courses/linux/"
        },
        {
            "name": "Loki",
            "category": "Observability",
            "website": "https://grafana.com/oss/loki/",
            "ds_course_url": ""
        },
        {
            "name": "Microsoft Azure",
            "category": "Cloud Platforms & Governance",
            "website": "https://azure.microsoft.com/",
            "ds_course_url": "https://www.devopsschool.com/courses/azure/"
        },
        {
            "name": "OPA",
            "category": "Policy as Code & Secrets",
            "website": "https://www.openpolicyagent.org/",
            "ds_course_url": "https://www.devopsschool.com/courses/opa/"
        },
        {
            "name": "OpenFeature",
            "category": "CI/CD & Release",
            "website": "https://openfeature.dev/",
            "ds_course_url": ""
        },
        {
            "name": "OpenTelemetry",
            "category": "Observability",
            "website": "https://opentelemetry.io/",
            "ds_course_url": "https://www.devopsschool.com/courses/opentelemetry/"
        },
        {
            "name": "OpenTofu",
            "category": "Infrastructure as Code & Automation",
            "website": "https://opentofu.org/",
            "ds_course_url": "https://www.devopsschool.com/courses/opentofu/"
        },
        {
            "name": "PagerDuty",
            "category": "AIOps & Incident Management",
            "website": "https://www.pagerduty.com/",
            "ds_course_url": ""
        },
        {
            "name": "Podman",
            "category": "Containers & Kubernetes",
            "website": "https://podman.io/",
            "ds_course_url": "https://www.devopsschool.com/courses/podman/"
        },
        {
            "name": "Prometheus",
            "category": "Observability",
            "website": "https://prometheus.io/",
            "ds_course_url": "https://www.devopsschool.com/courses/prometheus/"
        },
        {
            "name": "Python",
            "category": "Foundations & Languages",
            "website": "https://www.python.org/",
            "ds_course_url": "https://www.devopsschool.com/courses/python/"
        },
        {
            "name": "Sigstore",
            "category": "Security & Supply Chain",
            "website": "https://www.sigstore.dev/",
            "ds_course_url": ""
        },
        {
            "name": "Snyk",
            "category": "Security & Supply Chain",
            "website": "https://snyk.io/",
            "ds_course_url": ""
        },
        {
            "name": "SonarQube",
            "category": "Security & Supply Chain",
            "website": "https://www.sonarsource.com/products/sonarqube/",
            "ds_course_url": "https://www.devopsschool.com/courses/sonarqube/"
        },
        {
            "name": "Tempo",
            "category": "Observability",
            "website": "https://grafana.com/oss/tempo/",
            "ds_course_url": ""
        },
        {
            "name": "Terraform",
            "category": "Infrastructure as Code & Automation",
            "website": "https://developer.hashicorp.com/terraform",
            "ds_course_url": "https://www.devopsschool.com/courses/terraform/"
        },
        {
            "name": "Trivy",
            "category": "Security & Supply Chain",
            "website": "https://trivy.dev/",
            "ds_course_url": ""
        },
        {
            "name": "Vault",
            "category": "Policy as Code & Secrets",
            "website": "https://developer.hashicorp.com/vault",
            "ds_course_url": "https://www.devopsschool.com/courses/vault/"
        }
    ],
    "faqs": [
        {
            "q": "Is DevOps still a good career in 2026 with platform engineering and AI on the rise?",
            "a": "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."
        },
        {
            "q": "Do I need to know how to code to become a DevOps engineer?",
            "a": "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."
        },
        {
            "q": "How long does it take to learn DevOps from scratch?",
            "a": "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."
        },
        {
            "q": "Which cloud should I learn first: AWS, Azure or Google Cloud?",
            "a": "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."
        },
        {
            "q": "What is the difference between DevOps, SRE and platform engineering?",
            "a": "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."
        },
        {
            "q": "Which DevOps certification should I get first?",
            "a": "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."
        },
        {
            "q": "Should I learn Terraform or OpenTofu?",
            "a": "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."
        }
    ],
    "related": [
        "sre",
        "platform-engineering",
        "devsecops",
        "gitops"
    ],
    "key_tools": [
        "Git",
        "GitHub Actions",
        "Docker",
        "Kubernetes",
        "Terraform",
        "Prometheus"
    ],
    "course_url": "https://www.devopsschool.com/courses/devops/",
    "seo_title": "DevOps Learning Path 2026: Roadmap, Tools & Projects",
    "seo_description": "The 2026 DevOps roadmap: Linux, Git, CI/CD, Docker, Kubernetes, Terraform, cloud, observability, DevSecOps and DORA metrics, with projects and certs.",
    "url": "https://www.devopsschool.com/path/devops/",
    "updated_at": "2026-10-26 08:58:45"
}