ckad

Certified Kubernetes Application Developer

DevOps / Containers

The Certified Kubernetes Application Developer exam certifies that candidates can design, build and deploy cloud-native applications for Kubernetes. The exam is performance-based: candidates solve hands-on tasks at the command line covering pod and workload design, configuration and secrets, observability, services, ingress, network policies, and Helm/Kustomize.

exam: 17 questions · 120 min

Sign up free — practice 5 questions on this cert without a card.

Kubernetes for developerskubectlPerformance-based120 min examHands-on tasks66% to pass$445 USD

Difficulty

Hard

Avg study time

60-120h

1-2 months typical for engineers already shipping containerised apps

Pass rate

Not published

Community reports cluster around ~65-70% first-attempt - slightly higher than CKA because the surface area is smaller (no etcd, no kubeadm, no node-level debugging)

Market demand

High

Increasingly required for backend / cloud-native engineering roles; salary band $120K-$170K. Search volume on par with CKA per Google Ads Keyword Planner.

Exam Domain Breakdown

Application Design and Build20%
Application Deployment20%
Application Observability and Maintenance15%
Application Environment, Configuration and Security25%
Services and Networking20%

Difficulty by Topic

kubectl fluency under time pressure
Imperative create/run/expose, --dry-run=client -o yaml scaffolding, kubectl explain - speed matters more than depth
Multi-container Pod patterns
Init containers, sidecars, sharing volumes between containers, ordering guarantees - heavily tested and easy to get wrong
ConfigMaps and Secrets (env, envFrom, volumes)
Three injection patterns each, base64 encoding for Secrets, immutable=true, projected volumes - the largest single sub-domain
Probes (liveness, readiness, startup)
exec vs httpGet vs tcpSocket, initialDelaySeconds vs failureThreshold, when each probe changes Pod-status outcomes
Resource requests, limits, and QoS
Guaranteed/Burstable/BestEffort tiers, OOMKilled vs CPU throttling, LimitRange and ResourceQuota interactions
Deployments, rolling updates, rollbacks
kubectl rollout history/status/undo, maxSurge / maxUnavailable, recreate vs rolling strategies, --record (deprecated) replacement
Jobs and CronJobs
completions / parallelism / backoffLimit, restartPolicy=Never vs OnFailure, schedule cron syntax, concurrencyPolicy
Services & Ingress (from app perspective)
ClusterIP / NodePort / LoadBalancer / Headless, Service-to-Pod selector matching, Ingress host + path rules, IngressClass
NetworkPolicies (default-deny, egress)
Default-deny patterns, ingress/egress podSelector + namespaceSelector composition - widely under-practiced and high-value
Helm basics + Kustomize overlays
helm install/upgrade/list/uninstall, kustomize build, base + overlay structure - newer additions to the curriculum, often skipped in study

Exam Tips

1

Configure your shell as the very first action: alias k=kubectl, source <(kubectl completion bash), complete -F __start_kubectl k, export do='--dry-run=client -o yaml', export now='--force --grace-period=0'. The 30 seconds you spend here saves minutes on every subsequent task.

2

Never write manifests from scratch when scaffolding works. kubectl create deployment / kubectl run / kubectl expose with --dry-run=client -o yaml > x.yaml then edit beats typing apiVersion / kind / spec.template.spec.containers by hand every time.

3

kubernetes.io/docs is open in your exam browser - bookmark Pods (lifecycle, multi-container), ConfigMap, Secret, Deployment, Probes, NetworkPolicy, Service, Ingress, Helm, Kustomize before exam day. Almost every objective has copy-pasteable YAML in the docs.

4

Always run kubectl config use-context <name> as the first command of every task. Tasks span multiple clusters and grading happens on the wrong cluster if you forget. Set the namespace once with kubectl config set-context --current --namespace=<ns> instead of typing -n on every command.

5

Application Environment, Configuration and Security is the largest domain at 25%. Nail ConfigMap and Secret injection in all three forms (env, envFrom, volume mounts), and know the difference between projected volumes, immutable=true, and using a Secret in imagePullSecrets. This single area returns the most points per study hour.

6

Multi-container Pod patterns appear on almost every attempt - usually as 'one container produces logs into a shared emptyDir volume, the second container ships them somewhere'. Practice the sidecar + emptyDir pattern until you can write the YAML without thinking. Init containers are tested separately and run sequentially before the main containers, not in parallel.

7

Probe questions have a trap: liveness probe failures restart the container; readiness probe failures only remove the Pod from Service endpoints. If a question says 'the Pod should be removed from the Service when X is failing but not restarted', the answer is a readiness probe, not a liveness probe.

8

NetworkPolicy is the highest-leverage topic in Services and Networking. Memorize the default-deny-ingress / default-deny-egress YAML cold (empty podSelector + policyTypes). Also know that NetworkPolicy is additive - multiple policies are OR'd, never AND'd - and that DNS egress to kube-system requires explicit allow when default-deny-egress is on.

9

Use the bundled killer.sh CKAD simulator twice - it's included free with your exam purchase. The simulator is intentionally harder and broader than the real exam; if you can finish it within the time budget on the second pass, the real exam will feel manageable.

10

Time budget: ~15-20 hands-on tasks in 120 minutes is roughly 7 minutes per task, but task weights vary. Read the percentage value in each task header, flag anything that looks > 10 minutes for later, and sweep the 2-4% quick wins first.

Study Resources

Who It's Best Suited For

Backend / cloud-native application engineers

CKAD is becoming a hiring filter for engineers building services that run on Kubernetes - it proves you can ship a production-ready Pod spec, not just kubectl apply somebody else's chart.

Full-stack engineers in container-first orgs

If your team's deploy story is 'push a Helm chart' or 'commit a kustomization.yaml', CKAD covers exactly the surface area you touch every day - probes, ConfigMaps, Secrets, rolling updates, NetworkPolicies.

DevOps engineers who already hold CKA

Lifts much of the substrate you already know (kubectl, Pods, Services) and adds the application-developer angle (multi-container patterns, Helm, Kustomize) - typically only 2-4 weeks of incremental study after CKA.

Engineers planning to take CKS

Either CKAD or CKA satisfies the CKS prerequisite. CKAD is the lighter path for engineers whose day job is shipping apps rather than running clusters.

Certification Path

KCNA - Kubernetes and Cloud Native Associate
CKS - Kubernetes Security Specialist (requires active CKA or CKAD)