The KCNA (Kubernetes and Cloud Native Associate) is the entry-level certification of the CNCF, the foundation that hosts Kubernetes. It validates that you understand Kubernetes and the cloud native ecosystem, and it prepares you for the more advanced certifications (KCSA, CKAD, CKA, CKS). Unlike them, it is a theory exam: a multiple-choice questionnaire (MCQ), with no terminal and no cluster to work on. It tests your knowledge, not your speed at the keyboard.
This page is the KCNA preparation hub. It presents the exam format, the four domains of the blueprint (the official syllabus published by the CNCF) with the lessons of the site to read for each one, then a four-week study plan.
What you will learn
- Place the KCNA in the CNCF certification path
- Know the exam format and the conditions for passing it
- Split your study time across the 4 blueprint domains according to their weights
- Identify what you must be able to explain in each domain, and the lessons that cover it
- Reason about multiple-choice questions and avoid the classic confusions
- Follow a 4-week study plan, and adapt it to the time you have
What does the KCNA validate?
The KCNA certifies that you understand the foundations of Kubernetes and of the cloud native ecosystem. In practice, it covers six families of knowledge:
- Kubernetes architecture: clusters, nodes, control plane, Pods, namespaces;
- core resources: Deployments, Services, ConfigMaps, Secrets;
- container orchestration: why orchestrate, scheduling, scaling, service discovery;
- the cloud native landscape: the main families of tools and a few emblematic CNCF projects;
- delivery principles: CI/CD, GitOps, immutable infrastructure;
- security basics: Kubernetes good practices, isolation, access control.
The name "associate" is misleading: the KCNA is neither a hands-on exam, nor an administration, development or security certification. The section "What the KCNA does not ask" details what stays outside its scope. It checks that you have the theoretical foundation needed before tackling the hands-on certifications.
Why take the KCNA?
The KCNA plays a precise role in the CNCF certification path. Look in the table for the row that matches your situation, because the value of this certification varies widely with your starting point. For a technical profile already comfortable with Kubernetes, the benefit is mostly the structuring of your knowledge: while revising, you discover the areas you used without understanding them. For a non-technical profile, it is a proof of understanding that you obtain without sitting an exam in a terminal.
| Situation | What the KCNA gives you |
|---|---|
| You are discovering Kubernetes | A structured validation of your basic knowledge |
| You come from Docker | A bridge to cloud native, beyond containers alone |
| You are preparing for the CKA/CKAD | A solid foundation that speeds up what follows |
| You are a manager or an architect | A proof of understanding, with no need for hands-on mastery |
| You are changing jobs | A signal on your resume for cloud native roles |
What is the KCNA exam format?
Two rows of the table change the way you revise. The minimum score of 75% is higher than the 66% of the CKA and CKAD hands-on exams: the margin for error is smaller than people think. The hands-on exams also leave the Kubernetes documentation open, whereas the KCNA is taken without documentation (see the last row). You therefore have to know everything by heart: understanding is not enough, you must be able to name things.
| Item | Value |
|---|---|
| Duration | 90 minutes |
| Type | Online MCQ, proctored |
| Minimum score | 75% |
| Retake | 1 retake included |
| Price | 250 USD |
| Validity | 2 years |
| Eligibility | 12 months to sit the exam after purchase |
| Languages | English, with Chinese and Japanese versions |
| Prerequisites | No official prerequisite |
| Documentation | None: external tools, resources and sites are forbidden during the exam |
These values were collected on November 14, 2026. The minimum score of 75% comes from the Linux Foundation multiple-choice exam FAQ, which also sets the duration at 90 minutes and the validity at 2 years. The price, the included retake and the format can be checked on the official KCNA page. The number of questions is not published on that page, so the table does not show it.
The documentation rule comes from the Linux Foundation Resources Allowed page, collected on November 14, 2026: during a multiple-choice exam, candidates have no access to any external tool, resource or site. The KCNA is an exam of this type, so the Kubernetes documentation is not open during it. If the other values differ, the Linux Foundation candidate handbook prevails.
What should you know before you start?
Before starting the KCNA preparation, check that you have these four foundations. If one is missing, start with it: the study plan on this page assumes they are in place.
-
Understand what a container is
You must know what an image, a container and a Dockerfile are. You have already run a Docker container at least once.
-
Understand why containers are orchestrated
You know that Docker alone does not handle scaling, resilience or service discovery. You understand why Kubernetes exists.
-
Have read about the Kubernetes architecture
You know the words control plane, API Server, kubelet, Pod, Node, even if you do not master them perfectly yet.
-
A minimum of DevOps culture
You know what CI/CD and Git are. You understand the idea of automating deployment.
What are the four domains of the blueprint?
The official CNCF blueprint defines the domains and their weights. These percentages indicate the weight of each domain in the score: split your study time in the same proportions rather than according to your preferences. The first two domains alone weigh 72% of the exam: if you neglect them, even a perfect score on the other two (28%) cannot reach the required 75%.
| Domain | Weight | What it covers |
|---|---|---|
| Kubernetes Fundamentals | 44% | Architecture, components, core resources, API, kubectl |
| Container Orchestration | 28% | Scheduling, scaling, service discovery, networking, storage |
| Cloud Native Application Delivery | 16% | CI/CD, GitOps, Helm, application deployment |
| Cloud Native Architecture | 12% | Microservices, immutable infrastructure, autoscaling, serverless |
Remember this: almost half of the exam is about Kubernetes fundamentals. That is where the certification is won or lost, and having already practiced does not exempt you from revising this domain, because the exam asks you to name what daily use leaves implicit.
The lessons are not all in the same place. Domains 1 and 2 are revised with the lessons of the Kubernetes course, grouped in the KCNA track of the syllabus. Domains 3 and 4 rely mostly on guides from other courses of the site: Cloud native (in French), Helm (in French), ArgoCD (in French) and Observability (in French). These guides do not count toward your progress in the Kubernetes course. The W3 tab of the study plan gives the exact list.
Domain 1: Kubernetes Fundamentals (44%)
This is the core of the exam. You must understand how Kubernetes works, not only how to use it.
Cluster architecture
Rather than memorizing the list of components, remember who does what. Two confusions are to be avoided. The Scheduler decides on which node to place a Pod, whereas the Controller Manager watches the gap between desired state and actual state. And only the API Server talks to etcd: no other component accesses it directly.
- The control plane: API Server, etcd, Scheduler, Controller Manager
- The worker nodes: kubelet, kube-proxy, container runtime
- The role of each component and how they communicate
Core resources
For each of these resources, know how to answer two questions: which problem it solves, and which resource it replaces or complements. A Deployment does not replace a Pod: it drives Pod creation through an intermediate ReplicaSet. A Namespace does not isolate the network by default, only object names, which surprises people. And the difference between a ConfigMap and a Secret is not about storage security but about intent and how the cluster treats them.
- Pods: the basic unit, and why not a single container
- Deployments: scaling, rolling updates, rollbacks
- Services: ClusterIP, NodePort, LoadBalancer, internal DNS
- ConfigMaps and Secrets: configuration injection
- Namespaces: logical isolation
The Kubernetes API
The conceptual point to master is the declarative model: you describe what you want to obtain, and control loops work continuously to get there. This is what sets Kubernetes apart from a classic deployment tool, and what explains self-healing. On the API side, know how to recognize which group a resource belongs to: Pods and Services live in the core group v1, Deployments in apps/v1, Jobs in batch/v1.
- The declarative model (desired state and actual state)
- API groups (
apps/v1,batch/v1, etc.) kubectl: the essential commands (get,describe,apply,delete)
What you should be able to explain
These four questions are a self-assessment test, not a list to memorize. Formulate the answer out loud, without notes: if you hesitate on a link in the chain, you have just identified a gap. The first question is the most revealing, because answering it completely involves the API Server, etcd, the Controller Manager, the Scheduler and the kubelet, that is, the whole of domain 1 in a single explanation.
- What happens when you run
kubectl apply -f deployment.yaml? - Why does a Pod stay in
Pending? - What is the difference between a ReplicaSet and a Deployment?
- How does a Service find the Pods it must expose (labels and selectors)?
To work on this domain, start with the key concepts of Kubernetes, the essential vocabulary (cluster, Node, Pod, Deployment, Service), then the architecture to know who does what between the control plane, the worker nodes and the internal components. Resources are then read in the order in which they stack up: Pods, the basic unit, Deployments to deploy and scale, Services to expose internally and externally, and Namespaces for logical isolation.
Domain 2: Container Orchestration (28%)
This domain tests your understanding of why and how to orchestrate containers at scale.
Why orchestrate
Be able to say which problem an orchestrator solves on top of running containers. Docker starts a container on one machine. Kubernetes keeps a desired number of replicas running across a set of machines, replaces them when they fail and makes them reachable under a stable name. The comparison with Docker Swarm or Nomad does not call for technical detail: it is enough to know that they are competing orchestrators.
- The limits of Docker alone (scaling, resilience, service discovery)
- What an orchestrator brings (scheduling, health checks, auto-healing)
- Kubernetes versus the alternatives (Docker Swarm, Nomad)
Scheduling and placement
The mechanism to understand has two steps: the Scheduler first filters out the nodes that cannot host the Pod, then ranks the survivors to choose the best one. The requests come into play in the filtering phase, not the limits: a Pod that asks for 2 GB will never be placed on a node that has only 1 GB left. Also remember the distinction between the taint, set on the node to repel Pods, and the toleration, set on the Pod to accept that repulsion.
- How the Scheduler places Pods on nodes
- Affinities, taints and tolerations (principles, not detailed syntax)
- Requests and limits: their role in scheduling
Scaling and resilience
Distinguish two levels of automation. The ReplicaSet maintains a fixed number of replicas, decided by you; the HPA varies that number according to an observed metric, typically CPU usage. Self-healing belongs to neither: it is the kubelet that restarts a failed container in place, and the controller that recreates a whole Pod if the node disappears.
- Horizontal Pod Autoscaler (HPA): how it works
- ReplicaSets: keeping the desired number of replicas
- Self-healing: automatic restart of failed Pods
Networking and service discovery
The founding rule of the Kubernetes network model fits in one sentence: every Pod has its own IP address and can reach any other Pod without address translation. The other notions follow from it. Because these addresses change each time a Pod is recreated, the Service provides a stable name and address, and internal DNS makes that name resolvable. NetworkPolicies then restrict what is, by default, entirely open.
- The Kubernetes network model (every Pod has an IP)
- Services and internal DNS (
service.namespace.svc.cluster.local) - NetworkPolicies: network isolation principles
Storage
Storage splits the responsibilities among three objects. The PersistentVolume represents the actual storage and is the administrator's concern; the PersistentVolumeClaim is the request made by the application and is the developer's concern; the StorageClass automates the creation of the first from the second. Also know that an emptyDir volume disappears with the Pod, whereas a persistent volume outlives it.
- Ephemeral and persistent volumes
- PersistentVolumes (PV) and PersistentVolumeClaims (PVC)
- StorageClasses: dynamic provisioning
The guide Why an orchestrator? explains the limits of Docker alone and what orchestration brings, which answers the first part of the domain. For placement, requests and limits details the management of the CPU and memory resources the Scheduler uses, and the guide on the HPA shows horizontal autoscaling. On the network side, the Kubernetes network model comes before the Network Policies, which isolate Pods from each other, and the Storage guide covers PVs, PVCs and StorageClasses.
Domain 3: Cloud Native Application Delivery (16%)
This domain covers the delivery chain of cloud native applications.
CI/CD and deployment
What is expected is the vocabulary and what each deployment strategy actually does. A rolling update replaces instances progressively, without ever stopping everything; blue-green maintains two complete environments and switches traffic all at once; a canary exposes the new version to only a fraction of users before rolling it out to everyone. Associate each strategy with its trade-off between resource cost and exposure risk.
- CI/CD principles (continuous integration, continuous deployment)
- Build, test and deploy pipelines
- Deployment strategies (rolling update, blue-green, canary)
GitOps
The distinction between push and pull is the key to this theme. In a push model, your CI pipeline holds credentials for the cluster and sends changes to it. In a pull model, an agent installed in the cluster fetches the desired state from Git itself. The pull model is associated with GitOps because it avoids exposing access to the cluster from outside and because it automatically corrects configuration drift.
- The principle: Git as the source of truth
- The pull model and the push model
- The tools: ArgoCD, Flux (concepts, not detailed configuration)
Helm
Three words are enough, provided you do not mix them up: a chart is the package, the values are the parameters you supply, a release is a named installation of that chart in a cluster. The problem Helm solves is duplication: without it, deploying the same application in three environments forces you to maintain three nearly identical sets of manifests.
- The role of Helm in the Kubernetes ecosystem
- Charts, values, releases (vocabulary)
- Why templates make manifests easier to manage
Containers and images
Remember the role of the OCI (Open Container Initiative), and do not confuse it with the CNCF. The OCI produces technical specifications that standardize the image format and the behavior of runtimes: an image built with one tool therefore runs with another. The CNCF, for its part, hosts and governs projects. Also remember that the image is immutable: you do not modify it, you publish a new version.
- The lifecycle of a container image (build, push, pull, run)
- Registries and image distribution
- The OCI standard (Open Container Initiative)
The delivery chain is revised with the GitOps guide, where Git serves as the source of truth for infrastructure, then ArgoCD (in French) for GitOps deployment on Kubernetes and Helm (in French), the package manager. For containers and images, Docker, the basics recalls the lifecycle of an image and Write a Dockerfile shows how to build one.
Domain 4: Cloud Native Architecture (12%)
This domain tests your understanding of the architectural principles of cloud native.
Microservices
Aim for a nuanced position, not a plea. Microservices bring independent deployment and targeted scaling, at the price of higher network and operational complexity. On patterns, know how to place each one: the sidecar is an additional container in the same Pod, the service mesh generalizes this principle at cluster scale, the API gateway sits at the entry point for traffic coming from outside.
- Monolith and microservices: advantages and drawbacks
- Communication between services (synchronous or asynchronous)
- Common patterns: sidecar, service mesh, API gateway
Immutable infrastructure
The benefit you should be able to state is the disappearance of configuration drift: when no server is modified after it is created, two machines built from the same definition stay identical over time. Deployments are then reproducible and rollbacks reliable. Make the link with containers, the most visible application of this principle, and with Infrastructure as Code, which is its practical condition.
- The principle: never modify, always replace
- Infrastructure as Code (IaC) and its role
- Containers as an immutable deployment unit
Autoscaling and serverless
Three autoscaling mechanisms coexist in Kubernetes, and you must tell them apart by what they act on. The HPA adds or removes Pods, the VPA adjusts the size of Pods (their requests and limits), the Cluster Autoscaler adds or removes nodes. Serverless sits at another level: it is a model where infrastructure disappears from your concerns and where scaling can go down to zero instances, which Knative brings to Kubernetes.
- Horizontal scaling and vertical scaling
- Kubernetes HPA and Cluster Autoscaler (principles)
- Serverless and Knative (concepts)
The CNCF ecosystem
Remember the three maturity levels of projects: sandbox for projects early in their life, incubating for those that have demonstrated production use, graduated for those that have passed a full audit and have stable governance. Kubernetes and Prometheus are graduated; know two or three examples per level. Also remember that the CNCF is part of the Linux Foundation: it is not a company.
- The Cloud Native Computing Foundation: its role and governance
- Project maturity levels: graduated, incubating, sandbox
- The main families of tools (monitoring, networking, runtime, packaging) and a few representative projects
Observability
Observability weighs little in the blueprint, but its three pillars are easy to remember. Know which question each one answers: metrics tell you that there is a problem and how big it is, logs tell you what happened on a specific component, traces tell you where time was spent in a chain of calls between services. Then associate each category with a representative CNCF project.
- The three pillars: metrics, logs, traces
- The role of each pillar and the associated CNCF tool categories
The cloud native principles (in French) lay the foundations (12 factors, containers, microservices), to be read before the CNCF ecosystem (in French) which presents the CNCF, its projects and their maturity. The service mesh (in French) guide covers communication between services, mTLS and network observability, and the serverless (in French) guide places FaaS and Knative in the Kubernetes ecosystem. For observability, the fundamentals (in French) explain the three pillars, and Prometheus (in French) shows how to monitor a cluster.
Study plan (4 weeks)
This split follows the weights of the blueprint: one full week for domain 1, one for domain 2, one for the two lightest domains together, one for consolidation. Each week ends with a validation criterion worded as an explanation to produce from memory, not as a list of pages read. This is deliberate: with no documentation within reach, recognizing a notion is not enough, you must be able to recall it.
Four weeks are a model, not an imposed duration. To adapt it to your time, keep the same proportions as the blueprint. Over two weeks, devote the first to domains 1 and 2 (72% of the exam), and the second to domains 3 and 4 then to practice MCQs.
If you count in sessions rather than weeks, plan, for ten sessions, about four sessions on domain 1, three on domain 2, two on domains 3 and 4, and the last one on practice MCQs. Do not drop domains 3 and 4: a perfect score on the first two only gives 72%, below the required 75%.
Your starting point changes the duration, not the order. If you already practice Kubernetes, shorten week 1 but keep its validation criterion, because it checks that you can explain what practice leaves implicit. If you start from zero, add a week before the first one for the minimum foundation above, then follow the plan as is.
Week 1: Kubernetes Fundamentals (44%)
The goal of the week is to master the architecture and the core resources. This is almost half of the exam: spend time here.
Here is what you must study:
- The cluster architecture (control plane + worker nodes)
- Each component: API Server, etcd, Scheduler, Controller Manager, kubelet, kube-proxy
- The core resources: Pod, Deployment, Service, ConfigMap, Secret, Namespace
- The declarative model and labels/selectors
- The fundamental kubectl commands
The week is validated when you can explain out loud what happens when a Deployment is created, from kubectl apply to the running Pod.
For this week, the first cluster creates a local cluster with kind and the first deployment has you deploy an application step by step, which anchors the chain seen above. The basic resources give an overview of the objects, and ConfigMaps show configuration injection. The guides cited for domain 1 remain the reference for this week.
Week 2: Container Orchestration (28%)
The goal of the week is to understand the orchestration mechanisms.
Here is what you must study:
- The Scheduler: how it places Pods
- Affinities, taints, tolerations (concepts)
- Horizontal scaling (HPA) and vertical scaling (VPA)
- The Kubernetes network model
- Services, internal DNS, NetworkPolicies
- Storage: PV, PVC, StorageClasses
The week is validated when you can explain how Kubernetes ensures the high availability of an application (self-healing, scaling, service discovery).
On the guides side, the Control Plane describes the role of the Scheduler, requests and limits the resources it takes into account to place a Pod, and Assign nodes to Pods the affinities, taints and tolerations. The HPA and the VPA cover the two directions of scaling. On the network side, the Kubernetes network model comes before Services, CoreDNS for the internal DNS on which service discovery relies, and the Network Policies. The Storage guide ends the week with PVs, PVCs and StorageClasses. All these lessons are part of the KCNA track of the syllabus.
Week 3: Application Delivery (16%) + Architecture (12%)
The goal of the week is to understand delivery and the cloud native principles. These two domains represent 28% together, are complementary and are best revised together.
Here is what you must study:
- CI/CD: principles, pipelines, deployment strategies
- GitOps: Git as the source of truth, pull model, ArgoCD/Flux
- Helm: charts, values, releases
- Microservices and monolith
- Immutable infrastructure
- The CNCF ecosystem: the main families of tools and the emblematic projects
- The three pillars of observability
The week is validated when you can explain the complete lifecycle of an application change (commit, build, test, deploy) in a GitOps context.
On the guides side, GitOps, ArgoCD (in French) and Helm (in French) cover delivery, Cloud native principles (in French) and CNCF ecosystem (in French) cover architecture, then the observability fundamentals (in French) and Prometheus on Kubernetes (in French) cover the three pillars.
These guides are not part of the Kubernetes course: that is why the KCNA track of the syllabus does not list them, and your progress in the course does not count them. They belong to other courses of the site, Cloud native (in French), Helm (in French), ArgoCD (in French) and Observability (in French): for the exam, the pages cited here are enough to revise these two domains for an MCQ, without following those courses in full.
Week 4: Review and practice
The goal of the week is to consolidate what you have learned and identify your gaps.
Here is what you must do:
- Reread your notes on the 4 domains
- Redo the site quizzes for each domain
- Identify your weak points and spend time on them
- Review the CNCF vocabulary (graduated, incubating projects)
- Take the KCNA mock exam (in French), which draws its questions from the four domains and returns a result per topic
You are ready to book when you regularly score above 80% on practice quizzes: the official threshold is 75%, and this margin absorbs the stress of exam day.
Finally, go through the final checklist:
- Cluster architecture: I can name and describe each component
- Core resources: Pod, Deployment, Service, ConfigMap, Secret, Namespace
- Orchestration: scheduling, scaling, self-healing, service discovery
- Network: flat model, Services, DNS, NetworkPolicies
- Storage: PV, PVC, StorageClasses
- CI/CD and GitOps: principles and tools
- Helm: role, vocabulary, why it is useful
- CNCF ecosystem: at least 5 projects and their role
- Observability: metrics, logs, traces, Prometheus
- Basic security: RBAC, isolation, good practices
To practice, the Kubernetes quiz tests your fundamental knowledge in 21 questions.
What the KCNA does not ask
So that you do not spread yourself too thin, here is what is outside the scope of the KCNA, and the certification that assesses it where applicable:
- working on a cluster from the command line: it is an MCQ, not a hands-on exam;
- installing Kubernetes with kubeadm: that is the CKA;
- writing YAML manifests from memory: that is the CKA or the CKAD;
- configuring advanced security policies: that is the CKS;
- mastering Helm in depth: that is the CKAD;
- debugging Pods under time pressure: that is the CKA or the CKAD.
The KCNA tests your conceptual understanding, not your speed of execution.
How to reason about KCNA multiple-choice questions
The KCNA is not a speed exam, it is an exam of conceptual precision. Each question asks you to tell similar notions apart, to identify the exact role of a component or to recognize a cloud native principle.
Tell categories apart
For each notion, practice saying whether it is:
- a concept (microservices, immutable infrastructure, GitOps);
- a tool (Prometheus, Helm, ArgoCD);
- a role or a component (kubelet, API Server, Scheduler);
- a benefit (portability, resilience, observability).
This grid avoids level confusions. A question like "Which component is primarily responsible for scheduling?" checks, for example, that you do not confuse the Scheduler with the Controller Manager.
Classic confusions to eliminate
These six pairs are common confusions: an approximate understanding is enough to work day to day, not to answer a precision question correctly. Treat the last row with care: the base64 of a Secret is an encoding, not an encryption, and anyone with access to the object can read it. This is the kind of nuance a precision question can test.
| Easy to confuse | How to tell them apart |
|---|---|
| Pod / container | The Pod is the Kubernetes wrapper, the container is the process inside |
| Deployment / ReplicaSet | The Deployment manages updates, the ReplicaSet maintains the number of replicas |
| Service / Ingress | The Service gives a stable address to a set of Pods, the Ingress routes external HTTP traffic to Services |
| CNI / CSI / CRI | Container Network / Storage / Runtime Interface: three interfaces, three concerns |
| OCI / CNCF | OCI = container standards, CNCF = cloud native ecosystem |
| ConfigMap / Secret | Same mechanism, but Secrets are base64-encoded and meant for sensitive data |
Watch the wording
In an English MCQ, some wordings change the meaning of the question. Pay attention to:
- "Which is NOT…": the negation reverses the reasoning;
- "Best describes…": several answers may seem correct, but only one is the most precise;
- "Primarily responsible for…": look for the main role, not a secondary one;
- "Which of the following…": read all the options before answering.
Exam day strategy
Since the number of questions is not published, split your 90 minutes into two passes: a first read to answer the questions you master, then a time to review the marked questions. The real risk is reading too fast a negative wording or a nuance of vocabulary. So do not submit the exam as soon as the last answer is ticked.
| Tip | Why |
|---|---|
| Read each question twice | A negative wording ("which is NOT...") or a nuance ("best describes") can reverse the meaning |
| Eliminate first | Discarding the clearly wrong answers brings the choice down to the essentials |
| Do not get stuck | Mark the question and come back to it: use the 90 minutes wisely |
| Take care with vocabulary | Pod ≠ container, Service ≠ Ingress, CNI ≠ CSI: MCQs test these distinctions |
| Practice without help | With no documentation within reach, everything is played from memory: practice quizzes are essential |
How does the KCNA compare with other CNCF certifications?
The KCNA is the entry door of the certification path. In the table, the Format row is the first to look at: it is the only one of these four certifications that is not taken in a terminal. Its price is also the lowest in the table and its passing threshold the highest, but 75% on an MCQ and 66% on tasks to complete in two hours cannot be compared directly. These amounts and thresholds change: check them on the Linux Foundation site before buying, or see the comparison of Kubernetes certifications.
| Item | KCNA | CKAD | CKA | CKS |
|---|---|---|---|---|
| CNCF level | Associate | Developer | Administrator | Specialist |
| Format | MCQ | Hands-on (terminal) | Hands-on (terminal) | Hands-on (terminal) |
| Focus | Concepts | Applications | Cluster | Security |
| Official prerequisite | None | None | None | CKA passed |
| Duration | 90 min | 2h | 2h | 2h |
| Price | 250 $ | 445 $ | 445 $ | 445 $ |
| Min score | 75% | 66% | 66% | 67% |
Common preparation pitfalls
These five pitfalls come from a wrong picture of the exam more than from a lack of work. The first two affect profiles that already practice Kubernetes and assume experience will be enough. The last one mostly affects non-native English speakers: the exam is offered first in English (Chinese and Japanese versions exist) and the technical vocabulary is used there with precision. Mentally translating "scheduling" or "workload" during the exam costs time and can introduce errors.
| Pitfall | Consequence | Solution |
|---|---|---|
| Neglecting Kubernetes fundamentals | Up to 44% of the score at stake | Spend about half of your time on them |
| Focusing only on practice | The exam is theoretical (MCQ) | Also revise the concepts, not only the commands |
| Ignoring the CNCF ecosystem | Questions may cover Prometheus, Envoy, OPA... | Take a tour of the CNCF landscape |
| Not doing practice MCQs | Surprise at the format and the vocabulary of the questions | Take the site's mock exam (in French), then go back over the missed topics |
| Underestimating the English vocabulary | The exam is offered first in English | Revise the English terms of the key concepts |
Recommended resources
Since the documentation is not accessible on exam day, memorization resources should be preferred over lab environments: a glossary of CNCF projects and a few sets of mock MCQs will serve you here better than a test cluster.
Official course
The LFS250, Kubernetes and Cloud Native Essentials course is the Linux Foundation course associated with the KCNA. It is not mandatory, and its value depends on your starting point: useful if you are discovering cloud native, redundant if you already practice Kubernetes and only want to fill targeted gaps.
Documentation and references
These three resources meet distinct needs. The official curriculum is the only source that is authoritative on what is assessed: start with it, and come back to it before booking the exam, because the syllabus may change. The Kubernetes documentation is for deepening a concept you have not understood well, without aiming for exhaustiveness. The CNCF Landscape is browsed by category, not project by project.
- Kubernetes Documentation, the reference for the fundamental concepts
- CNCF Landscape, the map of the cloud native ecosystem
- KCNA Curriculum (CNCF), the official blueprint of the exam
Complementary hands-on practice
Even if the exam is an MCQ, working on a cluster helps you memorize the concepts. Three gestures are enough:
- create a local cluster with kind or minikube;
- deploy a simple application (Deployment + Service);
- observe the behavior (scaling, self-healing, rolling update).
What does the site already cover?
The site covers a large part of the KCNA syllabus. The table gives an overview by domain, with the quality of coverage you can expect.
| Domain (weight) | Coverage on the site | Status |
|---|---|---|
| Kubernetes Fundamentals (44%) | Architecture, Pods, Deployments, Services, Namespaces, ConfigMaps, RBAC | Good |
| Container Orchestration (28%) | Scheduling, HPA, Storage, Network Policies, DNS | Good |
| Cloud Native Application Delivery (16%) | GitOps, ArgoCD, Helm, Docker, Dockerfile | Fair |
| Cloud Native Architecture (12%) | Cloud native principles, CNCF, service mesh, serverless, observability | In progress |
To practice the MCQ format, the KCNA mock exam (in French) draws its questions at random from the lessons of the four domains and changes the draw on each attempt. Its practice levels are timed and weighted by the four domains; the Simulation mode (in French) takes the duration and passing score of the real test (90 minutes, 75%) with 60 multiple-choice questions. Since the real number of questions is not published, these 60 questions only set a practice pace. Some cross-cutting cloud native concepts remain less covered: complete them with the external resources above.
Key takeaways
- The KCNA is a 90-minute MCQ, with no cluster to work on: the documentation is not accessible during the exam, so prepare to answer from memory
- Kubernetes Fundamentals represents 44%: spend about half of your preparation on it
- 75% minimum score, which is more demanding than the 66% of the CKA and the CKAD
- 250 USD with 1 retake included, the same price as the KCSA and well below the 445 USD of the CKA and the CKS
- It is a stepping stone, not an end in itself: the path continues to the KCSA, the CKAD, the CKA or the CKS depending on your profile
- The CNCF ecosystem is part of the syllabus: know the main families of tools and the emblematic projects
- Learn to reason about MCQs: telling concept, tool, role and benefit apart makes the difference
- Practice helps even for an MCQ: working on a local cluster anchors the concepts
Knowledge check
Seven questions on the exam format, the weight of the domains, the positioning among CNCF certifications, the study method and adapting the plan.
Knowledge check
Check what you have learned with this interactive quiz
How it works
- The timer starts when you click Start
- Multiple choice, true/false and short answer questions
- You can move between questions
- Detailed results are shown at the end
Starts the quiz and the timer
Review
(0/0)Score by domain
A domain groups several guides and gets several questions, so its score is more reliable than a per-topic score, which often rests on a single question.
Summary
Strengths
No topic passed at 80% on at least two questions yet.
Weak areas
No topic below the pass mark.
Recommended next
Hints before you try again?
Continue the course: Prepare for the KCSA: format, domains and study plan
A new full quiz with random questions
Work again only on the questions you missed