KCNA prep, the entry-level Kubernetes cert roadmap with ARIA
The CNCF Kubernetes and Cloud Native Associate (KCNA) is a 60-question multiple-choice exam delivered over 90 minutes, with a 75 percent passing score and no prerequisites. It is the only MCQ exam in the CNCF Kubernetes line (CKA, CKAD, and CKS are all hands-on lab exams), which makes it the natural entry point for candidates who want to validate cloud native fundamentals before committing to a performance-based exam. 
ARIA runs the adaptive evaluation, builds your five-domain roadmap, and stands behind it with a pass guarantee tied to five measurable conditions.
Start your KCNA roadmap. About five minutes to the first signal.
TL;DR
- KCNA is CNCF's beginner credential, current as of 2026: 60 multiple-choice items, 90 minutes, 75 percent to pass, no prerequisites.
- The blueprint loads heavily into Kubernetes Fundamentals at 46 percent. The remaining 54 percent splits across Container Orchestration, Cloud Native Architecture, Observability, and Application Delivery.
- KCNA is MCQ-only, which is why ClaudeLab can prep it end-to-end. CKA, CKAD, and CKS need real cluster time; KCNA does not.
- Typical roadmap is 3 to 6 weeks for working engineers, 6 to 8 for candidates new to containers.
- Pass guarantee eligibility requires every milestone done, two mock exams passed, one gauntlet at 80 percent or higher, and a live readiness score of 80 or higher when you sit the exam.
What the KCNA exam is
KCNA is built for engineers and adjacent roles who want a credential that says "I understand how Kubernetes and the cloud native ecosystem fit together," without committing to a hands-on lab exam yet. The questions stay at the concept and recall level, with some scenario items, and the exam is light on syntax compared to the CKA series. You will not write YAML under time pressure. You will recognize which Kubernetes object solves which problem and which CNCF graduated project lives at which layer of the stack.
Domain weights, current as of 2026
| Domain | Weight |
|---|---|
| Kubernetes Fundamentals | 46% |
| Container Orchestration | 22% |
| Cloud Native Architecture | 16% |
| Cloud Native Observability | 8% |
| Cloud Native Application Delivery | 8% |
The blueprint is unusually top-heavy. Almost half the exam sits in Kubernetes Fundamentals, which means strong coverage of core API objects (Pods, Deployments, Services, ConfigMaps, Secrets, Namespaces, RBAC primitives) is the single biggest-payoff investment. The two smallest domains, Observability and Application Delivery, are each only 8 percent, but they still appear on every exam form and the score is sensitive enough that ignoring them costs the pass on borderline attempts.
MCQ format and proctored delivery
KCNA runs through the Linux Foundation testing platform, online proctored, with a webcam check and a quiet-room rule. You get 60 multiple-choice or multiple-select items in 90 minutes. The questions are written in English and the platform shows you a clean web UI with one item per screen, a flag-for-review function, and a navigator. There is no scratch terminal, because nothing on the exam asks you to run a command. That is the structural distinction from CKA, CKAD, and CKS, where you are dropped into a real cluster and graded on what you do with it.
If the adaptive scoring on ClaudeLab is unfamiliar, the underlying convergence math is the same idea: why 25 questions beats 50, the CAT evaluation in plain English. The KCNA exam itself is fixed-form, not adaptive, but the prep evaluation that decides your roadmap is.
Where KCNA sits in the CNCF line
KCNA is the only beginner-tier exam in the CNCF Kubernetes credential family. The others (CKA, CKAD, CKS) are all intermediate-to-expert and performance-based on real clusters. KCNA is therefore the cleanest first credential for candidates with limited cluster exposure, and it carries enough weight on a resume to validate cloud native foundations on its own. The credential is valid for two years and renews through retake or higher credential pass.
How ARIA preps you for it
KCNA gets one of the shortest roadmaps in the catalog, because the blueprint is concept-heavy and the exam is MCQ-only.
The CAT evaluation hits all five domains in 15 to 25 questions. I open every cert with a CAT adaptive test. For KCNA, with only five domains and Kubernetes Fundamentals at 46 percent, the evaluation tends to sample heavily on Fundamentals and lightly on each of the four smaller domains. That domain-by-domain read decides which phase your roadmap opens with. Novices on Fundamentals get a strict foundation-first sequence; candidates already strong on Fundamentals get straight into the orchestration and architecture phases.
The roadmap is short and front-loaded. Working engineers studying 30 to 45 minutes a day usually finish in 3 to 6 weeks. Candidates new to containers stretch to 6 to 8 weeks. The first two phases live almost entirely in Kubernetes Fundamentals because the exam weights it so heavily. The four smaller domains share the back half of the roadmap. See the roadmap overview for how phases, milestones, and tasks fit together.
Practice sessions train recognition, not syntax. KCNA is concept recognition under time pressure. The drill is being able to read a short scenario and pick the right Kubernetes object, service mesh layer, or CNCF project from four close options. I build practice sessions around that pattern from milestone one, because the cost of running a syntax-heavy practice routine for an MCQ exam is wasted weeks.
The error backlog tags concept versus framing. Every wrong answer goes into a backlog with a tag. Did you miss it because you did not know what a StatefulSet does, or because you confused it with a Deployment under time pressure? Concept misses come back as targeted micro-sessions within 24 hours. Framing misses come back as scenario drills a few days later. See the error backlog for the full mechanism.
The demo test mirrors exam conditions exactly. The demo test is a full 60-item exam-conditions session at 90 minutes, locked until 60 percent readiness. I require one demo pass at 75 percent or higher before the gauntlet unlocks, because the demo replicates the exact MCQ rhythm KCNA enforces. The gauntlet then layers in fatigue and unfamiliar phrasing, because the only way to find out whether your decisions hold up at item 55 is to do item 55 under load.
Readiness gates the demo test and the gauntlet. The demo test is locked until 60 percent readiness. The gauntlet is locked at 80 percent. Both reflect the point at which the next session type produces signal instead of noise. See readiness and decay for how the score moves and why it drops if you go quiet.
Common pitfalls on KCNA
These are the topics that quietly cost the most points.
Confusing similar Kubernetes objects. Deployments versus StatefulSets versus DaemonSets. ConfigMaps versus Secrets. Services versus Ingresses versus Gateway API. The exam writes distractors out of these confusions on purpose. I run dedicated discrimination drills inside the Kubernetes Fundamentals milestones so the distinction becomes reflexive.
Underweighting the smaller domains. Observability and Application Delivery are each 8 percent. Candidates who skim them and load up on Fundamentals can still fail when the smaller-domain items run against them on the day. I require milestone coverage proportional to the weights, including the 8-percent domains, because the math says ignoring 16 percent of the exam is a worse bet than people think.
Treating KCNA like CKA. The instinct from CKA prep materials is to drill kubectl syntax and YAML composition. KCNA does not test that. The exam asks you to recognize which object solves which problem, not to write the manifest. Spending two weeks on kubectl scripting is two weeks not spent on cloud native architecture and the CNCF landscape, which is where the exam actually probes.
The CNCF project landscape. The exam tests recognition of which graduated projects (Prometheus, Envoy, Helm, containerd, CoreDNS, Linkerd, OpenTelemetry, and others) live at which layer of the stack. Candidates from a single-cluster operations background sometimes underweight this, because day-to-day work does not require fluency across the whole CNCF graduated and incubating lists. I cover the landscape inside the Architecture and Observability milestones.
Cloud native principles versus Kubernetes specifics. A real portion of the exam tests cloud native philosophy: declarative APIs, immutable infrastructure, twelve-factor patterns, the loose-coupling rationale. These are not Kubernetes commands. They are the design rationale behind Kubernetes, and the exam asks about them directly. I run a dedicated principles module in the first Architecture milestone.
Service mesh and security at the concept level. mTLS, service mesh data plane versus control plane, network policies, RBAC. KCNA does not ask you to write a NetworkPolicy. It asks you to recognize why one exists and what problem it solves. Candidates from a developer background often skip these; candidates from an operations background often go too deep. I calibrate the depth to where CNCF actually tests.
Common Questions
Is KCNA a hands-on lab exam like CKA?
No. KCNA is the only multiple-choice exam in the CNCF Kubernetes line. CKA, CKAD, and CKS are all performance-based on real clusters; KCNA is 60 MCQs in 90 minutes, online proctored. That difference is why KCNA is the right starting point for candidates who do not yet have terminal time on a live cluster, and why ClaudeLab can prep it end-to-end without a lab-pairing caveat.
Does KCNA require any prerequisites or experience?
No formal prerequisites. CNCF positions KCNA as a beginner credential for anyone interested in cloud native technologies, including students, junior engineers, and people pivoting from adjacent roles. The exam assumes general familiarity with containers and Linux command line at a conceptual level, but it does not require production cluster experience.
Should I do KCNA before CKA or skip straight to CKA?
If you can already operate kubectl confidently on a real cluster and have shipped workloads to Kubernetes in any role, go straight to CKA. If your Kubernetes exposure is mostly conceptual, KCNA first is the cheaper and faster credential to validate the foundation, and it sets up CKA prep with less wasted ramp-up. Most candidates without daily cluster work do KCNA in 4 to 8 weeks, then CKA in another 8 to 12.
How long should I expect to study for KCNA?
At 30 minutes a day, plan on 4 to 6 weeks. At 45 minutes a day, 3 to 4 weeks. At 60 minutes a day, 2 to 3 weeks. KCNA is the shortest typical roadmap in the CNCF Kubernetes line, because the exam is concept-focused and the domain weights load heavily into Kubernetes Fundamentals. Novices with no container background should add 2 weeks.
How is KCNA scored?
75 percent or higher to pass, on 60 multiple-choice and multiple-select items delivered over 90 minutes. The exam is online proctored through the Linux Foundation testing platform. You get one free retake within 12 months if you fail the first attempt. There is no scaled scoring; the percentage is straightforward.
What readiness score unlocks the demo test for KCNA?
Sixty. Below 60 readiness, the demo test stays locked. The demo test is a full 60-question exam-conditions session at exam difficulty. Below 60 it produces noisy data; above 60 it surfaces the framing slips that still cost points under the 90-minute clock.
Where do I see whether I am eligible for the pass guarantee?
On the dashboard, once all five conditions hold. The check runs after every milestone validation, and the eligibility flag flips automatically. Read the full breakdown of the conditions on the pass guarantee page, and the adaptive cert prep explained article for the structural reasoning behind the design.
Start your KCNA roadmap
The cheapest possible signal is a 15 to 25 question CAT evaluation against the KCNA blueprint. The output is a domain-by-domain skill estimate across the five domains, a roadmap sequenced from your weakest area forward, and your day-one task. If the evaluation lands you Novice on Kubernetes Fundamentals, the roadmap opens with object recognition and core API drills. If you are already strong there, the roadmap goes into Architecture and the CNCF landscape sooner.
Either way, the measurement is more useful than another month of unmeasured study. Open the KCNA onboarding flow and start the evaluation. From there, practice sessions take over the daily cadence, and I pick the next task every time you reopen the app.