New: Roadmaps ordered paths through our cheat sheets and flashcards, so you always know what to study next.
Explore themSee what's new on GitHubFrom Internal Developer Platform vocabulary to a golden path developers actually use.
A 12-step learning path. Follow it in order, or jump to what you need.
This path is for DevOps or Kubernetes engineers ready to stop firefighting tickets and start building the platform other teams self-serve from. Plan on about 6 to 10 weeks at 3 to 5 hours a week, moving from the Internal Developer Platform vocabulary to a designed golden path a developer can actually follow end to end. It stays focused on the platform layer itself: for the wider CI/CD-to-cloud toolchain, see the DevOps Engineer path, and for the incident and error-budget practice of keeping what you build reliable, see the Site Reliability Engineer path. By the end you can provision self-service infrastructure with Crossplane, publish it through a Backstage catalog and templates, and enforce your guardrails as code instead of a review checklist that nobody follows.
Expected: comfort with Linux, Docker, and core Kubernetes objects plus a working CI/CD habit, the ground the DevOps Engineer path covers. Helpful but not required: deeper Kubernetes practice from the Docker to Kubernetes path, or hands-on Terraform experience.
Open this today and the buzzword finally resolves into five concrete planes, golden paths, and a maturity model you can benchmark your org against, the map every later step in this path fills in.
Step 1's golden paths only work if the apps riding them behave a certain way, stateless, configured through the environment, disposable, and this is where that assumption gets spelled out before you design a single template.
Once an app is shaped to run anywhere, the next question is what decides what's actually running, and making Git that single source of truth is the pattern every provisioning tool later in this path, from Crossplane to Backstage, quietly assumes.
You can explain what an Internal Developer Platform promises, recognize whether an app is shaped to ride a golden path, and point to Git as the one source of truth for what should be running. Next up: turning that source of truth into infrastructure developers can request themselves.
Finish this section to unlock.
+100 XP
This is where infrastructure stops being something you provision once and starts being something a cluster continuously owns and corrects, expect the reconcile-not-just-create shift from step 3's GitOps model to take a few passes before it clicks.
Self-service infrastructure from step 4 is only useful if a developer can actually find and request it, and a software catalog with templates is what turns file a ticket into click a button and get a repo, pipeline, and environment.
Templates from step 5 and infrastructure APIs from step 4 will eventually get misused, and this is where guardrails finally clicks as something the cluster enforces on its own instead of a review checklist nobody follows, expect to keep tightening these rules as new templates ship.
Take this if your platform needs decision logic Kyverno's YAML rules can't express: Rego gives you the same admission-control enforcement from step 6 with a real query language behind it.
You can let a team request infrastructure through a Kubernetes API instead of a ticket, hand them a portal to request it from, and enforce your rules automatically instead of policing pull requests by hand. A few minutes of due flashcards keeps the GitOps habit from step 3 sharp while you build on it here. Next up: hardening what you just built and proving it's worth what it costs.
Finish this section to unlock.
+100 XP
Policy enforcement from step 6 stops bad manifests at the door, and hardening goes further, security contexts, seccomp, RBAC, layered so one missed control never means one open door.
Worth it if you're heading toward owning what your platform costs: every self-service resource from step 4 someone can spin up for free is a bill somebody eventually has to explain.
Choose this if your golden path should ship changes gradually instead of all at once: canary and blue-green strategies here extend the Git-as-truth model from step 3 into how traffic actually shifts.
Everything you've automated since step 1 is a bet that developers ship faster because of it, and these five numbers are how you prove that bet paid off instead of just feeling busy.
The catalog from step 5, the provisioning from step 4, and the guardrails from step 6 finally come together here, in the one artifact platform teams actually ship: a golden path a developer can follow from a template to a running, guarded service the same day.
You can harden what runs on your platform, put a number on whether it's actually speeding teams up, and design a golden path end to end, from a Backstage template to a guardrailed, GitOps-deployed service a team can ship the same day. That's the Platform Engineer badge, earned.
Finish this section to unlock.
+100 XP
Finish every required step, at least 70% of them genuinely done (not skipped), to earn this badge and 500 XP.