If you write code that runs in containers, the CKAD is probably the Kubernetes cert you want. Not the CKA, not the security one. The CKAD is built for the person who ships apps onto a cluster, not the person who runs the cluster.
I'll break down what it tests, who it's for, and how to actually prepare without wasting weekends.
What CKAD stands for, and what it isn't
CKAD is the Certified Kubernetes Application Developer exam, run by the CNCF and the Linux Foundation. The key word is application. It's about deploying, configuring, and troubleshooting workloads.
The CKA (Certified Kubernetes Administrator) is the sibling cert. CKA cares about the cluster itself: setting up nodes, etcd, control plane components, upgrades, networking internals. That's the platform team's job.
If your day job is "here's my service, get it running reliably on Kubernetes," CKAD maps to your work. If your day job is "keep the cluster alive for everyone," CKA fits better. There's overlap, but pick based on what you actually do.
It's hands-on, and that changes everything
This is the part people underestimate. CKAD is not multiple choice. You get a live terminal connected to real clusters, and you solve tasks by doing them. Create this deployment. Fix this broken pod. Expose this service. Set a resource limit. Roll back this update.
You're graded on the resulting cluster state, not on how you got there. So the exam rewards speed and muscle memory, not trivia.
It's also open book in a narrow way. You can use the official Kubernetes documentation during the exam. That sounds generous until you realize the clock is the real constraint. You don't have time to read docs from scratch for every task. You need to know roughly where things live and confirm syntax fast.
The exam runs about two hours and is proctored remotely. Passing is in the mid-60s percent range, but treat the exact number as something to confirm on the official site, since the CNCF adjusts exam details over time.
What's on it
The domains shift a bit between versions, but the core areas are stable:
- Application design and build: containers, multi-container pods, init containers, jobs and cronjobs.
- Application deployment: deployments, rolling updates, rollbacks, basic Helm usage.
- Observability and maintenance: probes (liveness, readiness, startup), logging, debugging failing pods.
- Environment, configuration, and security: ConfigMaps, Secrets, service accounts, resource requests and limits, security contexts.
- Services and networking: exposing apps with services, and basic NetworkPolicies.
None of it is exotic. It's the stuff you touch when you put an app on a cluster and something doesn't come up.
How to actually study
The single biggest lever is getting fast with kubectl. Most candidates lose the exam to the clock, not to difficulty.
Learn the imperative shortcuts cold. You should be able to generate a pod or deployment YAML without typing it by hand:
kubectl run nginx --image=nginx --dry-run=client -o yaml > pod.yaml
kubectl create deployment web --image=nginx --dry-run=client -o yaml > deploy.yaml
That --dry-run=client -o yaml pattern is your best friend. You generate a skeleton, edit a few fields, and apply. Typing full manifests from memory is a trap.
Set up your shell before you start each task. An alias and a couple of variables save real time across two hours:
alias k=kubectl
export do="--dry-run=client -o yaml"
export now="--force --grace-period=0"
Then k run test --image=nginx $do does the heavy lifting.
Practice on a real cluster, not slides. Minikube, kind, or k3s on your laptop all work. Do the tasks with your hands until the motions are automatic. Reading about a readiness probe and writing one under time pressure are different skills.
Get comfortable with the docs as a lookup tool, not a tutorial. Practice finding the ConfigMap example, the security context fields, the NetworkPolicy template. Bookmark how the doc site search behaves so you're not hunting blind on exam day.
Drill debugging specifically. A chunk of the exam is "this is broken, fix it." Practice reading kubectl describe, checking events, pulling logs with kubectl logs, and spotting the obvious culprits: wrong image name, missing env var, bad probe, insufficient resources.
If you want a structured way to rehearse under pressure, treat your prep like interview prep: timed sessions, a fixed task list, and an honest review of what slowed you down. That's the same loop we push for technical interviews on gitGood, and it transfers cleanly to a hands-on exam.
Is it worth it
For a developer working with Kubernetes, yes, more than most certs. It's hard to fake because it's performance-based. Passing means you can actually operate a cluster's workloads, and hiring managers know that.
It won't teach you why to use Kubernetes or whether you should. It assumes you're already in that world and want to prove you can work in it competently.
If that's you, give yourself a few weeks, practice on a real cluster daily, and get your kubectl speed up. The cert follows from the reps.