How to Pass the CKAD (or how I passed the CKAD)

Kubernetes · CKAD · Cloud Native

How I Would Prepare for the CKAD Exam Today

The CKAD is a practical Kubernetes exam. You do not need to memorize everything about Kubernetes, but you do need to understand how the pieces fit together, know where to find answers quickly, and be able to solve real problems from the command line under time pressure.

TLDR

The biggest lesson I learned preparing for the CKAD was that knowing Kubernetes and passing the CKAD are related, but they are not exactly the same skill.

I studied quite a lot before my first attempt and still failed. I came within about 10% of passing. That failure turned out to be useful because it showed me that I had spent too much time learning broadly and not enough time practicing the specific workflow the exam rewards.

My preparation became much simpler after that:

1. Understand the major Kubernetes concepts and how they fit together.
2. Build and troubleshoot things yourself.
3. Practice solving tasks quickly while using the official documentation.

If I were preparing again today, I would follow essentially the same strategy—but I would update the topics and tools for the current CKAD curriculum.

Updated September 2026: This article began as notes from my own CKAD preparation and exam experience. The personal experience is unchanged, but I have updated the exam-specific material to reflect the current CKAD curriculum and exam environment. Kubernetes and Linux Foundation exam policies change over time, so always verify the official CKAD page before your exam.

What the CKAD Actually Tests

The Certified Kubernetes Application Developer exam is not primarily a multiple-choice knowledge test.

It is a hands-on, performance-based exam. You work in a Linux environment and solve Kubernetes tasks from the command line.

That distinction matters.

Reading about Kubernetes can teach you why a Deployment exists. The exam needs you to be able to create one, modify it, expose it, troubleshoot it, inspect its logs, update its configuration, and recognize when you have accidentally done something in the wrong namespace.

Current exam snapshot

Format

Performance-based
Real tasks completed from a command line.

Time

2 hours

Passing score

66%

Current Kubernetes version

v1.35 as of this September 2026 update.

The Linux Foundation periodically updates the exam environment as Kubernetes releases change, so check the official CKAD page before relying on the version number above.

What I Did the First Time

When I originally started preparing, I was not sure what the best path was.

I asked people I knew who had already passed the exam and got a lot of good recommendations: read Kubernetes documentation, set up a local environment, work through courses, use Minikube, and solve lots of hands-on problems in the terminal.

So I did a lot of studying.

Eventually I figured I was prepared enough and decided to take the exam. Since the exam purchase included a retake, I knew that if I missed on the first attempt I could learn from it and try again.

I failed.

I was not wildly unprepared. I came within roughly 10% of passing.

But when I went back to prepare for the second attempt, something important had changed: I finally understood what the exam was really asking me to be good at.

A lot of the material I had studied was useful for learning Kubernetes, but it was not necessarily the material that would earn the most points during a timed practical exam.

So I narrowed my preparation.

The Real Question: How Do I Know I'm Ready?

Kubernetes is enormous. If your goal is to know absolutely everything before scheduling the CKAD, you may never schedule it.

A better question is:

"Can I solve common Kubernetes application problems correctly and quickly without getting lost?"

For me, preparation broke down into three stages:

Understand the System → Build Things Yourself → Practice Under Time Pressure

Step 1: Understand How the Pieces Fit Together

Before trying to become fast, get the basic mental model right.

You should understand how an application goes from a container image to a running Kubernetes workload and how the major resources interact around it.

Image → Workload → Pod → Configuration → Service → Network Access → Observability

You do not need to understand every Kubernetes subsystem at an administrator level for CKAD, but you should understand what the application-facing pieces are doing.

Current CKAD domains

Application Design & Build — 20%

Container images, workload selection, multi-container Pods, and persistent or ephemeral storage.

Application Deployment — 20%

Deployments, rolling updates, deployment strategies, Helm, and Kustomize.

Observability & Maintenance — 15%

Probes, logs, monitoring, debugging, and API deprecations.

Environment, Configuration & Security — 25%

ConfigMaps, Secrets, resources, quotas, ServiceAccounts, SecurityContexts, authentication/authorization concepts, and resources extending Kubernetes.

