20 Free KCNA Sample Questions with Answers

How to use these KCNA practice questions

Work through the 20 KCNA sample questions in one sitting without looking anything up. For each question, decide on an answer first, then open the answer and read the explanation, including when you were right, because a correct guess and a correct line of reasoning look identical until the exam rewords the question. Mark every question as right, wrong or guessed, and count a guess as wrong when you score yourself. Give the set about 30 minutes, which is the average time per question on the real exam multiplied by twenty. The aim is to find out which exam domains are already solid and which ones need study before you buy the exam.

The official exam format is 60 questions in 90 minutes, with a passing score of 75%, according to the Linux Foundation documentation checked on 2026-10-23.

With JavaScript enabled, each answer starts collapsed behind a Show answer button so you can test yourself. Without JavaScript, and for any crawler or screen reader that reads the raw page, every answer and explanation is already visible below its question.

These questions were written for GoldenKube practice. They are not copied from the real exam, and nothing on this page tells you what the real exam will ask.

• Read the question twice and underline the constraint words: "most", "least", "first", "only", "not".
• Eliminate options you can prove wrong before you pick between the rest.
• Where a question says to select all that apply, every correct option must be chosen and none of the wrong ones.
• Read the explanation even for questions you got right; it often names the nearby concept the exam likes to swap in.

Kubernetes Fundamentals (9 questions)

Container Orchestration (6 questions)

Cloud Native Application Delivery (3 questions)

Cloud Native Architecture (2 questions)

Score yourself

The Linux Foundation lists a passing score of 75% for KCNA. On a set of 20 questions that is 15 correct. Reaching 15 here is a useful signal and not a prediction: 20 questions is a small sample, and the real exam covers every domain in its published weights. Use the table below to decide what to do next. Count only the questions you answered correctly without help, and be strict about it: a question you got right for the wrong reason belongs in the missed pile. Then repeat the exercise a few days later with a different set from the full bank so that you are measuring understanding and not memory of these specific questions.

Count your misses per domain, using the headings above. One missed question in a domain is noise; three misses in one domain is a study plan. The practice mode on GoldenKube does this sorting for you by sending you back to the domains where you are weakest.

Kubernetes Fundamentals: what it tests

Kubernetes Fundamentals is the largest KCNA domain and covers what a cluster is made of and how you describe work to it. Expect the control plane components (API server, etcd, scheduler, controller manager), the node components (kubelet, kube-proxy and the container runtime), and the core API objects: Pods, ReplicaSets, Deployments, StatefulSets, DaemonSets, Jobs, Services, ConfigMaps, Secrets and Namespaces. Questions usually describe a situation and ask which object or component is responsible, so knowing the single job of each piece matters more than memorising field names. Typical traps are swapping similar objects, such as a Deployment and a StatefulSet, or crediting the kubelet with a decision that the scheduler makes.

Study by tracing the request path: a manifest reaches the API server, is stored in etcd, is noticed by a controller, is placed by the scheduler and is started by the kubelet. If you can narrate that path from memory, most component questions reduce to recalling one step of it.

Container Orchestration: what it tests

Container Orchestration covers how containers are run, connected and kept alive once Kubernetes owns them. Expect container runtimes and the Container Runtime Interface, images and registries, container networking and the CNI plugin model, service discovery and DNS, storage through volumes and the CSI, scheduling, and the basics of securing workloads with RBAC and Pod security settings. The domain rewards clear boundaries between similar interfaces: CRI is for runtimes, CNI for networking and CSI for storage. A frequent trap is mixing up the different autoscalers, since the Horizontal Pod Autoscaler changes replica counts, while other autoscalers change resource requests or the number of nodes. The wording is often a scenario, so identify the layer involved before you read the answer options.

A useful drill is to take each of the three plugin interfaces and name one thing it standardises, one thing it does not, and one example implementation. Doing the same for the autoscalers takes five minutes and closes a common source of lost points.

