Kubernetes and Cloud Native Associate (KCNA) #1: Exam Introduction — Structure and Study Strategy

If the 26-post K8s hands-on track had you spin up Pods, Deployments, Services, and Ingress by hand on minikube and kubectl, and even run a cluster on EKS, the natural next step is getting that intuition validated by a certification. The CNCF (Cloud Native Computing Foundation) Kubernetes certifications come in four tiers — entry level (KCNA), application developer (CKAD), cluster administrator (CKA), and security specialist (CKS) — and the most entry-level of them is the Kubernetes and Cloud Native Associate (KCNA). This series walks through every domain needed to pass KCNA in nine posts.

This post is the starting point of the series. Before you sit down to answer questions, there is a picture you need in your head: what the exam asks, the form it asks in, and how to prepare to clear 75% within 90 minutes. That is what this post lays out.

What kind of certification is KCNA #

KCNA tests whether you understand the big picture of Kubernetes and the cloud native ecosystem. Unlike CKAD, CKA, and CKS, which are performance-based exams where you operate a real cluster from the terminal, KCNA ends with a single multiple-choice exam. Rather than the ability to manipulate a cluster by hand, it validates whether you can answer questions like these without hesitation.

• What do the Kubernetes control plane and worker nodes each do?
• What kind of problem does each of Pod, Deployment, Service, and ConfigMap solve?
• What boundaries do the container runtime and the CRI, CNI, and CSI interfaces draw?
• What trade-offs do autoscaling and serverless make in a cloud native architecture?
• What do the three pillars of observability (metrics, logs, traces) look at?

Someone who passes this exam will not have memorized every Kubernetes command. Instead, they can classify at a glance which resource solves which kind of problem, and they pick up the vocabulary of the core CNCF ecosystem projects and cloud native operations.

Who benefits from it #

On the flip side, the case for an engineer who already holds a CKA or CKAD to go back and earn KCNA is weak, because the higher-tier performance-based certifications already cover most of KCNA’s conceptual scope. That said, KCNA asks broadly about the cloud native ecosystem at large (serverless, Service Mesh, community governance, and so on) that the performance-based exams do not cover, so plenty of people pass through it first to organize the concepts.

Exam structure #

The surface facts of the KCNA exam are worth committing to memory quickly.

The decisive difference from CKAD and CKA #

CKAD, CKA, and CKS are performance-based exams where you connect to a real cluster and solve problems. KCNA, by contrast, is purely multiple choice. There is no terminal and no kubectl. This difference shapes the direction of study. For KCNA you should spend your time classifying concepts and terms precisely rather than practicing how to write manifests by hand.

What the 75% passing line means #

KCNA is reported to use a simple percent-correct standard rather than a scaled score, and you pass by getting at least 45 of the 60 questions (75%) right. The fee includes one retake, so even if you fall just short of the passing line on the first attempt, you can try once more at no extra cost. Still, there is no reason to slack on preparation while banking on the retake. After one pass through this series, the first goal is to clear the passing line on the mock exam in #9.

Question format #

Every question is either multiple choice or multiple response. Multiple choice asks you to pick one correct answer from the options, while multiple response is called out with wording like “Choose TWO” and requires you to select all correct answers with no partial credit. Since this is not a performance-based exam, you do not need to memorize command output, but if you confuse the precise definition of a concept (for example, the difference between a ReplicaSet and a Deployment, or between a readiness probe and a liveness probe), you lose points immediately.

The weight of the five domains #

The KCNA exam scope is laid out in the official exam curriculum as five domains.

The weights are themselves a guide for allocating study time. Kubernetes Fundamentals alone is 46%, nearly half, so this domain decides whether you pass. Add Container Orchestration and the two domains come to 68%, while the remaining three add up to 32%.

Domain 1: Kubernetes Fundamentals (46%) #

This asks about the core of Kubernetes itself. The key keywords are cluster architecture (the apiserver, etcd, scheduler, and controller-manager of the control plane; the kubelet and kube-proxy of the worker node), core resources (Pod, Deployment, ReplicaSet, Service, Namespace), the Kubernetes API and the declarative model, and containers and scheduling. The cluster picture from hands-on track #1 shows up on the exam as is. Since the weight is close to half, I cover it across two posts, #2 and #3.

Domain 2: Container Orchestration (22%) #

This asks about the layer that holds containers up beneath Kubernetes. Container runtimes (containerd, CRI-O) and the CRI, security (RBAC, NetworkPolicy, security context), networking (CNI, Service, DNS), storage (CSI, PV, PVC), and Service Mesh come up frequently. It is efficient to clearly classify what boundaries the interfaces (CRI, CNI, CSI) draw. I cover it in #4.

Domain 3: Cloud Native Architecture (16%) #

This asks about cloud native design thinking beyond Kubernetes. The core is autoscaling (HPA, VPA, Cluster Autoscaler), serverless (Knative, FaaS), community and governance (CNCF project maturity stages), open standards (OCI, OpenTelemetry, and so on), and concepts like self-healing and rollouts. I organize it in #5.

Domain 4: Cloud Native Observability (8%) #

The weight is small, but the question patterns in this domain are formulaic. The three pillars of telemetry (metrics, logs, traces), Prometheus and metric collection, SLI, SLO, SLA, and cost management (FinOps) concepts come up often. I cover it in #6.

Domain 5: Cloud Native Application Delivery (8%) #

This asks about the flow of delivering applications to a cluster. The core is the principles of GitOps (ArgoCD, Flux), CI/CD pipelines, and the concept of declarative deployment. The weight is small and it overlaps with advanced hands-on track #6 GitOps, so a single post, #7, organizes it fully.

