CKAD Exam Prep 2026: The 8 kubectl Patterns That Are Worth More Than Any Course

Most CKAD exam prep 2026 advice is a reading list. Here's a different take: the exam is two hours, roughly 15–20 hands-on tasks on a live cluster, and the difference between passing and failing is almost entirely how fast you can produce correct YAML.

So this post is eight patterns. Not concepts — patterns. The literal things I typed over and over until they were reflexes. If you internalise these, most of the exam becomes typing practice.

First, the shape of the thing

The current CKAD domains and weights:

Domain	Weight
Application Design and Build	20%
Application Deployment	20%
Application Observability and Maintenance	15%
Application Environment, Configuration and Security	25%
Services and Networking	20%

Passing is 66%. Two hours. You get a free retake within 12 months, and one browser terminal with access to kubernetes.io docs.

Note that Environment, Configuration and Security is the heaviest block at 25% — ConfigMaps, Secrets, SecurityContext, ServiceAccounts, resource requests/limits, and CRDs. People over-prepare Deployments and under-prepare this. Don't.

The 8 patterns

1. Never write YAML from scratch

kubectl create deployment web --image=nginx --replicas=3 --dry-run=client -o yaml > d.yaml

Every single object has a generator or can be scaffolded this way. If you find yourself typing apiVersion: by hand, you've already lost 90 seconds. Learn which resources have kubectl create support (deployment, job, cronjob, configmap, secret, service, serviceaccount, role, rolebinding, quota, ingress) and use run for pods:

kubectl run tester --image=busybox --restart=Never --dry-run=client -o yaml -- sleep 3600 > p.yaml

2. Set your environment in the first 60 seconds

alias k=kubectl
export do="--dry-run=client -o yaml"
export now="--force --grace-period=0"
source <(kubectl completion bash)

Then k create deploy web --image=nginx $do > d.yaml. That $do variable saves you a genuinely material amount of typing across 18 tasks.

3. Always confirm the namespace

Every task tells you a namespace. Half of all "I did it right and got zero" stories are people who created the object in default.

k config set-context --current --namespace=<ns>

Do it at the start of every task. Not once — every task.

4. Patch, don't rewrite

For "add a liveness probe to this existing deployment" style tasks:

k edit deploy web

or for something scriptable:

k set image deploy/web nginx=nginx:1.25
k set env deploy/web KEY=value
k scale deploy/web --replicas=5
k rollout undo deploy/web

kubectl set and kubectl rollout cover a surprising share of the Deployment domain without touching a file.

5. Know the four ways config reaches a container

This is the 25% domain in one bullet list, and you must be fluent in all four:

• env.valueFrom.configMapKeyRef — one key as one variable
• envFrom.configMapRef — every key as variables
• volumes.configMap + volumeMounts — keys as files
• the same three again, with secretKeyRef / secretRef / volumes.secret

Write all four out from memory once a day for a week. That's it, that's the drill.

6. Multi-container patterns, by name

Sidecar, ambassador, adapter, and init containers. The exam describes a scenario and expects you to pick the shape. The most common real task: "add an init container that waits for a service" or "add a sidecar that tails a log file from a shared emptyDir." Practise the shared-emptyDir pattern specifically — it's the most frequently asked and the most fiddly to type.

7. Debug in a fixed order

k get po -o wide
k describe po <name>      # events at the bottom — read these first
k logs <name> -c <container>
k logs <name> --previous  # for CrashLoopBackOff
k exec -it <name> -- sh

describe events before logs. Always. Most failures (ImagePullBackOff, failed mounts, unschedulable, failed probes) are diagnosed from events alone in five seconds, and people waste minutes reading logs that never got written.

8. Jobs, CronJobs, and the fields that get asked

completions, parallelism, backoffLimit, activeDeadlineSeconds for Jobs. schedule, concurrencyPolicy, startingDeadlineSeconds for CronJobs. These are pure memorisation and they are reliably worth marks.

The time strategy that actually matters

Two hours, ~18 tasks, each weighted differently — and the weight is shown. Here's the plan:

1. First pass, 70 minutes. Do every task you can finish in under four minutes. Skip anything that smells long. Flag it and move.
2. Second pass, 40 minutes. The flagged high-weight ones.
3. Last 10 minutes. Verify. k get all -n <ns> for each namespace you touched.

The single most common failure mode is spending 20 minutes on one 4% task while three 7% tasks sit untouched. Watch the weights.

Where practice questions fit into a hands-on exam

CKAD is performance-based, so "practice tests" sound irrelevant. They're not — they fix a different problem. Scenario labs fix your sequence. Question sets fix your recall: which field, which apiVersion, which flag.

I did a free CKAD practice test on my commute — twenty questions, no cluster needed — and then hands-on labs at night. The commute sets are what stopped me hesitating on field names, and hesitation is the whole enemy here. The CKAD exam page has the current domain weightings if you want the reference.

A four-week ramp

Week 1: Pods, Deployments, Jobs, CronJobs. Generate everything with $do. No copy-paste from docs.

Week 2: ConfigMaps, Secrets, SecurityContext, ServiceAccounts, resource requests and limits. The heavy domain — give it the most time.

Week 3: Services, Ingress, NetworkPolicy, probes, and multi-container patterns.

Week 4: Timed full simulations only. Two hours, no pausing. Then review — and re-type the ones you got wrong rather than reading the solution.

One opinion to close on

CKAD is easier than CKA. Smaller surface, friendlier tasks, no cluster upgrades or etcd backups. If you're choosing between them and you write applications rather than run clusters, start here.

But it punishes slow typing in a way no multiple-choice exam ever will. Build the reflexes, not the vocabulary.