Cover: a Pod with an app and a sidecar sharing an emptyDir volume, a two-hour exam timer and the five CKAD domain weights
Professional Certifications #CKAD exam#Kubernetes developer certification#CKAD study plan

How to Pass the CKAD Kubernetes Developer Exam

Pass the CKAD: the 2-hour hands-on format, the Kubernetes concepts tested most, kubectl speed tricks, and how to use killer.sh and a home lab to practice.

Alex Chen
November 14, 2026
11 min read

To pass the CKAD (Certified Kubernetes Application Developer), you need speed as much as knowledge: the exam gives you 2 hours for roughly 15 to 20 hands-on tasks in live clusters, and you need 66% to pass. The winning formula is to master the five curriculum domains, generate YAML with imperative kubectl commands instead of writing it by hand, learn to navigate the official Kubernetes docs fast, and finish your preparation with timed simulations such as the two killer.sh sessions included with your registration.

The CKAD is not a multiple-choice test. There’s no option D to fall back on. You get a terminal, a set of clusters, and a list of tasks like “create a Deployment with 3 replicas, expose it on port 8080, and add a readiness probe.” Either it works, or it doesn’t.

That’s exactly why so many experienced developers fail it the first time. They know Kubernetes. They’re just not fast enough with it. Let’s fix both.

CKAD Exam Format: Time-Pressured, Hands-On Kubernetes Tasks

The CKAD is a 2-hour, online-proctored, performance-based exam where you solve real tasks on real Kubernetes clusters from a command line. Each task has a weight, partial credit is possible on some tasks, and you can use the official Kubernetes documentation during the exam.

CKAD at a glance

DetailValue
Exam bodyThe Linux Foundation and CNCF
Duration2 hours
FormatPerformance-based tasks in a remote Linux desktop
Number of tasksRoughly 15 to 20 (varies)
Passing score66%
Allowed resourcesOfficial Kubernetes documentation (one extra browser tab)
Free retake1 included
Practice simulator2 killer.sh sessions included
Certification validity2 years
PriceAround $445 (check the Linux Foundation site, discounts are frequent)

Details like price, Kubernetes version, and allowed resources change over time, so always confirm them on the official CKAD page before you book.

What “time-pressured” really means

Do the math: 120 minutes for around 17 tasks is about 7 minutes per task, including reading the question, switching to the right cluster, doing the work, and verifying it. A single YAML indentation error that takes 6 minutes to debug can cost you a whole task.

That’s the core challenge of the CKAD. It’s less like an exam and more like a timed coding interview.

The environment

  • You work in a remote desktop with a terminal and a browser for the docs.
  • There are several clusters. Each task tells you which context to use, and switching with kubectl config use-context <name> is the first thing you do. Forgetting it means solving the task on the wrong cluster for zero points.
  • Copy and paste works differently inside the remote desktop terminal (usually Ctrl+Shift+C and Ctrl+Shift+V). Practice it beforehand so it doesn’t surprise you.

Core Kubernetes Developer Concepts That Appear Most on the CKAD

The CKAD curriculum has five domains, and the biggest single one is application environment, configuration, and security. Here is the current breakdown (check the official curriculum on GitHub for the latest version):

DomainWeightWhat to know cold
Application Environment, Configuration and Security25%ConfigMaps, Secrets, ServiceAccounts, SecurityContexts, resource requests and limits, ResourceQuotas, LimitRanges, CRDs, RBAC basics
Application Design and Build20%Container images, Jobs, CronJobs, multi-container Pods (sidecar, init containers), volumes
Application Deployment20%Deployments, rolling updates and rollbacks, blue/green and canary patterns, Helm, Kustomize
Services and Networking20%Services (ClusterIP, NodePort), Ingress, NetworkPolicies
Application Observability and Maintenance15%Liveness, readiness and startup probes, logs, debugging, API deprecations, monitoring

The high-frequency task types

