KCNA — Kubernetes and Cloud Native Associate

The CKA profile on this course already told you where this one sits: "below the CKA, as the knowledge-based, no-prerequisite entry point." This page is that entry point in full. The Kubernetes and Cloud Native Associate is a 60-question, multiple-choice exam about cloud native concepts — no terminal, no live cluster, nothing to build or fix. It exists for exactly the person the CKA intimidates: someone who wants to prove real, structured knowledge of Kubernetes and the CNCF landscape before committing hours to a hands-on exam that grades a live cluster under a clock. Below: what it actually tests, the five official domains and their weights, a direct side-by-side against the CKA, and how much of this course already prepares you for it.

What the KCNA actually tests, and who it's for

☺ Like you're 10: It checks whether you understand Kubernetes and the cloud native world conceptually — not whether you can operate any of it yet.

The Kubernetes and Cloud Native Associate (KCNA) is administered by The Linux Foundation on behalf of the CNCF and was introduced in 2021 as a deliberately gentler on-ramp to the certification ladder the CKA sits on. It certifies foundational knowledge: what Kubernetes' core objects are and roughly how they fit together, what a container actually is versus a VM, what the wider cloud native landscape looks like — observability, service meshes, CI/CD, the CNCF's own project maturity levels — and how the pieces of that ecosystem relate to each other. It does not certify that you can build, operate, or troubleshoot any of it. That distinction is the entire point of the exam, not a limitation of it.

It's aimed at exactly the population the CKA's performance-based format screens out by design: people early in a cloud native career, developers who deploy onto Kubernetes but have never administered a cluster, and — genuinely — non-engineering roles that need real fluency in the vocabulary without ever opening a terminal: technical product managers, sales engineers, support staff, technical writers. If your job touches Kubernetes conversationally more than it touches a kubectl prompt, this exam was built with you specifically in mind.

The format, in full

☺ Like you're 10: 60 questions, 90 minutes, closed book, no prerequisites — the opposite shape of the CKA in almost every dimension that matters.

Every fact below is what The Linux Foundation and CNCF generally publish and what candidates consistently report. Treat it as a reliable planning baseline, not a locked contract — the warning box further down explains what to check before you register.

The one detail worth over-explaining: a multiple-choice exam like this one is recognition, not recall-under-verification. The CKA hands you a broken cluster and grades whatever state it's in when time runs out — you have to produce the fix yourself and confirm it worked. KCNA hands you a scenario and four options and asks you to recognize the correct one — the answer already exists on the screen, your job is picking it out from three plausible-sounding wrong ones. That's a genuinely different skill, and it's why the two exams reward completely different study habits, covered further down.

↗ Linux Foundation official KCNA page

The five domains and their weights

☺ Like you're 10: Five topics, heavily lopsided — almost half the exam is just "what is Kubernetes and how are its pieces arranged."

The CNCF publishes a versioned curriculum for KCNA with five domains that sum to exactly 100%. Compare the shape to the CKA's: the CKA spreads its weight fairly evenly across five domains topped by Troubleshooting at 30%. KCNA does the opposite — it concentrates nearly half the exam in a single domain and lets the rest trail off sharply.

Kubernetes Fundamentals (46%) is close to half the exam on its own: the control plane and node components, the API primitives — Pods, ReplicaSets, Deployments, Namespaces, Services — scheduling basics, and the multi-container Pod design patterns (sidecar, ambassador, adapter). Container Orchestration (22%) steps back one layer, to orchestration concepts generally: container runtimes (containerd, CRI-O), the Container Runtime Interface, Container Network Interface, and Container Storage Interface as abstractions, and baseline container security concepts. Cloud Native Architecture (16%) is the domain most unlike anything the CKA touches: autoscaling patterns, serverless, and — a genuinely distinctive sub-topic — CNCF community and governance, including the maturity ladder a CNCF project climbs from sandbox to incubating to graduated. Observability (8%) and Application Delivery (8%) are both light touches: the vocabulary of metrics, logging, and tracing on one side, and CI/CD plus GitOps concepts on the other, without depth on any single tool.

The exact bullet wording under each domain shifts a little between curriculum revisions, the way it does for the CKA — confirm the current version against the CNCF's published curriculum before you build a study plan around this breakdown.

Even at the "recognition, not recall" level the exam operates at, KCNA still expects you to read Kubernetes YAML fluently — not write it from a blank file, but recognize what's valid, what's missing, and what a given manifest actually does:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
spec:
  replicas: 3
  selector:
    matchLabels: { app: web }
  template:
    metadata:
      labels: { app: web }
    spec:
      containers:
        - name: web
          image: nginx:1.27
          ports:
            - containerPort: 80

KCNA won't ask you to produce this from scratch under a clock the way the CKA would. It's far more likely to show you four near-identical versions of it and ask which one is valid, what happens to running Pods if replicas is removed entirely, or which field a matching Service's selector actually needs to reference. Same object, completely different kind of question.

KCNA versus CKA — the direct contrast

☺ Like you're 10: Same ecosystem, almost opposite exam in every dimension that matters — format, cost, stakes, and what "passing" actually proves.

These two sit one rung apart on the same ladder, and it's worth being precise about exactly how different the experience of sitting each one actually is, because the difference is bigger than "one is easier."

