A written version of the interactive roadmap above — every station, what you'll learn, and a small thing to build — laid out for reading, reference and search.
Foundations Start here
F1. Linux & the Shell
Beginner · 55 min
Everything a platform runs on is Linux, and the shell is where you live. Learn the filesystem, processes and signals, permissions, systemd, and enough shell scripting to automate the boring things — because a platform engineer who fears the terminal is a platform engineer who copy-pastes runbooks.
Skills: Filesystem & permissions · Processes, signals & systemd · Shell scripting · Text tooling (grep/sed/awk)
Build it: A service is eating memory on a box. Find the process, read its limits, and restart it cleanly — all from the shell.
F2. Networking for Platforms
Beginner · 55 min
Distributed systems are networking problems wearing trench coats. Learn TCP/IP, DNS, HTTP, load balancing and TLS, plus the cloud-native additions — service discovery, ingress, and why "it works locally but not in the cluster" is almost always a networking answer.
Skills: TCP/IP & DNS · Load balancing & TLS · Service discovery · Ingress & routing
Build it: A pod can’t reach a database by name. Walk the resolution path — DNS, service, network policy — and find where it breaks.
F3. Containers
Beginner · 60 min
Containers are the unit a platform ships. Learn what a container actually is (namespaces + cgroups, not a VM), how image layers and caching work, writing Dockerfiles that build fast and ship small, and registries — the foundation the entire orchestration stack sits on.
Skills: Namespaces & cgroups · Image layers & caching · Dockerfiles & multi-stage · Registries
Build it: Cut a 1.2 GB image to under 100 MB with a multi-stage build. What did the fat version ship that production never needed?
F4. Cloud Fundamentals
Intermediate · 60 min
Platforms are built on cloud primitives. Learn compute, storage and networking building blocks, IAM and the shared-responsibility model, managed services vs self-hosted trade-offs, and the cost awareness that separates a platform engineer from a big cloud bill.
Skills: Compute/storage/network primitives · Cloud IAM · Managed vs self-hosted · Cost awareness
Build it: Choose between a managed database and self-hosting one on Kubernetes. List the trade-offs your team will actually feel.
F5. Git & Version Control
Beginner · 45 min
GitOps means Git is the platform’s source of truth, so you must understand it deeply. Learn Git’s object model, branching strategies, and why declarative infrastructure lives in repositories — the substrate every modern deployment workflow is built on.
Skills: Git internals & objects · Branching strategies · Git as source of truth · PR workflows
Build it: Explain why "the cluster state should equal what’s in Git" is the whole idea of GitOps — and what breaks when it isn’t.
F6. Programming for Platforms
Intermediate · 55 min
Platform engineering is software engineering aimed at infrastructure. Learn Go or Python well enough to write operators, controllers and CLIs, work with APIs and YAML/JSON, and treat your platform as a product with code — not a pile of shell scripts nobody dares touch.
Skills: Go / Python for infra · APIs & serialization · CLIs & automation · Testing infra code
Build it: Write a small script that reconciles desired vs actual state for a resource. You just built the core idea of a controller.
The Platform The craft
T1. Kubernetes Core
Intermediate · 70 min
Kubernetes is the platform engineer’s operating system. Learn pods, deployments, services and the control loop that makes it all work — desired state reconciled continuously. Master kubectl, understand the scheduler, and grasp why "declare what you want, let the controller converge" is the whole philosophy.
Skills: Pods, deployments, services · The reconciliation loop · kubectl & the scheduler · Declarative state
Build it: A deployment won’t roll out. Use describe, events and logs to diagnose it — the debugging loop you’ll run a thousand times.
T2. Kubernetes in Depth
Advanced · 70 min
Past the basics lies the real platform. Learn ConfigMaps and Secrets, RBAC, network policies, storage and StatefulSets, resource requests/limits, and Helm or Kustomize for packaging — the pieces that turn "runs a container" into "runs a company’s workloads safely".
Skills: Config & secrets · RBAC & network policies · StatefulSets & storage · Helm / Kustomize
Build it: Package an app with Helm so any team can deploy it with three values. What do you expose, and what do you lock down?
T3. Infrastructure as Code
Advanced · 65 min
Clicking in a console doesn’t scale and can’t be reviewed. Learn Terraform (or OpenTofu/Pulumi): declarative infrastructure, state management and its dangers, modules for reuse, and the discipline that makes your entire cloud reproducible from a repository and a plan.
Skills: Terraform / OpenTofu · State & its dangers · Modules & reuse · Plan / apply discipline
Build it: Two engineers run terraform apply at once and corrupt state. Explain what happened and how remote state + locking prevents it.
T4. CI/CD & GitOps
Advanced · 65 min
The platform’s job is to move code to production safely and often. Learn pipeline design, build/test/deploy stages, GitOps with Argo CD or Flux (the cluster pulls desired state from Git), and progressive delivery — canary and blue-green — so deploys are boring instead of terrifying.
Skills: Pipeline design · GitOps (Argo/Flux) · Canary & blue-green · Rollback strategy
Build it: Design the deploy path where a bad release auto-rolls-back on failing health checks. What signal triggers the rollback, and when?
T5. Observability
Advanced · 60 min
You can’t operate what you can’t see. Learn the three pillars — metrics, logs, traces — plus Prometheus and Grafana, structured logging, distributed tracing, and how to build dashboards and alerts that answer "is it broken and why?" without drowning on-call in noise.
Skills: Metrics, logs, traces · Prometheus & Grafana · Structured logging · Dashboards & SLO alerts
Build it: A request is slow across five services. Which pillar tells you where the time went — and what must be instrumented for it to work?
T6. Platform Security
Advanced · 55 min
The platform is the blast radius for everyone on it. Learn secrets management, image scanning and supply-chain security, policy-as-code (OPA/Kyverno), and the paved-road principle: make the secure way the easy way, so every team gets security by default without becoming security experts.
Skills: Secrets & image scanning · Policy-as-code (OPA) · Supply-chain security · Secure paved roads
Build it: Write a policy that blocks any pod running as root from being admitted. Why enforce it at the platform, not in each team’s YAML?
Scale & Reliability Operate at scale
P1. Site Reliability Engineering
Advanced · 60 min
SRE is the discipline of running things reliably with engineering, not heroics. Learn SLIs, SLOs and error budgets, the toil-reduction mandate, capacity planning, and the culture that treats reliability as a feature you can measure, budget and trade against velocity.
Skills: SLIs, SLOs, error budgets · Toil reduction · Capacity planning · Reliability as a feature
Build it: Set an SLO for an API and the burn-rate alerts around it. When does the error budget say "stop shipping features and fix reliability"?
P2. Internal Developer Platforms
Advanced · 60 min
The frontier of the discipline: building the platform product itself. Learn golden paths, self-service provisioning, platform portals (Backstage), and the paved-road philosophy — abstracting Kubernetes complexity so a product engineer ships a service in an afternoon, not a fortnight.
Skills: Golden paths · Self-service provisioning · Backstage & portals · Abstracting complexity
Build it: Design the "new service" button: what does a product team fill in, and what does the platform generate — repo, pipeline, infra, dashboards?
P3. Incident Management
Advanced · 55 min
Everything breaks; what matters is how you respond. Learn on-call that doesn’t burn people out, incident command, effective runbooks, and blameless post-mortems that turn outages into permanent fixes instead of repeated 2am pages and quiet resentment.
Skills: On-call design · Incident command · Runbooks · Blameless post-mortems
Build it: Design an on-call rotation for a 6-person team that is humane AND covers 24/7. What automation removes the pages nobody should get?
P4. Cost & Efficiency (FinOps)
Intermediate · 50 min
A platform that ignores cost gets a very unpleasant meeting. Learn cloud cost visibility, right-sizing, autoscaling, spot instances, and FinOps practices that give teams the cost feedback to make good trade-offs — because the cheapest architecture nobody can operate is not actually cheap.
Skills: Cost visibility & tagging · Right-sizing & autoscaling · Spot & savings plans · FinOps culture
Build it: Your cluster runs at 20% utilization "for safety". Design the autoscaling that keeps headroom without paying for idle nodes all night.
P5. Multi-Cluster & Scale
Advanced · 55 min
One cluster becomes many: regions, environments, tenants. Learn multi-cluster patterns, service meshes (Istio/Linkerd) for traffic and mTLS, multi-tenancy isolation, and the disaster-recovery and failover design that keeps a global platform up when a region goes dark.
Skills: Multi-cluster patterns · Service mesh · Multi-tenancy isolation · DR & failover
Build it: A whole region fails. Trace what keeps serving and what doesn’t under your failover design — and what data you might lose.
P6. Platform as a Product
Intermediate · 45 min
The mindset shift that defines senior platform engineers: your users are developers, and the platform is a product they choose to use. Learn to gather feedback, measure adoption and developer experience, treat internal teams as customers, and grow from running infrastructure to shaping how a whole org ships.
Skills: Developers as users · Adoption & DX metrics · Platform roadmapping · IC to leadership
Build it: Teams keep bypassing your platform for their own scripts. Diagnose it as a product problem — what does your "product" get wrong?