Services & Networking — 20%

Services, application access, Ingress, and NetworkPolicies.

One important change from older versions of CKAD preparation material is that I would now explicitly practice things such as Helm, Kustomize, CRDs, workload selection, security configuration, and API deprecation awareness rather than treating the exam as mostly Pods, Deployments, Services, and ConfigMaps.

Start with one good overview

I still think an overview book, structured course, or high-quality tutorial is useful before grinding through exercises.

The goal at this stage is not memorization.

You are building a map in your head so that when somebody says:

• Deployment
• ConfigMap
• Secret
• Service
• Ingress
• NetworkPolicy
• PersistentVolumeClaim
• ServiceAccount
• SecurityContext

...you immediately understand roughly where that resource belongs and what problem it solves.

Step 2: Get Hands-On Experience

This is where CKAD preparation starts becoming useful even if you do not care about the certification itself.

Do not just read YAML.

Create it.

Break it.

Fix it.

The fastest way to discover whether you really understand Kubernetes is to make something fail and then try to figure out why.

A structured course with labs worked well for me because it forced me to repeatedly create and manipulate the same kinds of objects I would eventually encounter on the exam.

The specific course I originally used was Mumshad Mannambeth's CKAD course on Udemy. Courses change over time, so I would evaluate the current version rather than blindly choosing it because I used it years ago, but the combination of explanation + lab + timed practice is still exactly what I would look for.

Verify everything you create

This was one of the most valuable habits I developed.

Suppose a task asks you to create a Deployment and then expose it with a Service.

If you create the Deployment incorrectly and immediately move on to the Service, you can spend several minutes debugging the wrong layer.

Instead:

kubectl get deployment -n mynamespace
kubectl get pods -n mynamespace
kubectl describe pod mypod -n mynamespace
kubectl logs mypod -n mynamespace

Make sure the first step works before building another step on top of it.

Then test application connectivity whenever the task makes that possible.

curl http://service-name
wget -qO- http://service-name

CKAD habit: create → inspect → verify → continue. Do not assume that a command worked merely because it did not print an error.

Namespaces will eventually get you

One of the easiest ways to lose time is to create the correct resource in the wrong namespace.

Get into the habit of checking the namespace in the task before you do anything.

kubectl get pods -n mynamespace
kubectl get all -n mynamespace

When appropriate, you can also set the namespace on your current context:

kubectl config set-context --current --namespace=mynamespace

Just remember that doing so changes the default for subsequent commands.

Step 3: Become Fast

Once you understand the concepts and can solve problems correctly, the next constraint is time.

You do not need to memorize every Kubernetes YAML field.

You do need to avoid spending five minutes looking up something that should take thirty seconds.

That means getting fast in three different ways:

1. Know common kubectl commands without looking them up.
2. Know how to generate starter YAML instead of typing everything manually.
3. Know where the relevant examples are in the Kubernetes documentation.

Learn the Documentation Before You Need It

The Kubernetes documentation is not just study material.

It is part of your problem-solving toolkit.

During the current CKAD exam, candidates may use the browser in the exam VM to access the Kubernetes documentation, Kubernetes blog, Helm documentation, and task-specific documentation supplied through the exam's Quick Reference material.

That means your goal should not be:

"I have memorized Kubernetes."

It should be:

"I know enough Kubernetes to recognize the solution, and I can find exact syntax quickly when I need it."

Three Kubernetes documentation areas worth knowing

kubectl Reference

Useful when you remember what you want to do but forget the exact CLI syntax.

Concepts

Useful when you need to understand what a resource does and how its pieces relate.

Tasks

Often the most useful area when you need a concrete example of how to accomplish something.

I found task-oriented examples especially valuable because an example that is close to your problem can often be adapted much faster than writing a manifest from memory.

Exam-resource warning: Older CKAD guides sometimes recommend freely browsing Docker documentation or other external technical sites during the exam. Do not assume that is allowed. The Linux Foundation publishes a specific list of permitted resources. Check the current policy before your exam.

Commands Worth Practicing Until They Feel Automatic