Across candidate reports and simulators, a few task types show up again and again:

  • Create a Pod or Deployment with specific image, labels, env vars, and resource limits.
  • Inject configuration from a ConfigMap or Secret, as environment variables or a mounted volume.
  • Add probes (liveness, readiness) with the exact paths, ports, and timings asked.
  • Build a multi-container Pod, often a sidecar sharing an emptyDir volume, or an init container.
  • Create a Job or CronJob with a schedule, completions, or backoff limits.
  • Expose an app with a Service of the right type and port mapping.
  • Write a NetworkPolicy that allows traffic only from specific Pods.
  • Perform a rolling update, then roll it back.
  • Fix a broken Deployment (wrong image, wrong label selector, failing probe).
  • Set a SecurityContext (run as a specific user, drop capabilities, read-only filesystem).

The kubectl speed toolkit

The fastest candidates almost never write YAML from scratch. They generate it with imperative commands and edit only what’s needed:

# Alias and a dry-run shortcut
alias k=kubectl
export do="--dry-run=client -o yaml"

# Generate YAML instead of writing it
k run web --image=nginx --port=80 $do > pod.yaml
k create deployment api --image=nginx --replicas=3 $do > deploy.yaml
k create job backup --image=busybox $do -- /bin/sh -c "echo done" > job.yaml
k create cronjob report --image=busybox --schedule="*/5 * * * *" $do -- date > cj.yaml

# Config and secrets in one line
k create configmap app-config --from-literal=MODE=prod
k create secret generic db-pass --from-literal=PASSWORD=s3cret

# Expose, update, roll back
k expose deployment api --port=8080 --target-port=80
k set image deployment/api nginx=nginx:1.27
k rollout undo deployment/api

# Find the right YAML fields fast
k explain pod.spec.containers.livenessProbe

A few more habits that save minutes:

  • Set up vim for YAML at the start: set expandtab tabstop=2 shiftwidth=2 in ~/.vimrc.
  • Use k explain before searching the docs. It’s often faster.
  • Delete fast with k delete pod x --force --grace-period=0 when you need to recreate a Pod.
  • Verify every task: k get, k describe, and k logs take seconds and catch silly errors.

How to memorize the details that the docs won’t hand you

You can open the docs during the exam, but searching them for every field is far too slow. The details worth having in memory:

  • Which resources support imperative create and which don’t (for example, there’s no kubectl create for PersistentVolumeClaims or NetworkPolicies, so know where the YAML examples live in the docs)
  • Probe fields: initialDelaySeconds, periodSeconds, failureThreshold
  • SecurityContext fields at Pod level vs. container level
  • Service types and how port, targetPort, and nodePort relate
  • NetworkPolicy structure: podSelector, policyTypes, ingress.from

Flashcards work surprisingly well for these. A card like “Which SecurityContext field drops Linux capabilities, and at what level is it set?” takes 10 seconds to review and saves minutes in the exam. Pair them with active recall and spaced repetition, and they stick.

Practice Environment Setup and killer.sh for CKAD Simulation

Practice in a real cluster every day, and save the two killer.sh sessions for the last two to three weeks, when you’re already fast. The killer.sh simulator is intentionally harder than the real exam, so a score of 50% to 60% there is usually a good sign.

Setting up a home lab

You don’t need a cloud bill to practice. Any of these work on a laptop:

OptionGood forNotes
kind (Kubernetes in Docker)Fast, disposable clustersGreat for daily drills, multi-node possible
minikubeBeginners, add-ons like IngressEasy to start, one command
k3d / k3sLightweight clustersVery quick startup
Online playgroundsNo local installSessions are time-limited

For NetworkPolicies, make sure your local cluster uses a CNI that actually enforces them (many default setups don’t). Otherwise your policies will “work” while blocking nothing.

How to use killer.sh well

Your CKAD registration includes two killer.sh simulator sessions, and each one gives you access to the environment for 36 hours after activation. The questions are the same in both sessions, so plan them:

  1. Session 1, about 2 to 3 weeks before the exam. Take it under exam conditions: 2 hours, no pausing. Then use the remaining hours to study the detailed solutions and redo every task you missed.
  2. Between sessions: drill your weak domains daily with timed mini-tasks (5 to 7 minutes each).
  3. Session 2, a few days before the exam. Redo the whole simulation for speed. You’ll know the questions, so focus on typing, YAML generation, and context switching.

