IT, Cloud & Cybersecurity • Certification
Kubernetes and Cloud Native Associate
Entry-level proof of Kubernetes and cloud-native fundamentals.
Researched and maintained by TestPrepPilot Editorial BoardCloud-native & Kubernetes certifications desk · Figures last verified August 2026
The short version
What is the Kubernetes and Cloud Native Associate and is it worth it?
KCNA is a 90-minute, multiple-choice exam costing $250 that checks conceptual Kubernetes and cloud-native knowledge at roughly a 75% pass mark. It is the on-ramp to the performance-based CKx exams.
- Vendor-neutral baseline for Kubernetes concepts
- Lower cost and difficulty than CKx exams
- Good first step before CKA/CKAD
- Two-year validity
- Recognised by employers hiring junior cloud staff
What is it?
What exactly is the Kubernetes and Cloud Native Associate?
Entry-level proof of Kubernetes and cloud-native fundamentals.
Kubernetes and Cloud Native Associate (KCNA) is CNCFs foundational multiple-choice exam for people new to the ecosystem. It covers Kubernetes architecture, container orchestration, cloud-native architecture, observability and application delivery. It is aimed at students, developers and operations staff starting their cloud-native journey.
The path in brief
- Learn Kubernetes basics and the CNCF landscape
- Book the KCNA
- Review the five domains
- Pass at about 75%
- Move on to CKA, CKAD or KCSA
Before you book
Who is eligible to sit the Kubernetes and Cloud Native Associate?
Who it is for: Beginners and career-changers entering cloud-native roles.
The test itself
What is the format of the Kubernetes and Cloud Native Associate?
The Kubernetes and Cloud Native Associate is administered by Remote proctored (Linux Foundation platform) and runs 90 minutes and requires 75% (scaled) to pass.
| Administered by | Remote proctored (Linux Foundation platform) |
|---|---|
| Questions | Approximately 36 multiple-choice questions |
| Time limit | 90 minutes |
| Pass mark | 75% (scaled) |
| Exam fee | $250 |
| Format | Multiple choice, online proctored |
Content outline
What topics are on the Kubernetes and Cloud Native Associate?
The Kubernetes and Cloud Native Associate is weighted across 5 domains; the largest are Kubernetes Fundamentals (46%), Container Orchestration (22%), Cloud Native Architecture (16%).
Weightings come from the official exam outline. Study time is best allocated in roughly these proportions rather than evenly across domains.
- Kubernetes Fundamentals 46%
API, objects, architecture
- Container Orchestration 22%
Scheduling, workloads
- Cloud Native Architecture 16%
CNCF projects, design
- Cloud Native Observability 8%
Monitoring, logging
- Cloud Native Application Delivery 8%
CI/CD, GitOps basics
Money & time
How much does the Kubernetes and Cloud Native Associate cost?
For the Kubernetes and Cloud Native Associate, the exam fee is $250; the all-in cost is typically $250; most candidates spend 3-6 weeks preparing.
Cost breakdown
| Exam fee | $250 |
|---|---|
| Typical total | $250 |
Standard CNCF list price.
Timeline
- Study 3-6 weeks
- Exam 90 minutes
Typical prep: 3-6 weeks
The path
How do you register for the Kubernetes and Cloud Native Associate?
- 1
Create a Linux Foundation account5 minutes
Open a free account at training.linuxfoundation.org; it becomes the home for your exam registration, score report and digital badge.
- 2
Choose the right exam
Pick an associate multiple-choice exam for conceptual breadth, or a performance-based CKx exam if you work in a terminal daily.
- CKA / CKAD / CKS for hands-on roles
- KCNA / KCSA / PCA for conceptual roles
- 3
Purchase and schedule10 minutes
Buy the exam voucher and book a time slot through the Linux Foundation scheduling portal. CKx exams bundle one free retake.
- 4
Prepare with the curriculum4-12 weeks
Study the official exam curriculum; for CKx exams practise in a live terminal environment such as Killer.sh before the real session.
- 5
Sit the proctored exam
Associate exams are taken online with a proctor; CKx exams run in a remote terminal with a proctor observing your session and screen.
The fine print
What are the retake and renewal rules for the Kubernetes and Cloud Native Associate?
- Proctoring & delivery
- Delivered online with a live proctor (PSI for CKx performance exams; the LF exam platform for associate multiple-choice exams). A government photo ID is required and the workspace is scanned before the exam begins.
- Retake policy
- Performance-based CKx exams (CKA, CKAD, CKS) include one free retake with the standard voucher. Associate multiple-choice exams do not include a free retake; a new voucher must be purchased. There is no published hard limit on attempts.
- Score reporting
- CKx performance exams report pass/fail with a numeric score (66% for CKA/CKAD, 67% for CKS). Associate multiple-choice exams report pass/fail against a roughly 75% cut score. Results appear at the end of the session.
- Recertification
- All CNCF certifications are valid for two years. Exams passed before April 2024 were issued for three years. To recertify, pass the current version of the same exam (or a higher-level equivalent) before it lapses.
- Refunds & rescheduling
- Vouchers are generally non-refundable but can be rescheduled; review the Linux Foundation terms at purchase for the specific exam.
Context
CNCF certification tracks
| Track | Format | Fee | Validity | |
|---|---|---|---|---|
| Associate (KCNA, KCSA, PCA, OTCA, ICA, CCA, CBA, CNPA, CGOA, KCA, CAPA) | Multiple choice | $250 | 2 years | |
| CKA / CKAD | Performance-based terminal | $445 (1 retake) | 2 years | |
| CKS | Performance-based terminal | $445 (1 retake) | 2 years |
What it pays
How much does this credential pay?
$132,270 median for software developers (SOC 15-1252, BLS May 2024) — the closest official occupation to KCNA-related roles
There is no Bureau of Labor Statistics occupation called "Kubernetes administrator" or "cloud native engineer", so the honest anchor for this credential is Software Developers, SOC 15-1252, which had a May 2024 median wage of $132,270, with the lowest 10 percent earning less than $79,850 and the highest 10 percent more than $211,450. We have chosen that code deliberately: KCNA is positioned by CNCF as a pre-professional, knowledge-based credential for students and early-career IT professionals, and the day-to-day work it feeds into — deploying applications with kubectl, understanding pods and the control plane, reasoning about microservices, GitOps and CI/CD — sits inside the developer ecosystem that SOC 15-1252 describes. BLS projects 15 percent employment growth for the combined software developers, quality assurance analysts and testers occupation from 2024 to 2034, with about 129,200 openings a year, the strongest tailwind of any occupation quoted here. Two caveats belong in the same paragraph. First, KCNA is explicitly the conceptual stepping stone toward the CKA, CKAD and CKS exams; employers hiring for Kubernetes administration typically list CKA rather than KCNA, so the salary distribution above reflects the occupation, not KCNA holders specifically, and we will not invent a certificate premium BLS does not measure. Second, candidates who earn KCNA and stop there are earning a vocabulary credential; the roles that justify the top of the developer range require the hands-on professional exams that follow. Treat the wage figure as career context for a job family that is growing, not as a promise attached to this one test.
| Measure | Figure | Source / note |
|---|---|---|
| Median annual wage, software developers | $132,270 | BLS OEWS, SOC 15-1252, May 2024 |
| Lowest 10 percent | less than $79,850 | BLS OEWS, SOC 15-1252, May 2024 |
| Highest 10 percent | more than $211,450 | BLS OEWS, SOC 15-1252, May 2024 |
| Employment, 2024 | 1,895,500 jobs (combined software dev/QA) | BLS OOH Quick Facts, 2024 |
| Projected annual openings | ~129,200 per year | BLS OOH Job Outlook, 2024-34 |
Job growth.15% projected change 2024-34 for software developers, QA analysts and testers — much faster than the 3% all-occupations average
Source: BLS Occupational Outlook Handbook — Software Developers, Quality Assurance Analysts, and Testers
Your odds
What are the pass rates?
CNCF publishes no pass rate for KCNA — but it does publish the passing score, 75%, along with a $250 fee that includes one free retake
The core fact is that the Cloud Native Computing Foundation does not release pass-rate statistics for the Kubernetes and Cloud Native Associate exam, and neither does the Linux Foundation which administers it, so no pass-rate figure exists to quote and we will not estimate one. What is published and verifiable is the cut score: the Linux Foundation candidate FAQ states that a score of 75 percent or above is required to pass the KCNA exam, and the exam is scored automatically with results emailed within 24 hours of completion. The official CNCF page confirms the fee of $250, which includes one free retake, and the Linux Foundation FAQ confirms the exam lasts 90 minutes, is delivered online and proctored, is offered in English or Japanese, and that the certification is valid for three years, renewed by retaking and passing the exam before the expiration date. The exam contains approximately 60 multiple-choice, multiple-response and scenario-based questions, and the CNCF page publishes the domain weights: Kubernetes Fundamentals 44 percent, Container Orchestration 28 percent, Cloud Native Application Delivery 16 percent, and Cloud Native Architecture 12 percent. Two further policy details belong in the same planning picture: the free retake included in the $250 fee is valid for twelve months from registration, and the exam may include unscored questions used for research that are not identified and have no effect on the score, so every item on screen must be treated as if it counts. Because there is no pass rate to guide planning, the practical reading of the published threshold is that a candidate should aim well above 75 percent on practice items, since the paper mixes single-answer, multi-select and scenario questions and the threshold is applied to the whole form rather than per domain.
Read this before quoting the number.No pass rate is published by CNCF or the Linux Foundation. The 75% passing score, $250 fee with one free retake, 90-minute duration and three-year validity are the published figures this narrative relies on instead.
Your schedule
How long should I study for it?
45-60 hours over 6-8 weeks (5-10 weeks for newcomers) of focused study
Plan for six to eight weeks and 45 to 60 hours of study for a candidate with any IT background, or ten to twelve weeks at about five hours a week for a true newcomer, and spend the largest share of the time building a small hands-on Kubernetes cluster rather than reading the landscape map. The exam is approximately 60 questions in 90 minutes, delivered online and proctored, and it is a knowledge-based paper — CNCF is explicit that there are no hands-on, terminal-based questions on KCNA — so the balance is conceptual understanding plus vocabulary precision plus a modest amount of kubectl familiarity. The published domain weights on the official CNCF page are Kubernetes Fundamentals 44 percent, Container Orchestration 28 percent, Cloud Native Application Delivery 16 percent, and Cloud Native Architecture 12 percent, which tells you the single most important planning fact: nearly three-quarters of the paper is Kubernetes and orchestration, so a candidate who scatters effort across the whole cloud-native landscape is studying in the wrong proportions. The plan below runs in four blocks — fundamentals and orchestration first, application delivery and architecture next, then a final timed-rehearsal phase — and it assumes you can run Docker or a lightweight cluster locally. If you cannot, at minimum follow the interactive kubectl exercises, because scenario items about deployments, pods, services and namespaces read far more easily after you have watched a pod actually get scheduled, and a candidate who has seen a Deployment reconcile has internalised the concept that the exam keeps circling back to.
- Weeks 1-28-10 hrs/week
Kubernetes fundamentals (44%)
- Learn the architecture cold: control plane components, nodes, pods, namespaces, Deployments, Services and ConfigMaps
- Run a local cluster or cloud playground and deploy a sample app with basic kubectl commands
- Understand scheduling, self-healing and the difference between a pod and a Deployment
- Practise describing what each resource does in one sentence — the paper is heavily vocabulary-weighted here
- Weeks 3-48-10 hrs/week
Container orchestration (28%)
- Work containers, runtimes, orchestration fundamentals, networking and storage concepts end to end
- Understand service discovery, scaling, and how an orchestrator reconciles desired state
- Cover service mesh and the role of projects like Envoy and Fluentd in the ecosystem
- Drill scenario items that ask which behaviour a Deployment, Service or Ingress provides
- Weeks 5-67-9 hrs/week
Application delivery and cloud-native architecture
- Cover CI/CD concepts, GitOps, container images and immutable infrastructure
- Map the remaining 28%: microservices, autoscaling, serverless, open standards and community governance
- Learn the CNCF landscape projects by category — observability, storage, networking, service mesh
- Re-do practice questions on the two smallest domains until they stop costing points
- Weeks 7-87-9 hrs/week
Timed rehearsal
- Take two or three full 90-minute practice exams and log every miss to a domain
- Re-drill the highest-weight domains, Kubernetes fundamentals and orchestration, with fresh scenario practice
- Final pass over the cloud-native security concepts and the CNCF project categories
- One quiet day before the exam; results arrive by email within 24 hours of sitting
Adjusting the pace
Already using Kubernetes at work.Three to four weeks. Your hands-on time covers most of the Kubernetes and orchestration domains; spend the recovered hours on the CNCF landscape, GitOps, service mesh and observability concepts that daily kubectl work does not exercise.
Complete newcomer to cloud native.Ten to twelve weeks at 4-5 hrs/week. Front-load the fundamentals domain and build the local cluster early; the vocabulary is the real barrier, and scenario items are unreadable without it.
Preparing for CKA/CKAD after KCNA.Use KCNA as the survey layer and go deeper on hands-on kubectl throughout, since the professional exams replace concept questions with terminal-based performance tasks. Keep the local cluster you build here.
How to study
How do I prepare most effectively?
The strategy that reliably moves a KCNA score is "weight the two big domains, build a tiny cluster, and rehearse the 90-minute clock", and the single biggest error is studying the entire cloud-native landscape evenly when three-quarters of the paper is Kubernetes and orchestration. The official CNCF domain weights are the planning document: Kubernetes Fundamentals is 44 percent and Container Orchestration is 28 percent, so a candidate who masters pods, nodes, clusters, the control plane, Deployments, Services, ConfigMaps, scheduling and service discovery has already covered the majority of the exam before touching the wider ecosystem. The second proven approach is hands-on exposure through a local cluster or a managed playground: the exam is explicitly knowledge-based with no terminal questions, but scenario items about deploying an application, exposing it, and scaling it read completely differently after you have done those things once, and the behavioural memory of watching a cluster react is what the scenario items reward. Third, learn the CNCF landscape by category rather than project-by-project, because the exam asks you to reason about what kind of tool fills a role — observability, storage, networking, service mesh, GitOps — more often than it quizzes you on a specific logo. Fourth, drill the vocabulary precisely: terms like pod, Deployment, namespace, immutable infrastructure, control plane, and desired state come up in distractors, and imprecise vocabulary is how candidates lose otherwise-answerable items. Finally, rehearse timing with full 90-minute practice exams, because the format mixes single-answer and multi-select items, the threshold is a 75 percent cut across the whole form, and the free-retake entitlement in the $250 fee is worth protecting by arriving ready the first time.
Weight the two big domains first
Kubernetes Fundamentals (44%) and Container Orchestration (28%) together are 72% of the paper. Master pods, nodes, clusters, the control plane, Deployments, Services, ConfigMaps, scheduling and scaling before spending a single hour on the wider landscape, and the majority of the exam is already handled.
Build a tiny cluster, even though the exam is theory
KCNA has no terminal-based questions, but scenario items about deploying, exposing and scaling an application are far easier after you have done those actions once. Run a local cluster or a cloud playground and use kubectl on a real workload; the memory of the behaviour is what the scenario items reward.
Learn the CNCF landscape by category
The exam reasons about what kind of tool fills a role — observability, storage, networking, service mesh, GitOps — more than it quizzes individual projects. Learn the categories and the canonical project in each, and you can reason out items you have never seen before.
Be precise with the vocabulary
The paper is heavy on near-miss distractors: pod vs Deployment, node vs control plane, namespace vs cluster, GitOps vs plain CI/CD. Practise stating the exact definition and the exact boundary of each term, because imprecision is how answerable items get dropped.
Rehearse the 90-minute clock
About 60 questions in 90 minutes with multi-select items scored all-or-nothing means pace matters. Run full timed practice exams and build the habit of answering, flagging and returning, so the real paper feels like a rehearsal rather than a first exposure.
Use the free official curriculum
CNCF has open-sourced the KCNA curriculum that the exam is built from. Working the official curriculum before any commercial course guarantees you are studying the actual syllabus rather than a vendor’s compression of it.
What to buy
Which study resources are worth paying for?
The KCNA buying decision is dominated by free official resources — CNCF open-sourced the curriculum the exam is built from, the Linux Foundation publishes a detailed FAQ, and the $250 exam fee itself includes one free retake. The only genuinely necessary purchase is the exam voucher; everything else is optional acceleration. The table below compares the main options with prices current to this review, and the honest cost ranking is: the official curriculum and a small lab are the value core, practice exams are optional calibration, and video courses are conveniences rather than necessities. Three buying rules follow from how the exam actually works. First, because the exam is knowledge-based and blueprint-driven, anything that teaches you to reason about the four domains in the published proportions is worth more per dollar than a general Kubernetes course that teaches a different exam. Second, the free retake included in the $250 fee is real value, but it is only valuable if a failed first attempt teaches you something — so the money is better spent on practice exams that tell you honestly where you stand than on a course that only reassures you. Third, the one category to treat with suspicion is braindump-style question banks: the exam is knowledge-based and CNCF rotates items, so memorising recycled questions trains you for a paper that no longer exists, and the free official curriculum plus a small lab covers the material more honestly. If you are preparing for CKA or CKAD afterwards, the KCNA curriculum is the survey layer, so the materials you buy for it carry forward into the professional track.
| Resource | Price | Format | Best for |
|---|---|---|---|
| KCNA exam registration (Linux Foundation/CNCF) | $250, includes one free retake | Online proctored exam | The exam itself — the only required purchase |
| Open-sourced KCNA curriculum | Free | Official curriculum on GitHub | The authoritative syllabus the exam is built from |
| Linux Foundation KCNA candidate FAQ | Free | Documentation pages | Policies: duration, cut score, retakes, validity, ID rules |
| Local cluster or managed playground (minikube, kind, cloud sandboxes) | Free to ~$30/month | Hands-on environment | Building the behavioural memory the scenario items reward |
| Video and practice-exam courses (e.g. Udemy, KodeKloud-style) | ~$15-40 during sales | Video lectures plus timed mock exams | Candidates who learn by watching; use them to supplement the curriculum, not replace it |
Prices checked 2026-08 in USD before tax; the $250 fee includes one free retake valid for 12 months, and Udemy-style list prices are close to meaningless outside a sale. Country-specific taxes may apply on top of the base fee.
Avoid these
What mistakes do candidates most often make?
The most common KCNA mistakes are conceptual rather than technical: studying the whole cloud-native landscape evenly when Kubernetes Fundamentals and Container Orchestration together are 72 percent of the paper, and treating the exam as if it had terminal questions when it is explicitly knowledge-based. Candidates also lose points to imprecise vocabulary, to multi-select items scored all-or-nothing, and to the belief that one practice test at a passing score means readiness for a paper that mixes three question styles across a 90-minute clock. A sixth pattern is ignoring the free retake entirely by treating a failed first attempt as the end of the road, when the $250 fee includes one free retake valid for twelve months and the failure itself is the most diagnostic data available. The common thread across these failures is preparing in a way that ignores the published weights and the published exam description: the paper rewards proportionally weighted study of the two big domains, precise vocabulary, and pace under the 90-minute clock, and every mistake above is a way of avoiding one of those demands. A candidate who builds a small cluster, weights study hours to the 72 percent that Kubernetes and orchestration represent, drills the near-miss vocabulary, and rehearses the full timed format has addressed the entire list at once — and has protected the free retake by arriving ready the first time.
✕Studying the landscape evenly
✓The published domain weights make the allocation obvious: Kubernetes Fundamentals is 44% and Container Orchestration is 28%, so 72% of the exam is Kubernetes and orchestration. Weight your study hours in those proportions and treat observability, GitOps and the wider ecosystem as the 28% they actually are.
✕Preparing as if it were a hands-on exam
✓CNCF is explicit that KCNA contains no terminal-based questions — it is a knowledge-based paper. A candidate who spends months memorising command syntax is mis-training; spend the hours on concepts, scenario reasoning and vocabulary precision, with light kubectl exposure for the behaviour it teaches.
✕Imprecise vocabulary in near-miss items
✓Distractors rely on terms that sound adjacent: pod vs Deployment, node vs control plane, namespace vs cluster, GitOps vs CI/CD. Drill one-sentence definitions and the exact boundary of each term until you can state what separates each pair without hesitation.
✕Dropping multi-select items to partial knowledge
✓Multi-select and multiple-response items are scored as a whole, so knowing most of the answer loses the item. When a multi-select is uncertain, reason from what each option actually does rather than selecting every plausible-sounding choice.
✕Judging readiness from one passing practice score
✓A single practice test at 75-80% is not evidence of readiness across the full domain set. Take two or three full timed papers, log misses to domains, and re-drill the two big domains specifically before booking the $250 seat.
What you'll face
What question types will I see?
The KCNA exam is approximately 60 questions in 90 minutes, delivered online and proctored, and it is explicitly knowledge-based: CNCF states there are no hands-on, terminal-based questions. The paper mixes single-answer multiple choice, multiple-response items, and scenario-based questions, and a passing score of 75 percent is required on the whole form, with results emailed within 24 hours. The published domain weights are Kubernetes Fundamentals 44 percent, Container Orchestration 28 percent, Cloud Native Application Delivery 16 percent, and Cloud Native Architecture 12 percent, and those weights are the single most useful planning fact because they tell you where the bulk of the items live — a candidate strong in Kubernetes Fundamentals and Container Orchestration has already covered 72 percent of the paper before touching the wider ecosystem. Single-answer items dominate and test conceptual understanding and vocabulary, with near-miss distractors built on terms that sound adjacent, such as pod versus Deployment and namespace versus cluster; multiple-response items ask which statements are true and are scored all-or-nothing; and scenario items present a small situation — an application that must be exposed, a workload that must scale, a deployment that must be rolled out — and ask which resource, concept or behaviour applies. The exam may also include unscored questions used for research, which are not identified and have no effect on the score, so every question must be treated as if it counts. Because the exam is scored automatically and no score breakdown by domain is published to candidates, the practical preparation target is comfort with all four domains at well above the 75 percent cut. The samples below are editor-written illustrations of the published blueprint’s question styles, not live exam items.
Conceptual and vocabulary questions across all four domains, with near-miss distractors. These reward precise definitions of pod, Deployment, namespace, control plane, immutable infrastructure and the rest of the core vocabulary.
A list of statements or options with several true, scored all-or-nothing. Common where multiple behaviours are simultaneously true, such as what a Service provides or what the control plane does.
A described situation — deploy and expose an app, scale a workload, roll out an update — with a choice of the correct resource, concept or behaviour. These reward having watched a real cluster react to those actions.
Questions about the CNCF landscape, project categories, GitOps, CI/CD, observability and service mesh. Learn categories rather than logos and most of these become reasoning items.
Try these
Q1A team needs to run several replicas of a stateless web application, keep them running if one fails, and update them without downtime. Which Kubernetes resource is designed for this?
Answer:B
A Deployment manages a set of identical pod replicas, provides self-healing by replacing failed pods, and supports rolling updates without downtime — exactly the stated requirement. A is wrong because a single pod has no replica management or update strategy. C is wrong because a ConfigMap only stores configuration data. D is wrong because a Namespace is a scoping mechanism for cluster resources, not a workload controller.
Q2Which statement about the Kubernetes control plane is correct?
Answer:B
The control plane makes global cluster decisions — scheduling workloads, maintaining desired state, and exposing the API that controllers and users interact with. A is wrong because pods run on worker nodes, not on the control plane. C is wrong because the control plane includes the API server, scheduler and controller manager, not just configuration stores. D is wrong because production control planes run multiple replicas for high availability.
Q3An application’s configuration values must change without rebuilding the container image. Which mechanism supports this?
Answer:B
A ConfigMap decouples configuration from the container image, allowing values to be supplied at runtime and changed by redeploying with the new ConfigMap — precisely the stated requirement. A is wrong because baking values into the image forces a rebuild for any change. C is wrong because namespaces scope resources; they do not supply configuration. D is wrong because a fixed node affects placement, not configuration.
Samples are editor-written illustrations of the published blueprint, not live exam items.
The big day
What should I expect on exam day?
The KCNA exam is an online, proctored, 90-minute, approximately 60-question multiple-choice test delivered through the Linux Foundation platform via PSI, so exam day is a remote-proctoring exercise: the practical preparation is your room, your machine and your identification. You need a valid, unexpired, government-issued original photo ID whose name exactly matches the verified name on your exam checklist, a private space with a clear work area and no paper, writing implements, electronic devices or printed materials on or around the desk, and a well-lit room with no bright lights or windows behind you. Plan to begin check-in roughly 30 minutes early, because the ID verification and room scan take time and the proctor must approve the space before the exam releases — and a candidate who has not tested the platform in the actual exam room risks losing the appointment to a technical failure. The 90-minute clock starts once the exam begins, the passing cut is 75 percent, and results are scored automatically and emailed within 24 hours of completion. Pace at roughly one and a half minutes per question, flag multi-select and scenario items you are unsure of, and use the closing minutes to revisit flagged questions. The exam is offered in English or Japanese, and the $250 fee includes one free retake valid for twelve months, so a calm, tested environment protects both the appointment and the retake entitlement. The certification, once passed, is valid for three years and is renewed by retaking and passing the current exam before expiry.
Bring
- A valid, unexpired, government-issued original photo ID — a passport, driver’s license or national ID — with no photocopies or electronic versions
- The exact machine you system-tested, with a working webcam, microphone and a stable connection
- A quiet, private, well-lit room with a clear desk, no posters or papers on the walls, and no bright light behind you
- A phone only if the proctor requires it for check-in, then out of reach
- Confirmation of your exam time and your login details for the Linux Foundation platform
Leave at home
- Phones, smartwatches, fitness trackers and earbuds — out of the room or out of reach after check-in
- All paper, notes, writing implements, books and printed materials, including under the desk
- Second monitors, which must be unplugged and turned away, and any other person in the room
- Snacks and drinks at the desk unless the proctor permits them, and any background audio
- Anything hanging on the walls behind the work area
How the day runs
Rules in the room
- The exam is online and proctored; there is no offline delivery.
- 90 minutes for approximately 60 questions; the clock does not stop once it starts.
- A score of 75% or above is required to pass the KCNA exam.
- One valid, unexpired, government-issued original photo ID is required, with name exactly matching the exam checklist.
- The exam is closed-book: no paper, notes, electronic devices, or printed materials in the work area.
- The exam is offered in English or Japanese.
- The certification is valid for 3 years and renewed by retaking and passing the current exam before expiration; the $250 fee includes one free retake.
Afterwards.Your result is scored automatically and emailed within 24 hours of completing the exam, so you will not know the outcome on the spot the way you would at some test centres. On a pass, your digital certificate and Credly badge are issued through the Linux Foundation, and the certification is valid for three years; renewal is by retaking and passing the current KCNA exam before the expiration date, which restarts the three-year clock. Because KCNA is positioned as the conceptual stepping stone, the natural next step is the hands-on professional track — CKA, CKAD or CKS — and the local cluster you built during preparation is the foundation for that work. On a fail, use the free retake entitlement included in the $250 fee, and spend the gap re-drilling the two big domains — Kubernetes Fundamentals and Container Orchestration — by the published weights, because the score you cannot see is almost always lost in the 72 percent of the paper those two domains represent.
Reference
What are the key facts about the Kubernetes and Cloud Native Associate?
Kubernetes and Cloud Native Associate is a certification credential; awarded by Cloud Native Computing Foundation; the exam fee is $250; typical preparation is 3-6 weeks; holders typically earn $90,000-$130,000.
| Credential | Kubernetes and Cloud Native Associate |
|---|---|
| Abbreviation | KCNA |
| Type | Certification |
| Profession | IT, Cloud & Cybersecurity |
| Specialty | Cloud Native & DevOps |
| Awarded by | Cloud Native Computing Foundation |
| Difficulty | Moderate |
| Typical prep time | 3-6 weeks |
| All-in cost | $250 |
| Typical salary range | $90,000-$130,000 |
| Delivery | Online proctored multiple-choice exam |
| Retake | New voucher required; no free retake |
| Validity | 2 years |
| Level | Foundational / associate |
| Scope | National / Multi-state |
| Also known as | KCNA |
Real questions
Frequently asked questions about the Kubernetes and Cloud Native Associate
Should I take KCNA before CKA?
If you are new to Kubernetes, KCNA builds the conceptual foundation and confidence before the much harder terminal-based CKA. It is the recommended on-ramp for people without cluster experience.
Is KCNA hands-on?
No. It is a multiple-choice exam assessing knowledge, not live terminal skill. The CKx exams are the hands-on validation if you later need to prove operations ability.
Does KCNA count toward CKA?
It does not substitute for CKA, but the knowledge carries over and many candidates sit KCNA first. Think of it as the theory exam that makes the practical exam easier.
Which domain matters most?
Kubernetes Fundamentals is weighted 46%, nearly half the exam, so invest most of your study time in the API, core objects and cluster architecture before the lighter domains.
How long is it valid?
Two years, the same as other CNCF credentials earned recently. Recertify by passing the current version again before it lapses.
Is KCNA worth it for experienced engineers?
If you already run clusters daily, skip to CKA or CKAD. KCNA pays off most for newcomers, career-changers and non-technical stakeholders who need the shared vocabulary.
Do I need Kubernetes experience for the associate exams?
The associate multiple-choice exams are designed as entry points and test conceptual knowledge rather than live terminal skill, though some hands-on exposure helps.
Why did validity change from three to two years?
CNCF shortened the certification lifecycle so credentials reflect current project versions; anyone certified before April 2024 keeps the original three-year window.
How do the performance exams differ from associate exams?
CKA, CKAD and CKS are taken in a live terminal where you solve real tasks; associate exams are multiple choice. The terminal exams prove genuine hands-on ability.
Are CNCF exams available in my region?
Yes. All CNCF exams are delivered online with live proctoring through PSI (performance) or the Linux Foundation platform (associate), available worldwide in English.
In short
Is the Kubernetes and Cloud Native Associate worth it?
- Foundational CNCF multiple-choice exam
- Covers Kubernetes, orchestration and cloud-native concepts
- 75% pass, $250
- Valid for two years
Same awarding body
What other credentials does Cloud Native Computing Foundation award?
Worth comparing
How does the Kubernetes and Cloud Native Associate compare with similar credentials?
Trust
Where does this information come from?
Everything above is taken from the awarding body's own published material. Fees, question counts and domain weights are revised regularly — check the official page before you pay.
- Cloud Native Computing Foundation Awarding body
- Official Kubernetes and Cloud Native Associate exam page Exam page
Research confidence: high · Last reviewed 2026-08