I would not try to memorize hundreds of commands.

I would memorize the small set I use constantly and know how to get help for everything else.

Shorten kubectl

alias k=kubectl

If shell completion is available, using it can save additional typing as well.

Generate YAML instead of writing it from scratch

One of the highest-value CKAD patterns is:

kubectl <command> --dry-run=client -o yaml

Redirect that output into a file when you need to customize it:

kubectl create deployment web \
  --image=nginx \
  --dry-run=client \
  -o yaml > deployment.yaml

Then edit:

vi deployment.yaml

And apply:

kubectl apply -f deployment.yaml

Create a Pod quickly

kubectl run nginx \
  --image=nginx \
  --dry-run=client \
  -o yaml

Inspect resources

kubectl get pods
kubectl get pods -o wide
kubectl describe pod mypod
kubectl get pod mypod -o yaml

Edit an existing resource

kubectl edit deployment mydeployment

Read logs

kubectl logs mypod

For a multi-container Pod:

kubectl logs mypod -c mycontainer

For the previous instance of a restarted container:

kubectl logs mypod --previous

Execute a command inside a container

kubectl exec mypod -- ls

Or open a shell when one exists:

kubectl exec -it mypod -- sh

Create a Service

kubectl expose deployment mydeployment \
  --port=80 \
  --target-port=8080

Inspect resource usage

kubectl top pod

This depends on the cluster having the appropriate metrics support.

Use kubectl explain

This is another useful way to answer a YAML question without leaving the terminal.

kubectl explain deployment.spec
kubectl explain pod.spec.containers
kubectl explain pod.spec.containers.resources

Search describe output when troubleshooting

kubectl describe pods -n mynamespace | grep -i -C 10 "searchstring"

More often, though, I would inspect the specific resource:

kubectl describe pod mypod -n mynamespace

Use built-in command help

kubectl expose --help
kubectl create configmap --help
kubectl create secret --help

This is extremely useful when you remember that kubectl can do something imperatively but forget an option.

Base64

Kubernetes Secrets commonly expose base64-encoded values, so know both directions.

Decode:

echo 'MTIzNA==' | base64 --decode

Encode:

echo -n '1234' | base64

Useful Linux basics

ls -la
cat file.yaml
grep -i "text" file.yaml
curl http://example
wget -qO- http://example

The CKAD is a Kubernetes exam, but comfort with a Linux terminal makes everything faster.

Practice the Topics That Are Easy to Get Wrong

Some Kubernetes concepts are straightforward when you read them and much less straightforward when you have to configure or troubleshoot them under time pressure.

NetworkPolicies

Practice selectors, ingress/egress behavior, and recognizing when a networking problem is really a policy problem.

Services

Know selectors, ports, targetPorts, ClusterIP behavior, and how to test whether traffic actually reaches the application.

Ingress

Practice matching hosts and paths and connecting an Ingress to the correct Service.

Probes

Be comfortable with readiness, liveness, and startup probes and know why choosing the wrong one changes application behavior.

SecurityContext

Practice users, groups, capabilities, privilege settings, and the difference between Pod-level and container-level configuration.

Resources & Quotas

Know requests, limits, ResourceQuota, and how resource configuration can affect scheduling or application behavior.

ConfigMaps & Secrets

Practice using them as environment variables as well as mounted files.

Volumes

Be comfortable connecting Pods to ephemeral and persistent storage and diagnosing mount problems.

Multi-container Pods

Practice init containers and sidecar-style patterns rather than simply memorizing their definitions.

Rollouts

Know how to inspect rollout status, update an application, view history, and roll back.

Helm

Be comfortable finding, installing, inspecting, upgrading, rolling back, and removing an existing package.

Kustomize

This deserves explicit practice in a modern CKAD study plan. Understand bases, overlays, patches, and applying Kustomize configurations.

Deployment Strategies: Understand the Result

Canary and blue/green deployment questions can sound more complicated than they are.

Kubernetes does not necessarily give you a special "Canary" object or "BlueGreen" object.

The exam may instead ask you to use ordinary Kubernetes primitives—often Deployments, labels, replicas, and Services—to produce that behavior.

