Start here · Welcome

Welcome to Kubernetes.

Kubernetes runs more of the world's production workloads than any other orchestrator, and this course teaches it as an actual discipline rather than a certification checklist: how the control plane reasons about your cluster, what the object model means the moment you write a manifest, and why the reconciliation loop is the one idea every other feature is built on top of. From there it goes deep — seventeen lessons, one per subsystem, covering the CNI and the CSI, RBAC and admission control, autoscaling, operators, service mesh, GitOps, multi-cluster fleets, FinOps, and platform engineering on top of Kubernetes itself — then hands you sixteen practical guides to the tools you'll actually run, a five-part capstone that builds one real cluster end to end, and seven guided drills for when something breaks and you have to fix it under pressure. It closes on the complete CNCF Kubernetes certification ladder: KCNA, KCSA, CKA, CKAD, and CKS, all five, each covered in the depth an actual exam deserves — official domain blueprints, study plans, practice tasks, and multiple full-length mock exams apiece. It's built for engineers who already run containers and want the operational depth underneath kubectl, and for anyone working toward any of those five certifications who wants more than a stack of memorized exam questions.

What's inside

☺ Like you're 10: Pick a card below and it drops you straight into that part of the course, in the order the course wants you to read them.

The sidebar runs eleven groups deep, in the order they're meant to be read the first time through — though nothing stops you jumping straight to what you need. Foundations lays down the architecture and the declarative object model everything else assumes. The Exam Blueprint walks CKA's own five domains — cluster architecture, workloads and scheduling, services and networking, storage, troubleshooting — as a genuine buildout rather than an exam cram. Operating Kubernetes steps back to the anti-patterns and the operating model a real platform team lives by day to day. Kubernetes in Depth is the long middle of the course: seventeen deep-dive lessons on the CNI and the CSI, autoscaling, RBAC and admission control, operators and CRDs, service mesh, GitOps, multi-cluster fleet management, observability, cost and FinOps, stateful workloads, platform engineering, troubleshooting methodology, and the wider CNCF project landscape. Tools Used in Kubernetes is sixteen practical guides to the CLI and controllers you'll actually run — kubectl, Helm, Kustomize, kubeadm, kind, minikube, k9s, containerd, Calico, Cilium, ingress-nginx, cert-manager, metrics-server, the Cluster Autoscaler, Karpenter, and Velero. Hands-On Labs is where it stops being reading: a five-part capstone that builds one cluster from bare architecture through security and RBAC, plus seven guided drills that each start from a cluster that's already broken and hand you the terminal. Common Preparation, Certifications, Interview Prep, and Reference are the groups you come back to rather than read once — study plans, mock exams, flashcards, a searchable glossary, and real-company case studies.

Who this course is for

☺ Like you're 10: If you've already typed kubectl get pods and wondered what's actually happening on the other end, this course is for you.

This is written for engineers who already run containers day to day and want the operational and architectural depth underneath the commands they already type — why a Pod goes Pending, what actually happens between kubectl apply and a container starting, how a Service finds a healthy Pod without you wiring anything by hand. It's equally built for anyone working toward KCNA, KCSA, CKA, CKAD, or CKS who wants the concepts and the muscle memory, not a leaked question bank. If your job is building the paved road a platform team's developers actually use — golden paths, self-service, internal developer platforms — this course still covers the cluster underneath that road in full, but the platform layer on top of it belongs to the Platform Engineering course; its Kubernetes substrate lesson picks up exactly where this course's control-plane internals leave off.

How this course teaches

☺ Like you're 10: There's no login and nothing you're forced to finish — you read the pages in the order the sidebar lists them, and a cast of recurring animal characters walks you through each one.

Every idea in this course is taught by a recurring character from the Pod Squad who is that idea — Professor Owl draws the architecture, Timmy the Turtle guards RBAC and admission control, Pip the Hummingbird carries the traffic through Services and the CNI, and seven others each own a piece of running a real cluster. And underneath every major heading in every lesson sits this course's core teaching device: a one-line "Like you're 10" note that reframes the concept in plain terms before the technical prose starts, backed by a full Explain It Like I'm 10 callout at the top of the page with a concrete, worked analogy — the one above this section is this page's own. Nothing here is gated behind a login and nothing is timed except the papers you start yourself in the mock exams; "progress" is just where you are in the sidebar, tracked locally in your own browser and never sent anywhere. When you want the tools rather than the lessons, the glossary and flashcards live in Common Preparation, and browsing by tag lets you cut across every group at once — by exam track, by format, or by section.

The full CNCF Kubernetes certification ladder

☺ Like you're 10: Five official Kubernetes exams exist, and this course teaches every one of them from the ground up, not just the exam-day tricks.

The CNCF publishes exactly five certifications that test Kubernetes itself, and this course covers every one of them in full: the knowledge-based associates KCNA and KCSA, and the performance-based, live-cluster exams CKA, CKAD, and CKS — the last gated behind an active, passed CKA. Each gets its own official domain blueprint transcribed straight from the CNCF curriculum, a study plan, a bank of practice tasks, and multiple full-length mock exams, all cross-linked back to the deep-dive lessons and tool guides that actually teach the material behind each domain. Start at the certifications hub for the master table, the associate-versus-performance-based split that should shape how you study, and three recommended paths depending on where you're starting from.

Those five exams are also exactly the set that earns Kubestronaut status — but Kubestronaut is one rung on a longer ladder. Golden Kubestronaut asks for the CNCF's entire certification catalogue plus the Linux Foundation's LFCS. This course deliberately stops at the five Kubernetes exams rather than re-deriving that whole ladder: the sibling Golden Astronaut course covers the other nine stops on it — Argo, Cilium, Istio, Kyverno, OpenTelemetry, Prometheus, Backstage, GitOps, and LFCS — and the Platform Engineering course's certifications hub covers the two platform-engineering exams (CNPA, CNPE) along with a full, honest explanation of how the Kubestronaut and Golden Kubestronaut programs actually work — qualifying rules, renewal maths, and all. Chase the full badge across all three courses; we won't duplicate any of it here.

Ready? Start with What Is Kubernetes, and Why, or meet the cast first at The Pod Squad.