What the CKA Exam Actually Tests (And Why It Matters)

The Certified Kubernetes Administrator exam has a problem, and it's not the one you'd expect. The test isn't too theoretical—it's relentlessly practical. It doesn't quiz you on trivia—you have the full Kubernetes documentation open in a second browser tab throughout the two-hour session. The problem is that the exam tests a very specific kind of competence: the ability to administer Kubernetes clusters from the command line under time pressure while working in a remote desktop environment with quirky keyboard shortcuts and no personal tools.

A new course from freeCodeCamp, developed by Bo Carnes and funded by the Linux Foundation, walks through preparation for the 2026 version of the CKA exam aligned with Kubernetes 1.34. The two-hour course doesn't just teach Kubernetes—it maps the precise skills the exam measures and the environment where you'll demonstrate them.

The exam's structure reveals what the Cloud Native Computing Foundation considers core administrative competency. Troubleshooting accounts for 30 percent of the total score—the largest single category. Cluster architecture, installation, and configuration comes in at 25 percent. Services and networking takes 20 percent, workloads and scheduling 15 percent, and storage rounds out the remaining 10 percent.

These weights aren't arbitrary. They reflect the reality that Kubernetes administration is fundamentally about diagnosing what's wrong, building clusters from scratch on generic Linux machines, and managing the networking layer that makes distributed systems possible. The exam doesn't test whether you can click through a managed Kubernetes service interface. It tests whether you can bootstrap a production cluster using kubeadm, troubleshoot a failing pod, or configure network policies from first principles.

The Remote Desktop Problem

The exam environment itself becomes part of the test. Since late 2025, the CKA has been "strictly administered via a remote Ubuntu desktop," according to the course. This seemingly minor detail has significant implications. Standard keyboard shortcuts don't work. Copy and paste requires Ctrl+Shift+C and Ctrl+Shift+V instead of the usual commands. Ctrl+W closes your browser tab rather than deleting a word in the terminal. These aren't edge cases—they're fundamental workflows you'll use dozens of times during the exam.

The course emphasizes what it calls "SSH node hopping"—the practice of connecting to different cluster nodes to run commands. "In version 1.34 exams, you will almost never stay on the base node," Carnes explains. "Most tasks require you to SSH into a specific worker or control plane node." Candidates must verify which node they're on before running commands and elevate to root access immediately to avoid permission errors when editing system files.

This is administration at the infrastructure layer. The exam doesn't abstract away the Linux machines running your cluster. It requires you to work directly with them, understanding kernel modules, cgroup drivers, and container runtimes. The course walks through installing containerd on Ubuntu nodes, configuring kernel parameters for bridge network filtering, and setting up the CNI plugin that enables pod-to-pod communication.

What Declarative Actually Means

Kubernetes operates on a declarative model—a concept the course positions as "the fundamental principle underpinning Kubernetes." Rather than issuing imperative commands, administrators define the desired state of the system in YAML manifest files. Once applied, Kubernetes controllers work continuously to reconcile the actual state with the desired state.

The pedagogical challenge is that declarative thinking isn't intuitive for people trained on imperative systems. If a pod crashes, you don't manually restart it. You define that three replicas should always be running, and a controller notices the discrepancy and creates a new pod automatically. The system is self-healing by design, but only if you've correctly specified what "healthy" means.

The exam tests this mental model directly. Candidates have access to the full Kubernetes documentation, making the test "a test of knowledge, application, and problem-solving speed rather than rote memorization," according to the course. You're not expected to remember YAML syntax—you're expected to find the right template in the docs, adapt it to the specific requirement, and apply it correctly while the clock runs.

The course recommends never writing YAML from scratch during the exam. Instead, generate base manifests using dry-run commands, then edit them in Vim with proper indentation settings. This is practical advice, but it also reveals something about what the exam values: efficiency and pattern recognition over creation from first principles.

The Architecture You Can't Abstract

The control plane/worker node architecture matters more than it might seem. The control plane runs the API server (which handles all cluster communication), etcd (the distributed key-value store holding cluster state), the scheduler (which assigns pods to nodes), and the controller manager (which runs the control loops maintaining desired state). Worker nodes run the kubelet (which ensures containers match pod specifications), kube-proxy (which maintains network rules), and the container runtime.

Managed Kubernetes services hide much of this infrastructure. The CKA certification assumes you're running Kubernetes on generic Linux machines where you're responsible for every layer. This means understanding why swap memory must be disabled (the kubelet requires it for predictable resource management), why specific kernel modules must be loaded at boot (Kubernetes networking depends on them), and why the cgroup driver must match between the kubelet and container runtime (mismatches cause cluster instability).

The course walks through these prerequisites methodically, explaining not just the commands but their purpose. This is administration as systems thinking—understanding how components interact rather than memorizing configuration steps.

What the Exam Doesn't Test

The CKA measures a specific slice of Kubernetes competency. It doesn't test application development, doesn't require deep knowledge of specific workload types beyond the basics, and doesn't cover the business or organizational aspects of adopting Kubernetes. You won't answer questions about migration strategies, cost optimization, or team structure.

This focus creates both clarity and limitation. The exam validates technical administration skills—if you pass, you can build and maintain Kubernetes clusters. But it doesn't validate the judgment about when Kubernetes is the right choice, how to design cluster architecture for specific organizational needs, or how to handle the political and cultural challenges of infrastructure transformation.

The course is frank about what it prepares you for: passing the exam and understanding Kubernetes administration at the infrastructure level. Whether that's the Kubernetes knowledge you need depends entirely on your role. For platform engineers managing self-hosted clusters, it's directly applicable. For developers using managed Kubernetes services, the skills may be more theoretical—useful for understanding what's happening beneath the abstraction layer but not part of daily workflow.

The 30 percent weight given to troubleshooting suggests the exam's real focus. Kubernetes administration isn't primarily about initial setup—it's about maintaining running systems, diagnosing failures, and understanding the distributed system well enough to identify where problems originate. That's the competency the CKA measures, and it's a reasonable proxy for real-world administrative skill.

The question isn't whether the CKA tests the right things. The question is whether the specific skills it tests—command-line administration, from-scratch cluster building, terminal-based troubleshooting—match what Kubernetes administrators actually do in your organization. For some environments, that's exactly the skill set required. For others, it's a certification that validates understanding without mapping to daily work. The exam doesn't resolve that question. Your infrastructure does.

Samira Okonkwo-Barnes