So do not merely memorize the names of deployment strategies.

Understand what traffic should go where.

Debugging Is a Core Skill

Creating resources is only half of the skill.

You should also be able to look at a broken application and move through a debugging sequence without randomly changing YAML.

1. Am I in the correct namespace?

2. Does the resource exist?

3. Is the Pod running?

4. If not, what does `kubectl describe` say?

5. What do the container logs say?

6. Is the application listening on the expected port?

7. Does the Service selector match the Pod labels?

8. Does the Service target the correct port?

9. Is a NetworkPolicy blocking traffic?

10. Is the readiness probe preventing traffic?

11. Are ConfigMaps, Secrets, volumes, or environment variables wrong?

12. Did a rollout introduce the problem?

A consistent debugging process is much faster than guessing.

Use the Mock Exams

I consider timed practice one of the most important parts of CKAD preparation.

The Linux Foundation currently includes two activations of the Killer.sh CKAD simulator with the exam purchase.

Use them.

But do not treat the score as the only thing that matters.

Afterward, ask:

• Which questions took me too long?
• Which commands did I have to look up repeatedly?
• Which documentation pages did I struggle to find?
• Which YAML structures did I repeatedly forget?
• Did I verify my resources after creating them?
• Did namespace mistakes cost me time?
• Did I spend too long on one difficult question?

A mock exam is most useful when it reveals where your workflow is slow.

Exam Strategy Matters

The clock moves faster than you expect.

If a question is turning into a time sink, move on.

You do not need 100% to pass.

Secure points from the work you know how to do, then return to harder tasks with the time remaining.

Do not let one stubborn task consume the exam. A nearly completed difficult question can be worth less than several easy questions you never reached.

Read the task carefully

Before touching the terminal, identify:

• the required namespace
• the requested resource name
• the image
• ports
• labels and selectors
• required output or behavior
• whether you are supposed to create or modify something

A technically correct Kubernetes solution can still be wrong if it does not match the task.

What I Would Not Spend Too Much Time On

The CKAD can easily tempt you into trying to become a Kubernetes administrator before taking an application-developer exam.

Understanding the broader architecture is useful, but I would not spend most of my preparation time memorizing details about control-plane administration that are outside the published CKAD competencies.

Follow the current curriculum.

If a topic is worth 20–25% of the exam, it deserves substantially more practice than an interesting Kubernetes topic that is not actually part of the CKAD objectives.

A Better Definition of "Ready"

I would consider myself ready when I could sit down at a clean terminal and comfortably do things like:

• Create and modify Pods and Deployments.
• Choose an appropriate workload resource.
• Configure Jobs and CronJobs.
• Create and consume ConfigMaps and Secrets.
• Configure resource requests and limits.
• Use ServiceAccounts and security contexts.
• Work with ephemeral and persistent volumes.
• Create Services and troubleshoot their selectors and ports.
• Configure Ingress.
• Understand and modify NetworkPolicies.
• Add readiness, liveness, and startup probes.
• Inspect logs and debug broken Pods.
• Perform rolling updates and rollbacks.
• Implement basic blue/green or canary-style deployments.
• Deploy and manage an existing Helm package.
• Work with Kustomize.
• Recognize and use Kubernetes resources that extend the API.
• Generate starter YAML quickly with imperative commands.
• Find an unfamiliar option quickly in the official documentation.

More importantly, I would want to do those things without needing ten minutes to remember where to start.

The Retake Changes How I Would Approach the Exam

The current standard CKAD purchase includes one free retake if you do not pass the first attempt.

That does not mean I would take the exam completely unprepared.

But I also would not wait until I felt like I knew all of Kubernetes.

At some point, another week of broad reading may teach you less about your readiness than a realistic timed simulation—or the actual exam.

One More Practical Note: Check the Current Rules

CKAD has changed since I originally took it, and it will change again.

Before the exam, I would always check:

• the current Kubernetes exam version
• the current curriculum
• the current allowed-resource policy
• the current retake policy
• the current remote-testing requirements

Also test your computer and exam setup ahead of time.