A 6-week CKAD study plan

For developers who already know containers and have used Kubernetes a little, about 6 weeks at 1 to 1.5 hours a day is realistic:

WeekFocusDaily practice
1Pods, Deployments, imperative commands, kubectl setupCreate and modify resources without YAML from scratch
2ConfigMaps, Secrets, resources, SecurityContexts, ServiceAccounts5 config tasks a day, timed
3Multi-container Pods, Jobs, CronJobs, volumesBuild sidecar and init patterns from memory
4Services, Ingress, NetworkPoliciesDebug connectivity with curl from a temp Pod
5Probes, debugging, rollouts, Helm, Kustomize + killer.sh session 1Review every missed task
6Speed drills + killer.sh session 2Full timed run, then light review

If you also plan to take the CKA, the overlap is substantial. Our CKA Kubernetes administrator guide covers the cluster administration side.

Exam-Day Strategy: Triage Beats Perfection

Do the quick, high-weight tasks first, flag anything that takes longer than about 8 minutes, and come back to it at the end. With partial credit available on many tasks, a mostly correct answer on every task beats a perfect answer on half of them.

  • Read the whole task first, including namespace and context.
  • Switch context with the command given at the top of each task. Every time.
  • Use the namespace specified (-n <namespace>). Resources in the wrong namespace earn nothing.
  • Note task weights and skip low-weight, long tasks until the end.
  • Verify with k get or k describe before moving on.
  • Keep 10 minutes at the end for flagged tasks.

Common Reasons Candidates Fail the CKAD

Most failures come from speed and carelessness rather than missing knowledge. The usual suspects:

  • Writing YAML by hand instead of generating it
  • Solving tasks in the wrong context or namespace
  • Spending 20 minutes on a single hard task
  • Never practicing in a timed, remote-desktop-like environment
  • Not knowing where key examples live in the docs (NetworkPolicy, PersistentVolumeClaim, probes)
  • Skipping verification, so small typos go unnoticed

Frequently Asked Questions

How hard is the CKAD exam?

It’s challenging mainly because of the time limit. Most tasks aren’t conceptually difficult, but solving around 17 of them in 2 hours requires fast, confident kubectl skills. With 4 to 8 weeks of daily hands-on practice, it’s very achievable.

What is the passing score for the CKAD?

You need 66% to pass. Tasks have different weights, and partial credit is possible on some of them.

Can I use documentation during the CKAD?

Yes. You can use the official Kubernetes documentation in the exam browser. Check the Linux Foundation’s current list of allowed resources before your exam, as it occasionally changes.

Should I take the CKA or CKAD first?

If you’re a developer deploying applications, start with the CKAD. If you manage clusters (installation, upgrades, etcd backups, troubleshooting nodes), start with the CKA. Many people take both, since the kubectl skills overlap.

Is killer.sh harder than the real CKAD?

Yes, by design. It has more tasks and harder ones than the real exam, so lower scores there are normal. Use it to find weak spots and build speed, not to predict your exact result.

Remember the Details, Practice the Speed

The CKAD rewards two things: hands-on speed, which only comes from daily practice in a cluster, and instant recall of field names, flags, and patterns, which comes from spaced review.

LongTerMemory handles the second part for you. Upload the CKAD curriculum, your course notes, or Kubernetes doc pages as PDFs, and it generates question and answer cards automatically, then schedules them with spaced repetition so the details of probes, SecurityContexts, and NetworkPolicies stay fresh until exam day. That frees your study hours for the terminal, where they matter most. You can try it on the free trial during your first weeks of prep.

The Bottom Line

Passing the CKAD exam comes down to speed with substance. Learn the five domains, especially configuration and security (25%), generate YAML with imperative commands, practice daily in a local cluster, and use your two killer.sh sessions strategically.

On exam day, switch context every time, triage by weight, and verify before moving on. Do that, and 2 hours will feel like just enough time.

Tags: CKAD examKubernetes developer certificationCKAD study planKubernetes cloud certification exam preparation

Share this article