KCNA
Kubernetes and Cloud Native Associate (KCNA)
KCNA Exam Guide: What to Study, How to Prepare, and When to Schedule
The Kubernetes and Cloud Native Associate (KCNA) validates foundational knowledge of Kubernetes and the wider cloud-native ecosystem, including basic application deployment, cluster architecture, delivery practices, and core platform concepts. It is intended for beginners, students, and aspiring developers, administrators, architects, and managers who need a vendor-neutral starting point. This guide helps you decide whether your current knowledge is ready for an exam-focused review, whether structured training would be more efficient, and how to schedule the assessment without leaving technical or administrative tasks until the last minute.
What the KCNA is designed to validate
KCNA is a pre-professional, associate-level certification for candidates building foundational Kubernetes and cloud-native knowledge. It confirms conceptual understanding rather than positioning itself as an advanced administration or application-development credential.
The Linux Foundation describes KCNA as demonstrating basic knowledge of Kubernetes and cloud-native technologies, including how to deploy an application using basic kubectl commands. It also covers Kubernetes architecture—containers, pods, nodes, and clusters—the cloud-native landscape, and projects involving storage, networking, GitOps, and service mesh.
That scope makes the certification useful when your next step is deciding whether to pursue deeper Kubernetes work. It can help you organize vocabulary and relationships across the ecosystem before moving toward a professional-level Kubernetes, developer, platform, or security certification. It does not remove the need for hands-on experience or prove that you can independently operate a production cluster.
A sensible readiness question is not simply, “Have I used Kubernetes?” Ask instead whether you can explain what the main objects and components do, connect a cloud-native design choice to its purpose, and distinguish related technologies without relying on memorized product names.
Who should consider taking KCNA
KCNA is a practical entry point for people who need a broad foundation before specializing in Kubernetes administration, application development, architecture, platform engineering, or cloud-native security.
The associated Kubernetes and Cloud Native Essentials course is designed for existing and aspiring developers, administrators, architects, and managers who are new to cloud-native technologies and container orchestration. The certification page also identifies students and candidates interested in working with cloud-native technologies as suitable audiences.
You do not need a prerequisite for KCNA. That lowers the formal barrier to entry, but it should not be interpreted as a promise that no preparation is needed. A beginner can prepare effectively by building a connected mental model instead of trying to memorize isolated definitions.
You may be better served by delaying registration if containers, basic application delivery, and the purpose of a cluster are all unfamiliar. Start with introductory learning, then return to the exam domains and test whether you can describe the concepts in your own words. If you already work with Kubernetes, use the blueprint to identify neglected areas rather than assuming experience covers every domain.
How the KCNA domains determine study priority
Study time should follow the official domain distribution, with Kubernetes fundamentals receiving the largest share and the smaller domains receiving deliberate review rather than being ignored.
The current KCNA exam domains are Kubernetes Fundamentals at 44%, Container Orchestration at 28%, Cloud Native Application Delivery at 16%, and Cloud Native Architecture at 12%. These percentages are planning signals, not a substitute for learning every listed competency.
The Kubernetes Fundamentals domain covers core concepts, administration, scheduling, and containerization. This is the foundation for interpreting questions about how Kubernetes is structured and how workloads are placed and run.
The Container Orchestration domain covers networking, security, troubleshooting, and storage. Prepare to connect each topic to the operational purpose it serves: communication, protection, diagnosis, or persistence. Do not study these as unrelated feature lists.
The Cloud Native Application Delivery domain covers application delivery and debugging. Review how an application moves through a delivery process and how debugging fits into that process, rather than treating delivery as only a deployment command.
The Cloud Native Architecture domain covers observability, cloud-native ecosystem principles, and community and collaboration. Its smaller percentage still matters because it tests whether you understand the environment around Kubernetes, not only the Kubernetes API.
A useful allocation decision is to begin with Fundamentals, then use Container Orchestration to test whether your conceptual model survives operational scenarios. Finish with Application Delivery and Architecture, returning to the larger domains for spaced review. Do not compare the bare percentages without their domain labels: each percentage describes a different competency area.
Turn the blueprint into a gap analysis
Create four study columns using the official domain names, then record what you can explain, what you can demonstrate, and what remains uncertain. This turns a broad syllabus into a sequence of decisions.
For Kubernetes Fundamentals, write a short explanation of the relationship between a container, a pod, a node, and a cluster. Add basic kubectl practice only after you understand what the command is acting on. For Container Orchestration, map networking, security, troubleshooting, and storage to recognizable cluster problems.
For Application Delivery, trace a hypothetical change from source or configuration through delivery and debugging. For Architecture, define observability and identify why cloud-native projects and community collaboration affect platform choices.
Mark a topic as ready only when you can explain its purpose, identify a plausible alternative or boundary, and recognize how it connects to another domain. A glossary-only review can create false confidence because multiple-choice questions often distinguish concepts by context.
What the exam format means for preparation
KCNA is an online, remotely proctored, multiple-choice exam. The official multiple-choice instructions state that the exam contains 60 multiple-choice questions and provides 90 minutes for completion.
The exam is delivered through PSI’s Bridge platform, with remote proctoring through streaming audio, video, and screen-sharing feeds. Candidates provide their own computer, a supported operating system, one active monitor, reliable internet access, a microphone, and a webcam that can be moved to show the surroundings.
Use the official system check before exam day and review the PSI Secure Browser requirements. The secure-browser download is made available at exam launch time, so technical preparation should not be postponed until the appointment begins. The Linux Foundation recommends the latest version of Google Chrome for the scheduling experience because the secure browser is Chrome-based.
A quiet private location is part of preparation, not an optional convenience. Public spaces such as coffee shops, stores, and open office environments are not allowed. Reduce bandwidth competition on the same connection, turn off file-sync or other bandwidth-intensive services, and check camera and microphone permissions in advance.
Because the exam is multiple choice, practice should include reading the entire question, identifying the requested relationship, and eliminating answers that belong to a different layer or purpose. Do not use leaked questions or dumps: they are not a reliable way to build the knowledge the certification is intended to validate and may conflict with exam rules.
Which language and registration option fits you
KCNA exam objectives are available in English, Japanese, and Simplified Chinese, with Japanese and Simplified Chinese requiring registration for the corresponding language-specific version.
The language handbook states that candidates may switch between available languages during the exam by using the Language Control Dropdown List in the exam console when objectives are available in multiple languages. Confirm the language option attached to your registration instead of assuming that a preferred language can be added later.
The KCNA-JP offering states that exam content is available in Japanese while proctors are English-speaking. That distinction matters if you are comfortable reading Japanese technical material but need to understand the proctor interaction in English.
Choose the language in which you can compare closely related Kubernetes and cloud-native concepts most accurately. If technical terms are more familiar in English, switching languages may introduce rather than remove ambiguity. If you register for a language-specific version, verify the current product details and handbook before purchase.
A practical KCNA study roadmap
A staged plan works better than trying to cover every cloud-native project at once: establish the Kubernetes model, connect it to orchestration, study delivery and architecture, then validate recall with scenario-based review.
Begin with a baseline session. Without opening notes, explain the purpose of Kubernetes, the difference between a container and a pod, the role of a node, and what a cluster provides. Record every term you cannot explain. This first inventory determines whether you need foundational course material before exam preparation.
Next, work through Kubernetes Fundamentals. Study core concepts, administration, scheduling, and containerization together because they describe how workloads are represented and managed. Use a small practice environment or guided lab where available to deploy a simple application with basic kubectl commands. The objective is not to build a production platform; it is to connect command, object, and expected outcome.
Then move to Container Orchestration. Study networking, security, troubleshooting, and storage as questions about cluster behavior. For each topic, create a “symptom, concept, decision” note. For example, a workload that cannot communicate should prompt questions about networking rather than an immediate guess about storage or scheduling. Keep examples conceptual and use your own practice environment to verify relationships.
After that, study Cloud Native Application Delivery. Describe how an application is delivered and what debugging contributes when the result is not what you expected. Link this work back to Kubernetes objects and container behavior so that delivery is not treated as a separate vocabulary exercise.
Finish the first pass with Cloud Native Architecture. Review observability, cloud-native ecosystem principles, and community and collaboration. Your goal is to explain why these concerns influence architecture and operations, not to memorize a catalogue of CNCF projects.
Use the final phase for mixed review. Shuffle questions or prompts across all four domains, explain why an answer is correct, and identify why the alternatives are less suitable. Revisit the relevant domain whenever you miss a question; do not merely add the correct letter to a memorization list.
A focused first week
In the first study period, prioritize terminology and relationships over speed. Build a one-page map linking containers, pods, nodes, clusters, scheduling, administration, and basic kubectl use.
Use the official course outline as a sequence if you choose the Kubernetes and Cloud Native Essentials course. Its listed chapters include Course Introduction, Cloud Native Architecture, Kubernetes Fundamentals, Container Orchestration, Working with Kubernetes, and Cloud Native Application Delivery. Treat the chapter sequence as a learning path, then check your understanding against the exam domains.
At the end of the week, explain the map without notes and perform a basic application deployment in a learning environment if one is available. If you cannot explain what changed and why, spend more time on fundamentals before adding ecosystem terms.
A second-stage domain review
In the next stage, pair each domain with an output. For Kubernetes Fundamentals, produce a component relationship diagram. For Container Orchestration, produce troubleshooting decision notes. For Cloud Native Application Delivery, produce a delivery-and-debugging flow. For Cloud Native Architecture, produce short definitions and examples of observability, ecosystem principles, and collaboration.
This method exposes a common weakness: recognizing a term while reading it is not the same as selecting the correct concept in context. Ask yourself what problem a technology or practice addresses, what layer it belongs to, and which nearby concept it should not be confused with.
Use mixed practice only after each domain has received a first pass. Otherwise, a practice score can reflect familiarity with a small set of topics rather than balanced readiness.
The final review before scheduling
Before selecting an appointment, complete a review that includes every official domain and at least one practical explanation of each competency group. The decision to schedule should be based on coverage and clarity, not on having memorized a particular question bank.
Create a short list of unresolved distinctions, such as architecture versus application delivery or troubleshooting versus administration. Review those distinctions with diagrams, commands, and explanations. Avoid starting a large new course immediately before the exam; consolidate the model you already built and reserve time for the technical checklist.
If your only preparation has been watching demonstrations, add retrieval practice. Close the material and explain the purpose, input, and expected effect of each demonstrated action. Passive recognition is a frequent source of overconfidence.
How to use courses, labs, and practice questions
Use a course for structure, a lab for cause-and-effect learning, and practice questions for retrieval; none of these should replace the official domain outline.
The Linux Foundation lists Kubernetes and Cloud Native Essentials (LFS250) as a course for people new to cloud-native technologies and container orchestration, and offers it with the KCNA exam in a bundle. The course outline includes Kubernetes fundamentals, working with Kubernetes, container orchestration, cloud-native architecture, and application delivery, which aligns with the certification’s broad scope.
A lab is valuable when it requires you to predict an outcome before running a command. Afterward, record what object changed, what component was involved, and what evidence confirmed the result. This creates durable understanding without implying access to live exam questions.
Practice questions should be used diagnostically. For each missed answer, classify the error: unknown term, confused layer, misread requirement, or unsupported assumption. Then study the relevant domain rather than memorizing the item. Questions described by the Linux Foundation as clearly worded still require careful interpretation of the scenario and the concepts being tested.
Avoid a common shortcut: learning only kubectl syntax. The exam also covers the cloud-native landscape, application delivery, architecture, observability, security, storage, networking, and collaboration. Command familiarity is useful evidence of engagement, but it is not the whole KCNA scope.
Mistakes that weaken otherwise good preparation
Most avoidable problems come from studying the most visible Kubernetes commands while neglecting the surrounding concepts, or from treating scheduling and proctoring requirements as administrative details that can be handled at the last moment.
Do not equate “beginner” with “trivial.” The official experience level is beginner and there are no prerequisites, but the breadth of the domains still requires deliberate coverage. A candidate with a narrow Kubernetes role may know one operational area well while missing architecture, delivery, or ecosystem concepts.
Do not spend all your time on the 44% Kubernetes Fundamentals domain and leave the 12% Cloud Native Architecture domain untouched. The Kubernetes Fundamentals domain is the largest, but Cloud Native Architecture has its own named competencies and should receive explicit review.
Do not confuse an ability to run a command with an ability to troubleshoot its result. In practice, pause after each lab action and explain what the system should do, what evidence would show failure, and which domain contains the relevant concept.
Do not schedule before checking your equipment and location. A supported computer, one active monitor, reliable internet, working microphone, movable webcam, and private testing space should be verified before the appointment.
Do not assume you can change a reservation at any time. A scheduled exam may be rescheduled or canceled up to 24 hours before its start time; changes are unavailable when 24 hours or less remain. A no-show forfeits the registration fees and does not qualify for a retake.
Do not treat the retake as part of the initial plan. One retake per exam purchase is granted when the candidate does not achieve a passing score and remains eligible, but the retake must normally be taken within 12 months of the original exam purchase or before a corporate subscription expires, whichever comes first. Prepare to use the first attempt as the attempt you intend to complete successfully.
How to register and schedule without avoidable delays
Complete the Linux Foundation preparation checklist before trying to schedule. The Schedule button becomes active only after the Getting Started items are completed, and the scheduling flow then directs you to PSI Bridge.
From the Linux Foundation learning portal, open My Portal and select My Learning. Open the active certification using Start Certification or Resume, then complete the checklist items. Once scheduling is enabled, select a date and the time zone in which you will take the exam.
The scheduling guide states that exams require a 24-hour lead time for virtual-machine preparation, so the earliest possible reservation date is the following day. The scheduling calendar presents dates up to 60 days out. Plan around your preparation and equipment checks rather than choosing the earliest available slot automatically.
Registration provides eligibility to take the exam within 12 months of the registration date, unless a corporate subscription expires sooner. That window gives flexibility, but a long eligibility period should not become an excuse to postpone structured study indefinitely.
Review the current purchase terms before completing registration. The Linux Foundation page lists exam-only and course-bundle options, but prices and product offerings can change. Use the official certification page for current commercial details rather than relying on a third-party summary.
What to do on exam day
On exam day, focus on a compliant, tested setup and a calm reading process: use the prepared private space, the verified computer and connection, and the proctoring workflow described in the official instructions.
Have one active monitor, a functioning microphone, and a webcam that can be moved as required for the surroundings check. Avoid other activities on the same connection that consume substantial bandwidth, and disable file synchronization or similar services before launching the session.
The exam is 60 multiple-choice questions with 90 minutes for completion. Use a first pass to answer questions you understand, flag uncertainty if the interface permits it, and return to difficult items with the domain distinction in mind. Do not spend disproportionate time trying to force certainty from a question you have misclassified.
Read the question for its requested task and constraints before examining every option. Then identify whether it is testing a Kubernetes fundamental, an orchestration concern, application delivery, or cloud-native architecture. This simple classification can prevent a familiar but irrelevant answer from appearing attractive.
Results are emailed within 24 hours after the exam is completed, according to the Linux Foundation’s multiple-choice instructions. Keep the registration and support details available until the result is received, and consult the official terms if a technical or scheduling problem affects your appointment.
What to do after the result
Use the result as a learning decision, not just a pass-or-fail label: a successful result can identify the next specialization, while an unsuccessful attempt should direct a targeted review before the available retake.
If you pass, compare your strongest and weakest domains against your intended role. Someone moving toward administration may deepen Kubernetes operations and troubleshooting; someone interested in application work may extend delivery and debugging; someone working toward platform architecture may continue with observability and ecosystem design. KCNA establishes a foundation, so the next credential or project should match the capability you want to build.
If you do not pass, do not immediately repeat the same study routine. Reconstruct your preparation by domain, identify whether the issue was breadth, terminology, or scenario interpretation, and rebuild the weakest areas with explanation and hands-on verification. Confirm the retake eligibility and timing in the terms attached to your purchase.
Keep the official handbook and exam pages as the authority for current policies, languages, system requirements, scheduling rules, and product details. Training advice can remain stable, but administrative details may change.
A final readiness checklist
Schedule KCNA when you can explain the official domains, demonstrate basic Kubernetes relationships, reason through delivery and troubleshooting scenarios, and verify the remote-proctored exam setup.
Before registering or scheduling, confirm that you can:
• Explain containers, pods, nodes, clusters, core administration, scheduling, and containerization.
• Relate networking, security, troubleshooting, and storage to container orchestration problems.
• Describe application delivery and debugging without reducing the topic to a single command or tool.
• Explain observability, cloud-native ecosystem principles, and community and collaboration.
• Identify the four official domains by name and keep each percentage attached to its domain: Kubernetes Fundamentals 44%, Container Orchestration 28%, Cloud Native Application Delivery 16%, and Cloud Native Architecture 12%.
• Use a practice environment to connect actions with objects and outcomes.
• Complete the Linux Foundation preparation checklist, verify the PSI requirements, and select an appropriate private testing location.
• Confirm the registered exam language and understand the rescheduling, no-show, registration-validity, and retake rules.
If several of these statements are not yet true, keep studying and measure progress through explanations and practical checks. If they are true and your technical setup is ready, complete the checklist and schedule through the official Linux Foundation and PSI workflow.
Conclusion
KCNA preparation is strongest when it combines broad coverage with concrete Kubernetes reasoning. Start with the official domain weights, build the fundamentals needed to interpret the rest, and then connect orchestration, application delivery, and cloud-native architecture through practical examples. Treat the remote-proctoring checklist and scheduling rules as part of exam readiness. Your next step is to perform a domain-by-domain gap analysis, choose structured training or targeted self-study, and schedule only after both your knowledge and testing environment are ready.
Related exams
- CNPA exam — Certified Cloud Native Platform Engineering Associate
- KCSA exam — Kubernetes and Cloud Native Security Associate ()