The current exam is delivered through a secured remote environment, and Linux Foundation explicitly recommends reviewing the technical requirements before exam day.

Final Thoughts

I already had professional Kubernetes experience when I originally prepared for the CKAD, and I still discovered that I had a lot to learn.

That is part of why I think the certification can be worthwhile.

CKAD preparation forces you to move beyond:

"I generally understand what Kubernetes does."

...and toward:

"Give me a terminal and a Kubernetes problem, and I can probably figure it out."

Those are very different levels of familiarity.

If your goal is simply to collect a certification, there are easier exams.

But if you want a structured reason to get comfortable with containers, Kubernetes resources, Linux command-line workflows, troubleshooting, networking, configuration, deployment strategies, Helm, and related cloud-native tooling, preparing for the CKAD is still a useful exercise.

Understand the system. Build things yourself. Verify everything. Learn how to find answers quickly. Then practice until solving Kubernetes problems under a clock feels normal.

Quick Reference: My CKAD Preparation Checklist

FOUNDATION

[ ] Understand Pods, Deployments and workload resources
[ ] Understand labels and selectors
[ ] Understand container images
[ ] Understand Services and application networking
[ ] Understand configuration and storage


APPLICATION DESIGN & BUILD

[ ] Pods
[ ] Deployments
[ ] Jobs
[ ] CronJobs
[ ] DaemonSets / other appropriate workloads
[ ] Multi-container Pods
[ ] Init containers
[ ] Container images
[ ] Volumes


DEPLOYMENT

[ ] Rolling updates
[ ] Rollbacks
[ ] Blue/green concepts
[ ] Canary concepts
[ ] Helm
[ ] Kustomize


OBSERVABILITY & MAINTENANCE

[ ] Readiness probes
[ ] Liveness probes
[ ] Startup probes
[ ] Logs
[ ] kubectl top
[ ] kubectl describe
[ ] Debugging
[ ] API deprecation awareness


CONFIGURATION & SECURITY

[ ] ConfigMaps
[ ] Secrets
[ ] Environment variables
[ ] Resource requests
[ ] Resource limits
[ ] Quotas
[ ] ServiceAccounts
[ ] SecurityContexts
[ ] Linux capabilities
[ ] Authentication / authorization concepts
[ ] CRDs / resources extending Kubernetes


SERVICES & NETWORKING

[ ] Services
[ ] Ports and targetPorts
[ ] Labels and selectors
[ ] Ingress
[ ] NetworkPolicies
[ ] Connectivity testing


EXAM SPEED

[ ] alias k=kubectl
[ ] Comfortable with --dry-run=client -o yaml
[ ] Comfortable editing generated YAML
[ ] Comfortable with kubectl explain
[ ] Comfortable with kubectl --help
[ ] Know Kubernetes docs layout
[ ] Know how to find task examples quickly
[ ] Practice with namespaces
[ ] Verify every resource after creating it


BEFORE SCHEDULING

[ ] Complete timed practice exams
[ ] Complete Killer.sh simulator
[ ] Review mistakes
[ ] Repeat weak areas
[ ] Check current CKAD curriculum
[ ] Check current Kubernetes exam version
[ ] Check allowed documentation policy
[ ] Check remote-testing requirements

References & Further Reading

Exam versions, prices, policies, and curriculum details can change. These official sources should take precedence over any blog post, including this one.

Linux Foundation — Certified Kubernetes Application Developer (CKAD) ↗ https://training.linuxfoundation.org/certification/certified-kubernetes-application-developer-ckad/ CNCF — CKAD Certification & Curriculum ↗ https://www.cncf.io/training/certification/ckad/ Kubernetes Documentation ↗ https://kubernetes.io/docs/home/ Kubernetes — kubectl Quick Reference ↗ https://kubernetes.io/docs/reference/kubectl/quick-reference/ Helm Documentation ↗ https://helm.sh/docs/ Killer.sh Exam Simulator ↗ https://killer.sh/ Udemy — Certified Kubernetes Application Developer Course ↗ https://www.udemy.com/course/certified-kubernetes-application-developer/