Certified Kubernetes Administrator (CKA) Study Guide

The Certified Kubernetes Administrator (CKA) is a hands-on credential from the Cloud Native Computing Foundation that validates a candidate's ability to install, configure, and manage production Kubernetes clusters. Unlike multiple-choice certifications, the CKA puts you directly into a live terminal and asks you to actually solve problems — deploying workloads, debugging broken clusters, and configuring networking — the same way you would on the job.

This exam is aimed at system administrators, DevOps engineers, site reliability engineers, and platform engineers who operate Kubernetes clusters day to day. It's also a strong fit for developers moving into infrastructure-focused roles who want to prove they can do more than write YAML — they can keep a cluster healthy under pressure.

Why It's Worth Pursuing

• Kubernetes has become the default way organizations run containerized workloads, so cluster administration skills are in steady demand.
• The CKA is one of the few certifications that tests real command-line proficiency rather than memorized trivia, which makes it credible to hiring managers.
• Passing signals that you can be trusted with production cluster access — a meaningful trust signal for platform and SRE teams.
• It commonly serves as a stepping stone toward more specialized Kubernetes credentials, such as security- or developer-focused certifications.

Because the exam is performance-based and time-pressured, preparation has to emphasize speed and muscle memory with `kubectl` and cluster troubleshooting workflows, not just conceptual understanding.

The CKA is an online, remotely proctored exam rather than a testing-center experience. It is delivered through PSI's Bridge platform using the PSI Secure Browser, which handles identity verification and monitors your session via streaming audio, video, and screen sharing throughout the attempt.

Key Logistics

• Format: A performance-based test where you solve real tasks from a command line running against live Kubernetes clusters, rather than answering multiple-choice questions.
• Task count: The exam consists of 15-20 hands-on performance-based tasks.
• Duration: Candidates are given 2 hours (120 minutes) to complete the exam.
• Passing score: A score of 66% or higher is required to pass.
• Cost: The exam costs $445 and includes one free retake if you don't pass on your first attempt.
• Results: A score report is emailed within 24 hours of finishing the exam.
• Curriculum version: The exam environment and published curriculum currently align with Kubernetes v1.35.
• Validity: The CKA certification remains valid for 2 years from the date you pass.

Because it's remotely proctored, you'll need a quiet, private space, a working webcam and microphone, and a stable internet connection. The included retake is a meaningful safety net given the exam's difficulty — use your first attempt to learn the real testing environment, and treat the retake as backup rather than a plan.

The CKA curriculum is organized into 5 competency domains, each weighted according to how central it is to real-world cluster administration. Understanding these weightings helps you allocate study time proportionally rather than spreading effort evenly across topics that don't carry equal exam weight.

The Five Domains

• Troubleshooting (30%): The single most heavily weighted domain, covering diagnosing and fixing cluster, node, application, and networking failures. Expect scenarios where something is broken and you must find and resolve the root cause under time pressure.
• Cluster Architecture, Installation & Configuration (25%): Covers bootstrapping clusters, managing role-based access control, upgrading Kubernetes components, and understanding how the control plane and worker nodes fit together.
• Services & Networking (20%): Covers Services, Ingress, network policies, and DNS — the mechanisms that let workloads communicate inside and outside the cluster.
• Workloads & Scheduling (15%): Covers Deployments, Pods, ConfigMaps, Secrets, and how the scheduler places workloads onto nodes, including resource limits and affinity rules.
• Storage (10%): Covers persistent volumes, persistent volume claims, storage classes, and how Kubernetes handles stateful data.

Because Troubleshooting and Cluster Architecture together account for more than half the exam, candidates who under-invest in debugging skills and cluster setup mechanics tend to struggle even if they know the API objects well. Practicing failure scenarios — not just successful deployments — is essential.

Because the CKA is entirely hands-on, reading alone will not get you through it — you need repeated, timed practice on a real or simulated cluster. A structured multi-week plan works better than cramming.

Suggested Progression

1. Weeks 1-2 — Foundations: Set up a local multi-node cluster (kubeadm, kind, or minikube) and get comfortable with core objects: Pods, Deployments, Services, ConfigMaps, and Secrets. Practice writing manifests from memory rather than copy-pasting.
2. Weeks 3-4 — Cluster Architecture & Installation: Practice bootstrapping clusters with kubeadm, managing RBAC, and performing version upgrades on control plane and worker nodes. This domain rewards repetition since the steps are mechanical but easy to fumble under time pressure.
3. Weeks 5-6 — Networking & Storage: Work through Services, Ingress controllers, NetworkPolicies, and DNS resolution. Pair this with persistent volumes, claims, and storage classes so you can provision stateful workloads confidently.
4. Weeks 7-8 — Troubleshooting drills: Deliberately break things — kill kubelet, misconfigure a Service selector, corrupt a manifest — and practice diagnosing and fixing them quickly. Given troubleshooting's outsized weighting, this stage deserves the most repetition.
5. Final week — Timed mock exams: Simulate the full 2-hour session under exam conditions, including using only the allowed documentation, to build speed and reduce time-management mistakes.

Throughout, get fluent with `kubectl` imperative commands and shortcuts (aliases, autocomplete, `--dry-run=client -o yaml`) since typing full manifests by hand under time pressure is one of the most common reasons candidates run out of time.

Success on the CKA depends as much on time management and environment setup as on technical knowledge. A handful of avoidable mistakes account for many failed attempts.

Before the Exam

• Test your webcam, microphone, and internet connection with the PSI Secure Browser well ahead of time, since remote proctoring setup issues can eat into your session time.
• Clear your desk and room according to proctoring rules — unexpected items or a second monitor can trigger delays or flags during identity and environment checks.
• Get comfortable navigating between the allowed Kubernetes documentation tabs, since you're permitted limited reference access during the exam.

During the Exam

• Skim all tasks first and tackle the ones you're confident about before spending time on harder items — partial credit means an unfinished hard task can cost you easy points elsewhere.
• Always double-check you're operating in the correct cluster context before making changes; switching contexts between tasks is one of the most common sources of lost points.
• Use `kubectl config use-context` deliberately and verify with `kubectl config current-context` before each task.
• Watch the clock — with only 2 hours for 15-20 tasks, spending too long on one item can jeopardize your ability to attempt the rest.

Finally, avoid the common mistake of treating study as purely conceptual. Candidates who only read about Kubernetes without typing commands under time pressure tend to freeze when the live terminal appears, regardless of how well they understand the theory.

Because the CKA rewards repetition and speed over rote memorization, the free study tools on this site are built to reinforce exactly those skills rather than simulate multiple-choice recall.

Where Each Resource Fits

• Practice questions: Scenario-style questions modeled on the exam's domains help you rehearse recognizing which command or resource type a given task calls for, building the pattern recognition needed to move quickly during the timed session.
• Flashcards: Useful for locking in command syntax, flag meanings, and object field names — the kind of small details that slow you down if you have to think twice about them mid-task.
• Glossary: A quick way to build a solid working vocabulary of Kubernetes terminology (control plane components, networking concepts, storage objects) before diving into hands-on labs, so cluster documentation and error messages make sense immediately.

None of these resources replace time spent inside an actual cluster, but they compress the ramp-up period considerably. Using flashcards and the glossary early to build vocabulary, then shifting to practice questions organized around the domain weightings, mirrors the study-plan progression and helps concentrate effort on the highest-value areas — particularly troubleshooting and cluster architecture, which together make up more than half the exam.