How I Cleared the KCNA Certification with 98% By Studying Over a Weekend

I’ll be honest. When I first signed up for the Kubernetes and Cloud Native Associate (KCNA) exam, I wasn’t sure what to expect. I had been working with Kubernetes on and off for a while, and I thought, “how hard can a foundational exam be?” Spoiler: it’s not impossible, but it’s not a walk in the park either. A few of the reviews I read before taking it said the same thing. Even CKA holders said they had to stop and think on some questions.

So when I walked out (virtually) with 98%, I figured I owed it to the community to write this up properly.

What is the KCNA?

The Kubernetes and Cloud Native Associate exam is offered by the Linux Foundation and CNCF. It’s a multiple-choice, online-proctored exam designed to validate your foundational understanding of Kubernetes and the broader cloud native ecosystem.

Here are the quick stats:

• Duration: 90 minutes
• Format: Multiple choice
• Cost: $250 (exam only), with bundles available
• Validity: 2 years
• Attempts: 2 (one retake included)
• Prerequisites: None

It’s the starting point on the Kubernetes certification path, before CKA, CKAD, CKS, and honestly a great way to solidify your conceptual foundation even if you’re already hands-on in the field.

What Does the Exam Actually Cover?

The KCNA exam is split across four domains, each with a specific weight:

Kubernetes Fundamentals (44%)

This is the bulk of the exam and for good reason. You need to know Kubernetes core concepts inside out: Pods, Deployments, Services, ReplicaSets, ConfigMaps, Secrets, Namespaces, all of it. It also covers administration basics and scheduling (how the scheduler decides where to place a Pod, taints and tolerations, node affinity). And yes, containerization is in here too, including Docker, OCI, and container runtimes.

Container Orchestration (28%)

This domain goes deeper into how Kubernetes manages workloads at scale. Networking (how Pods communicate, CNI plugins, Services, DNS), security (RBAC basics, network policies, pod security), troubleshooting fundamentals, and storage (PersistentVolumes, StorageClasses) are all fair game.

Cloud Native Application Delivery (16%)

This is where GitOps, CI/CD, Helm, and deployment strategies come in. Think about how applications actually get deployed in a cloud native world: Argo CD, Flux, Helm charts, Kustomize. The debugging section here is more conceptual, focused on understanding how to approach issues with applications running in Kubernetes.

Cloud Native Architecture (12%)

This section is about the bigger picture. Observability (metrics, logs, tracing with tools like Prometheus, Grafana, Jaeger), the CNCF landscape, microservices patterns, and how the cloud native community operates. It sounds light but don’t sleep on it. Some of the trickiest questions come from here.

My Preparation Strategy

I had working knowledge going in. I’d used Kubernetes in a few projects, deployed workloads, written manifests, dealt with debugging sessions at 2am, you know the drill. But working knowledge alone won’t get you to 98%. Here’s what I actually did.

Step 1: Map the CNCF Landscape

One of the first things I did was spend real time on the CNCF landscape. Not just scrolling through it, but actually understanding what category each project falls under and why. The exam regularly asks about specific CNCF projects: which ones handle service meshes (Istio, Linkerd), which handle observability (Prometheus, Grafana, OpenTelemetry), which handle container runtime (containerd, CRI-O). If you’re just memorizing names without understanding what problem they solve, you’ll get tripped up.

Step 2: Go Deep on Concepts, Not Just Commands

Since this is a multiple-choice exam (not a hands-on lab like CKA), the emphasis is on understanding why things work the way they do. Why does Kubernetes use etcd? What’s the role of the kube-scheduler vs. the controller manager? What’s the difference between a DaemonSet and a Deployment? Don’t just know the what, know the why.

Step 3: Take Mock Exams till you feel confident

After going through the material, I hit mock exams hard. I specifically used the Sailor.sh KCNA mock exam and this is where things really clicked for me. The questions are genuinely exam-level. They exposed gaps I didn’t even know I had, things I thought I understood but couldn’t actually explain under a bit of pressure. The explanations for each answer were also really solid. I went through the bundle multiple times until I was consistently hitting high scores, and that confidence going into the real exam was worth everything.

Step 4: Review the CNCF Curriculum PDF

The official KCNA curriculum PDF on GitHub is your bible. Every single topic on the exam is in there. Go through it line by line and make sure you can explain each competency point out loud. If you can’t, that’s your next study session.

Tips and Tricks for the Exam

Read every question twice. Some questions are worded in a way that changes meaning subtly. “Which of the following is NOT” type questions are easy to rush through and get wrong.

Don’t confuse similar concepts. The exam loves testing things like: DaemonSet vs. Deployment, ConfigMap vs. Secret, Readiness Probe vs. Liveness Probe, PV vs. PVC. Make sure you can distinguish these cleanly.

Know your CNCF project categories cold. Seriously. Monitoring, logging, tracing, service mesh, runtime, CI/CD, GitOps, image registry. Know which tools fall under which category and what problem they solve.

GitOps is important. More than people realize going in. Understand the principles, the pull vs. push model, and the tools (Argo CD, Flux).

Observability is a full topic. The three pillars are metrics, logs, and traces. Know the tools behind them: Prometheus for metrics, Loki or ELK for logs, Jaeger or Zipkin for traces. These come up more than once.

Time is not your enemy. 90 minutes for a multiple choice exam is generous. Don’t rush. Flag questions you’re unsure about and come back.

Don’t overthink it. Some questions have a clearly correct answer if you know the concept. Trust your preparation.

Final Thoughts

The KCNA is a genuinely good certification. It’s not a rubber stamp. You’ll meet people who’ve passed it and clearly know their stuff, and you can tell. Preparing for it gave me a much more structured mental model of the cloud native ecosystem than I had from just working in it.

If you’re early in your Kubernetes journey, this is the right place to start. If you’re already experienced, it’s a surprisingly good way to validate and fill in the gaps. I found a few myself.

And if you’re serious about scoring high, don’t skip the mock exams. Real exam questions have a particular style and pressure to them, and there’s no substitute for practicing under those conditions before the real thing.

Good luck, you’ve got this.

Found this helpful? Drop a clap or follow for more cloud native content. Happy to answer questions in the comments.