The honest way to read that table: KCNA is lower-stakes on every axis at once — cheaper, shorter, no live environment to fail in front of, and a full extra year before it expires. That's a feature, not a discount. It exists so the CKA's format doesn't become the thing that talks someone out of starting the ladder at all. If the idea of a proctor handing you a broken cluster and a two-hour clock is what's kept you from booking anything, KCNA is the exam built specifically to get you moving without that fear being relevant yet.

What this course already covers — and the real gap

☺ Like you're 10: You already know a solid chunk of the "what is it" half. The rest is mostly vocabulary this course only touches in passing.

Containers & orchestration and the Kubernetes tool page teach the concepts KCNA's biggest domain draws on — but they teach them at the altitude of someone about to deploy onto a cluster, with worked kubectl examples and YAML you're expected to write. KCNA never asks you to write anything; it asks you to recognize concepts fluently instead. That gap between "learned it to use it" and "learned it to recognize it on a multiple-choice line" is smaller than it sounds, but it's real.

The honest summary: this course gets you strong, genuine coverage on four of the five domains worth 84% of the exam combined. The one real gap — CNCF community and governance inside Cloud Native Architecture — is a small, fast, memorizable slice of a 16% domain, not a structural hole. If you've worked through this course's Foundations and Infrastructure & Operations sections in order, you are closer to exam-ready for KCNA than for almost any other certification on this shelf.

How to actually prepare for a knowledge-based exam

☺ Like you're 10: This is the one certification on this course where flashcards genuinely work — because the real exam is also just recognizing the right answer from a list.

This is the mirror image of preparing for the CKA. There's no cluster to sabotage, no muscle memory to build, no clock pressure that rewards typing speed. What matters here is breadth of vocabulary and the ability to recognize a correct definition or a valid manifest instantly, under a fairly generous 90-second-per-question pace.

• Drill definitions, not commands. This course's own flashcards and glossary are a genuinely good match for this exam's format in a way they aren't for the CKA's — a multiple-choice exam rewards exactly the "instant recall of a precise definition" skill Remy the Rabbit's flashcards are built around.
• Read YAML without writing it. Spend time recognizing valid manifests, spotting the one field that's missing or misspelled among four near-identical options, and reasoning about what happens when a field like replicas or a selector is wrong — never actually typing a manifest from a blank file, since you won't need to on exam day.
• Don't skip Cloud Native Architecture's governance sub-topic. It's the one genuinely new vocabulary this course doesn't teach — the CNCF's sandbox → incubating → graduated maturity ladder, and roughly which well-known projects (Kubernetes, Prometheus, Envoy, etcd) sit at "graduated." It's a small, fast, high-leverage thing to memorize directly, since nothing else on this site will teach it for you.
• Read the CNCF Cloud Native Landscape once, deliberately. Not to memorize every logo on it — to build the mental map of which category (orchestration, observability, service mesh, CI/CD) a tool you've never heard of probably belongs to, which is exactly the kind of reasoning a well-written distractor option is built to test.
• Time yourself loosely, but don't obsess over it. 90 minutes for 60 questions is 90 seconds each on average — generous compared to a performance-based exam's task pacing. A single practice run under a rough clock is enough to confirm pacing isn't your actual risk here; content breadth is.

Exam-day logistics

☺ Like you're 10: Same remote-proctoring process as the CKA — ID check, room scan, webcam on — just with nothing to fix once the clock starts.

KCNA is delivered through the same remote-proctoring family as the CKA: a secure browser, webcam and microphone required, an ID check and room scan before the timer starts. The meaningful difference is what happens after that. There's no environment to load, no cluster to wait on, no terminal to get comfortable in — just a sequence of questions, one at a time, with the option to flag and return to ones you're unsure about.

Where KCNA sits on the ladder, and what to do next

☺ Like you're 10: It's the first rung, not the whole ladder — know what sits beside it and above it before you plan the rest of your route.

Treat the CNCF's certifications as a small floor plan, the same way the CKA profile does. KCNA sits at the entry level: knowledge-based, no prerequisites, cheapest and shortest of the family. CKA and CKAD sit side by side one rung up, at practitioner level — same performance-based style as each other, different half of Kubernetes: CKA is the cluster the workloads run on, CKAD is the workloads themselves. Above both, CKS requires an active CKA as a formal prerequisite and goes deep on hardening, supply-chain, and runtime security. None of that is a required path from here — KCNA doesn't unlock anything — but it is the sequence that makes each next exam feel like a smaller step than it would cold.

Off to the side of the CNCF ladder entirely sit the tool- and vendor-specific certifications on this course's certifications hub: the Terraform Associate, which is the closest thing to a KCNA equivalent for infrastructure as code — cheap, knowledge-based, no prerequisites — and the vendor-specific tracks like Azure DevOps Engineer Expert or the Google Cloud Professional DevOps Engineer, which assume real production experience the way the CKA does, just pointed at a specific cloud instead of at Kubernetes. If you're genuinely undecided where to start and have never sat a certification exam before, KCNA and the Terraform Associate are this course's two lowest-stakes on-ramps — pick whichever concept gap actually matches your day job, then use that first pass to build the exam-taking muscle before anything performance-based.