Cloud Native Application Delivery: what it tests

Cloud Native Application Delivery is about how code gets from a repository to a running cluster and how releases are made safe. Expect continuous integration and continuous delivery, the idea of GitOps with a pull-based agent, packaging with tools such as Helm and Kustomize, and rollout strategies including rolling updates, blue-green and canary releases. Questions tend to test definitions and trade-offs, for example when a canary release is preferable to a blue-green switch, or what separates continuous delivery from continuous deployment. A common trap is describing GitOps as any pipeline that stores files in Git, when the defining feature is that an agent continuously reconciles the cluster toward what Git declares.

Write one sentence for each strategy that starts with the risk it reduces and ends with the cost it adds. The exam usually asks for the better fit for a stated risk, and that sentence is the answer.

Cloud Native Architecture: what it tests

Cloud Native Architecture is the broadest and most conceptual KCNA domain. Expect the role of the CNCF and its project maturity levels (sandbox, incubating and graduated), the characteristics of cloud native systems such as resilience, elasticity and loose coupling, autoscaling and serverless ideas, the three observability signals of metrics, logs and traces, and community topics such as roles and open standards. Because the domain is small, a handful of questions decide it. A frequent trap is attributing the wrong job to a well-known project, for example confusing a metrics system with a tracing system, so learn one sentence per major CNCF project and which signal it handles.

Skim the CNCF landscape once with a single purpose: for each category, remember one graduated project and what it does. That is usually enough for the architecture questions at this level.

What a 20-question KCNA sample can and cannot tell you

A set of 20 questions is a screening test, not a measurement. With only a few questions per domain, one lucky guess or one unlucky wording moves your result by five percentage points, and a domain with only two questions behind it says almost nothing about that domain's true strength. The set is also fixed, so after one read-through it measures your memory of these items and not your command of KCNA. Use it to choose where to start studying, not to decide whether you are ready, and then rely on the larger bank, where questions repeat only after a gap and the app tracks which domains stay weak.

A second limit is style. Written practice questions share one author voice, while a real exam draws on many writers and reads differently. Treat any practice score, here or elsewhere, as one input next to the official curriculum, hands-on experience with the technology, and the documentation of the project itself.

A one-week plan after the KCNA sample set

After the sample set, spend a week turning the result into a plan. Start with the domains where you missed questions and read the matching part of the official curriculum before you try more questions, because practice is far more useful once you can explain the topic. Return to practice in short daily sessions, review every missed question the next day, and leave the last day for a fresh mixed set. Keep a simple note of which concepts caused misses; the same three or four ideas usually explain most of them, and naming them is what turns practice into progress.

The largest KCNA domain is Kubernetes Fundamentals, at 44% of the published weights. If two domains tie for weakest in your tally, start with the heavier one, and keep the other 3 domains ticking over with short reviews.

Adjust the pace to your calendar. If you have more time, spread the same steps over two or three weeks and add a second mixed session at the end of each week. If you have less, keep days 1 to 3 and day 6 and accept a rougher picture. What matters is that every study session starts from a specific weak domain and ends with a check, not that the plan is followed to the letter.

Practice the full KCNA bank

These 20 questions are a small slice of the GoldenKube KCNA bank, which holds more than 250 questions. In practice mode the app serves the questions you are due to review first, then the domain where you are weakest, and it brings missed questions back after a gap until you answer them correctly. You can answer 10 questions as a guest without an account; after that a free account keeps your progress, and no credit card is asked for at any point. Each answer comes with the same kind of written explanation you saw on this page, so a wrong answer is always followed by the reasoning that fixes it.

Practice mode shows one question at a time and gives the verdict and explanation as soon as you answer. A focus option lets you stay inside a single domain until it feels solid, which is the natural next step after finding your weakest domain on this page. There is no timer and no exam simulation in practice mode; the goal is learning, not performance under pressure.

Frequently asked questions