The Kubernetes Baseline You Need
Every lesson from here on assumes you can already operate a Kubernetes cluster — read a Pod's status, write a Service, reason about a RoleBinding — without this course stopping to teach you how. That's deliberate. The five-exam Kubernetes core — KCNA, KCSA, CKA, CKAD and CKS — is covered in full, start to finish, in the sibling Kubernetes course, and re-teaching it here would either shortchange it or double the length of every page in this course that leans on it. This page draws the line honestly: exactly what's assumed, a short self-check so you find any gap on your own terms rather than mid-lab, and exactly where in the Kubernetes course to go if the self-check finds one.
Imagine mission control hands you the controls for a two-year, sixteen-launch campaign. Nobody re-teaches you how to fly the basic capsule first — that was a separate, earlier training, already flown and logged. If you can't already dock, adjust orbit, and read the instrument panel without thinking about it, every one of the sixteen launches ahead gets harder for a reason that has nothing to do with that launch itself. This page is the pre-flight check for that earlier capsule training. It isn't a flying lesson.
Why this course starts above the Kubernetes line
☺ Like you're 10: This is the sequel, not the first movie. It assumes you already watched the first one.
Mission Control says it plainly: this course assumes you've already cleared the five-exam Kubestronaut foundation and doesn't re-teach it, only builds the next eleven exams — nine here, two in the sibling Platform Engineering course — on top of it. The Sixteen-Exam Ladder and The Order of Attack both treat that five-exam core as phase one of sixteen, sequenced before anything on this page's shelf. This page is the narrower, more personal question underneath all three: not "where does Kubernetes fit in the ladder," but are you personally carrying it already? KCNA and KCSA give you the vocabulary; CKA, CKAD and CKS give you the hands. This course's own nine exams — CGOA, CAPA, CBA, CCA, ICA, KCA, OTCA, PCA and LFCS — read every part of that vocabulary and every one of those hands-on reflexes as already fluent, never as something to introduce.
| The assumed skill | Why this course leans on it | Fastest reread if it's shaky |
|---|---|---|
| Pods, Deployments, Services & the object model — the nouns, not just the words for them | A CGOA reconciliation example, a Cilium NetworkPolicy, a Kyverno policy target — every one assumes you parse these on sight. | KCNA |
kubectl reflexes — apply, get, describe, logs, edit, explain, without a lookup | CCA, ICA, KCA and LFCS each put a live task or lab in front of you; nothing times how fast you read a manifest, only whether the task finishes in the window you're given. | CKAD |
| RBAC basics — Role vs ClusterRole, bindings, ServiceAccounts, proving a grant rather than assuming one | KCA's admission policies and CBA's scaffolder both sit directly on top of an identity model this course never re-derives. | CKA |
| CKA-level cluster operations — reading events, triaging a stuck Pod, basic node maintenance | When a lab here says a policy is silently rejecting something, it expects you to already know how to triage a cluster, not learn to under a deadline. | CKA |
The self-check
☺ Like you're 10: Tick the things you could genuinely do right now, with nothing to look up. Leaving a box empty isn't a bad mark — it's the whole point of checking.
Eleven items, read as literal instructions. Only tick one if you could do it this minute, closed-book — not "I've seen this" or "I'd recognize the flag." An empty box here is far cheaper than the same gap showing up mid-lab in KCA or CCA, where the clock doesn't pause while you remember.
- ① Objects, workloads & kubectl reflexes
- ② RBAC & CKA-level cluster operations
One or two empty boxes, especially in group ②, is completely normal and not a reason to stop — read the matching section of the Kubernetes course and move on. Four or more empty boxes, or anything in group ① left unticked, is a different signal: this course's own material will spend its limited time re-explaining Kubernetes instead of teaching CGOA, Cilium or Kyverno, and you'll absorb less of both. That's a week well spent in the Kubernetes course first, not a delay — the table above tells you exactly which exam's material to start with.
"I'd read the CGOA blueprint twice and felt ready, so I skipped this page entirely and jumped into the KCA hands-on lab. The Kyverno part went fine — that was genuinely new material. What actually cost me twenty minutes was a RoleBinding I half-remembered and got backwards, because I'd never had to write one from a blank file before, only read one someone else had already written. The lab wasn't testing RBAC. It just assumed I had it, the same way this page said it would."
If the self-check found a gap
☺ Like you're 10: Now you know which starter skill is wobbly. Go fix that one specific thing — you don't need to restart the whole first movie.
Start at the Kubernetes course's own index. Its Field Notes page sizes up the same five exams honestly from the candidate's side, and its certifications hub lays out KCNA, KCSA, CKA, CKAD and CKS with a blueprint, a study plan and practice questions of their own. Match the specific items you left unticked above to the table earlier on this page, and go straight to that exam's material rather than working the Kubernetes course front to back — you're closing a named gap, not starting a second course from scratch.
Starting this course's own material — CGOA's reconciliation loop, a Cilium policy, a Kyverno rule — while kubectl still needs a lookup feels productive and isn't. You'll spend the reading silently translating instead of learning the actual new idea in front of you, and a hands-on lab hides the gap worse than a knowledge exam ever could: it doesn't tell you what you got wrong, it just times out.
Floor confirmed? This course's own nine exams start from here, in the order The Order of Attack lays out.
Foxy: Wait — do I need to have actually passed all five Kubernetes exams before I'm allowed to start this one?
Professor Owl: Passed, no. Fluent, yes — those are genuinely different bars. Nobody checks a certificate at the door here, but the self-check above will catch the gap just as reliably as a booking form would.
Timmy the Turtle: And it should be checked, not assumed. Tick every box honestly before you open a CGOA lesson — an unchecked assumption is exactly the sort of thing that gets a manifest rejected later.
Professor Owl: The five-exam core teaches you to fly the capsule. Everything in this course happens after liftoff.
1. Which five exams make up the Kubernetes core this course assumes, and which sibling course teaches them? 2. Name two concrete self-check items from group ② — RBAC and CKA-level operations. 3. Why does this page recommend matching one specific unticked item to one exam's material, rather than rereading the Kubernetes course start to finish? 4. According to the warn callout, what's the actual risk of starting CGOA or a hands-on lab in this course before the floor is solid? 5. If you're comfortable with Pods, Deployments, Services and kubectl but shaky specifically on RBAC and node-level troubleshooting, which single exam's page is the fastest reread?
Check your answers
- KCNA, KCSA, CKA, CKAD and CKS — taught in full in the sibling Kubernetes course, which this course deliberately never re-teaches.
- Any two of: stating the Role vs ClusterRole difference and when you need a ClusterRole; writing a Role and RoleBinding and proving the grant with
kubectl auth can-i --as=; cordoning and draining a node without checking the flags; diagnosing a Pod stuck inPending; readingkubectl get pods -o wide; switching context and namespace without opening a kubeconfig file. - Because the unticked items are named, specific gaps, not a sign the whole foundation is missing — going straight to the matching exam's material closes exactly that gap, while rereading everything from the start wastes time re-confirming what you already have.
- It doesn't just feel slower — a hands-on lab hides the gap worse than a knowledge exam would. Instead of telling you which fact you got wrong, it simply runs out the clock while you're still silently translating basic Kubernetes instead of learning the new idea the lesson is actually about.
- CKA — its curriculum covers RBAC and day-to-day cluster operations (node maintenance, troubleshooting, reading events) directly, which is exactly the pairing this page's table points at for that gap.