Skip to content
Français
Account: not signed in, sync available My learning
Select theme
Français

Prepare for the KCNA: complete study guide

By updated

Improve this page

Logo Kubernetes

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.

SituationWhat the KCNA gives you
You are discovering KubernetesA structured validation of your basic knowledge
You come from DockerA bridge to cloud native, beyond containers alone
You are preparing for the CKA/CKADA solid foundation that speeds up what follows
You are a manager or an architectA proof of understanding, with no need for hands-on mastery
You are changing jobsA 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.

ItemValue
Duration90 minutes
TypeOnline MCQ, proctored
Minimum score75%
Retake1 retake included
Price250 USD
Validity2 years
Eligibility12 months to sit the exam after purchase
LanguagesEnglish, with Chinese and Japanese versions
PrerequisitesNo official prerequisite
DocumentationNone: 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.

  1. 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.

  2. Understand why containers are orchestrated

    You know that Docker alone does not handle scaling, resilience or service discovery. You understand why Kubernetes exists.

  3. 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.

  4. 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%.

DomainWeightWhat it covers
Kubernetes Fundamentals44%Architecture, components, core resources, API, kubectl
Container Orchestration28%Scheduling, scaling, service discovery, networking, storage
Cloud Native Application Delivery16%CI/CD, GitOps, Helm, application deployment
Cloud Native Architecture12%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.

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 confuseHow to tell them apart
Pod / containerThe Pod is the Kubernetes wrapper, the container is the process inside
Deployment / ReplicaSetThe Deployment manages updates, the ReplicaSet maintains the number of replicas
Service / IngressThe Service gives a stable address to a set of Pods, the Ingress routes external HTTP traffic to Services
CNI / CSI / CRIContainer Network / Storage / Runtime Interface: three interfaces, three concerns
OCI / CNCFOCI = container standards, CNCF = cloud native ecosystem
ConfigMap / SecretSame 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.

TipWhy
Read each question twiceA negative wording ("which is NOT...") or a nuance ("best describes") can reverse the meaning
Eliminate firstDiscarding the clearly wrong answers brings the choice down to the essentials
Do not get stuckMark the question and come back to it: use the 90 minutes wisely
Take care with vocabularyPod ≠ container, Service ≠ Ingress, CNI ≠ CSI: MCQs test these distinctions
Practice without helpWith 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.

ItemKCNACKADCKACKS
CNCF levelAssociateDeveloperAdministratorSpecialist
FormatMCQHands-on (terminal)Hands-on (terminal)Hands-on (terminal)
FocusConceptsApplicationsClusterSecurity
Official prerequisiteNoneNoneNoneCKA passed
Duration90 min2h2h2h
Price250 $445 $445 $445 $
Min score75%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.

PitfallConsequenceSolution
Neglecting Kubernetes fundamentalsUp to 44% of the score at stakeSpend about half of your time on them
Focusing only on practiceThe exam is theoretical (MCQ)Also revise the concepts, not only the commands
Ignoring the CNCF ecosystemQuestions may cover Prometheus, Envoy, OPA...Take a tour of the CNCF landscape
Not doing practice MCQsSurprise at the format and the vocabulary of the questionsTake the site's mock exam (in French), then go back over the missed topics
Underestimating the English vocabularyThe exam is offered first in EnglishRevise the English terms of the key concepts

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.

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 siteStatus
Kubernetes Fundamentals (44%)Architecture, Pods, Deployments, Services, Namespaces, ConfigMaps, RBACGood
Container Orchestration (28%)Scheduling, HPA, Storage, Network Policies, DNSGood
Cloud Native Application Delivery (16%)GitOps, ArgoCD, Helm, Docker, DockerfileFair
Cloud Native Architecture (12%)Cloud native principles, CNCF, service mesh, serverless, observabilityIn 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

  1. 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
  2. Kubernetes Fundamentals represents 44%: spend about half of your preparation on it
  3. 75% minimum score, which is more demanding than the 66% of the CKA and the CKAD
  4. 250 USD with 1 retake included, the same price as the KCSA and well below the 445 USD of the CKA and the CKS
  5. 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
  6. The CNCF ecosystem is part of the syllabus: know the main families of tools and the emblematic projects
  7. Learn to reason about MCQs: telling concept, tool, role and benefit apart makes the difference
  8. 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

7 questions
5 min
80% to pass

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