Study strategy #

1) If you have hands-on intuition, layer the vocabulary on top #

If you went through the 26-post K8s hands-on track, you have effectively built resources like Pod, Deployment, Service, Ingress, and ConfigMap with your own hands. KCNA study is just a matter of layering the vocabulary of the cloud native ecosystem (CNCF projects, Service Mesh, GitOps, the three pillars of observability, and so on) on top of that. Because there are not that many concepts you are seeing for the first time, you can bring yourself up to the passing line within 2–3 weeks.

2) If you are new to hands-on work, start with Domain 1 #

If you have not gone through the hands-on track, start your study with Domain 1 (Kubernetes Fundamentals), because this domain lays the vocabulary foundation for every other domain. It also carries the largest weight at 46%, so if you firmly secure points here, the burden of the remaining domains drops sharply.

3) Organize with your head, not your hands #

Because KCNA is not performance-based, you do not need to memorize manifests. Instead, it pays off to make cards that compare a pair of concepts. If you organize confusing pairs like ReplicaSet vs Deployment, StatefulSet vs Deployment, liveness vs readiness probe, ClusterIP vs NodePort vs LoadBalancer, and CRI vs CNI vs CSI, a fair number of exam questions come straight out of those comparisons.

4) Concentrate mock exams in the back half #

I do not recommend a strategy of doing mock exams from the start. After one pass through this series, I have placed a mock multiple-choice exam at #9. The recommended flow is to take it at that point: if the score clears the passing line, book the exam, and if it falls short, do another pass through the weak domains. If you need more practice questions, the official KCNA study resources provided by CNCF and the Linux Foundation training courses are the trusted standard.

5) Account for it being an English-language exam #

KCNA is offered only in English. There is no Korean toggle as with CLF, so you need to get comfortable reading questions in developer English. Fortunately the question sentences are formulaic, and the technical terms appear exactly in the English notation covered in this series, so if you learn the terms in English, the translation burden is almost nonexistent.

Registration and the testing environment #

Registration steps #

1. Create an account on the Linux Foundation training portal
2. Buy the KCNA exam. If you wait for the frequent sales (several times a year), you can buy it for less than list price
3. Book your exam date in the PSI proctoring system
4. Pass the system compatibility check (browser, webcam, network) before the exam

Preparing for the online-proctored (PSI) exam #

KCNA has no test center and is conducted only via online proctoring. You take it on your own PC and webcam, and a proctor inspects your screen and surroundings in real time.

• ID. A passport with your name in English is the safest option. The name must match your registration information exactly
• Testing environment. Clear everything off the desk, use only one monitor in a dual-monitor setup, and block family and roommates from entering
• System check. Log in 30 minutes before the exam and shut down all browser extensions and background apps. A stable wired network is recommended
• No breaks. You cannot leave your seat for the 90 minutes, so finish your preparation before you start

Common traps #

1) Mistaking it for a performance-based exam and only memorizing manifests #

KCNA is multiple choice. If you spend all your time writing manifests and kubectl commands as you would for CKAD prep, you will lose points on the architecture, observability, and delivery concepts that make up 32% of the weight. The emphasis should be on the classification and definition of concepts.

2) Neglecting the CNCF ecosystem beyond Kubernetes #

Domains 3–5 ask not about Kubernetes itself but about surrounding projects and concepts like Prometheus, ArgoCD, Knative, and OpenTelemetry. If you study only Kubernetes and walk in, you wobble on this 32%. You should be able to explain in one line what problem each project solves.

3) Lumping similar resources together #

If you leave the differences between similar-looking resources fuzzy — Deployment vs. StatefulSet, Job vs. CronJob, ConfigMap vs. Secret — the multiple-choice options will probe exactly those differences. You must be able to distinguish each confusing pair in a single sentence.

4) Missing the number of correct answers in a “multiple response” question #

If you miss the “Choose TWO” notation and pick only one, it is automatically wrong. Multiple choice and multiple response questions look nearly identical, so you need the habit of always reading the final line of the question to catch the answer count.

5) Getting stuck on a single question #

Sixty questions in 90 minutes works out to an average of 1 minute 30 seconds per question. If you linger on any single question for more than 3 minutes, you will not reach the last questions. Mark the ones you are unsure about and keep moving, then revisit only the marked questions before time runs out.

Wrap-up #

What this post pinned down:

• KCNA validates the big picture and vocabulary of Kubernetes and cloud native, as an entry-level certification. It is multiple choice, not performance-based
• 60 questions / 90 minutes / 75% / $250 (one retake included) / valid for 2 years. Online-proctored only
• Five domains. Kubernetes Fundamentals (46%), Container Orchestration (22%), Cloud Native Architecture (16%), Observability (8%), Application Delivery (8%)
• Study strategy. Layer ecosystem vocabulary on top of hands-on intuition. Make concept-comparison cards. Concentrate mock exams in the back half
• Traps. Mistaking it for performance-based, neglecting the CNCF ecosystem, lumping similar resources together, missing the answer count in multiple-response questions, and getting stuck on one question

Next: Kubernetes Fundamentals 1 #

The exam structure is pinned down. Now we move into the largest domain, at 46% of the weight.

In #2 Kubernetes Fundamentals 1: Architecture and Core Resources, I cover the components of the control plane and worker nodes (apiserver, etcd, scheduler, controller-manager, kubelet, kube-proxy), the core resources (Pod, ReplicaSet, Deployment, Service, Namespace), and the component-role matching questions that come up often on the exam.