How I Passed the CKAD in One Month (84%): Strategy, Resources and the Mistakes That Taught Me the Most

From struggling with YAML indentation to scoring 84% on the Certified Kubernetes Application Developer exam in just one month.

On November 5, 2026, I passed the Certified Kubernetes Application Developer (CKAD) exam with a score of 84%.

One month earlier, I was struggling with a seemingly simple exercise: deploying a multi-container Redis Pod using a ConfigMap and an emptyDir volume.

I was fighting YAML indentation errors and trying to understand how volumes and mounts actually worked together.

What made the difference wasn't studying more theory. It was practicing consistently, learning from my mistakes, and changing the way I approached the exam.

In this article, I'll share:

• My background and starting point.
• The resources I used.
• My one-month preparation plan.
• My practice exam scores.
• The three-pass strategy that took me from 54% to 91% on a mock exam.
• The mistakes that cost me the most points.
• My advice for anyone preparing for the CKAD.

1. My background: From QA to Cloud and DevOps

I'm a computer engineer with more than eight years of experience in Quality Assurance, test automation and systems validation, mainly in the telecom and video/OTT industries.

I'm currently transitioning towards Cloud, Infrastructure and DevOps engineering.

Before starting my CKAD preparation, I already had several AWS certifications, including AWS DevOps Engineer Professional, HashiCorp Terraform Associate and Kubernetes and Cloud Native Associate (KCNA).

I was familiar with Kubernetes concepts, but there was a significant gap between understanding the theory and being able to execute commands efficiently with kubectl under time pressure.

That's exactly what the CKAD challenges: practical skills, speed and accuracy.

2. The resources I used

I relied on four main resources, each serving a different purpose.

I also used the official Kubernetes documentation and Helm documentation regularly.

This is particularly important because these are the documentation resources available during the exam. Knowing how to navigate them quickly is part of the preparation.

My most useful study habit: Keeping a mistake notebook

One habit made a huge difference throughout my preparation.

After each exercise, I wrote down:

• The commands I had used.
• The errors I encountered.
• Why the errors happened.
• How I fixed them.
• What I needed to remember next time.

Instead of simply repeating exercises, I was building a personal reference guide based on my own mistakes.

By exam day, this notebook had become one of my most valuable preparation resources.

3. My one-month preparation plan

I practiced every day, usually for 1.5 to 2 hours.

My approach was progressive: start with individual concepts, practice them independently, and then move on to full mock exams.

Week 1: Building the foundations

I focused on the basics:

• Pods
• ConfigMaps
• Volumes and mounts
• YAML syntax and indentation

I also spent time doing simple YAML debugging exercises.

Interestingly, most of my early mistakes were not Kubernetes-related. They were YAML-related.

Weeks 2 and 3: Practicing one topic at a time

I worked through Chad Crowell's Killercoda CKAD scenarios.

The topics included:

• ConfigMaps and Secrets
• Resource requests, limits and LimitRanges
• Deployments and ReplicaSets
• Services and DNS
• Logs and troubleshooting
• Liveness, readiness and startup probes
• Jobs and CronJobs
• RBAC and securityContext
• Pod Security
• NetworkPolicies
• Kustomize
• Ingress

My objective was to become comfortable solving each type of task without constantly looking at the solution.

Week 4: Mock exams and exam simulation

The final week was dedicated to practice exams.

I completed the KodeKloud Mock Exams, reviewed every lost point on the same day, and repeated failed exercises on Killercoda.

A few days before the real exam, I also completed my two killer.sh sessions.

One rule helped me avoid wasting too much time:

If I was stuck on an exercise for more than 15 minutes, I would read the solution, understand it, and redo the exercise the following day.

The goal was not to spend 45 minutes struggling with one task. It was to understand the problem and learn how to solve it independently.

4. My practice exam scores: A few surprises along the way

My scores were far from consistent.

Some mock exams went very well, while others exposed weaknesses I hadn't expected.

Here is how I progressed:

Two important lessons emerged from these results.

First, don't judge your preparation based on a single mock exam.

The difficulty and topic distribution can vary significantly. Look at the overall trend and, more importantly, the types of mistakes you make.

Second, use your scores to identify what needs more work.

Helm repeatedly cost me points. Once I dedicated an entire practice session to it, the results improved.

5. The three-pass strategy that changed everything

This was probably the most important improvement in my preparation.

I went from 54% to 91% on two KodeKloud mock exams, without suddenly learning a lot of new Kubernetes concepts.

The difference was how I managed my time.

What went wrong on Mock Exam 4?

Initially, I answered questions in the order they appeared.

I got stuck on two long questions involving writing CRDs from scratch.

By the time I finished, I had run out of time and had not even attempted the last four questions.

Those questions turned out to be among the easiest in the exam.

I realized that spending too much time on one difficult task could prevent me from securing several easy points elsewhere.

So I changed my approach.

My three-pass strategy

Pass 1: Secure the quick wins

Read every question and immediately solve the ones that take less than three minutes.

Examples:

• Checking logs.
• Adding labels.
• Scaling a Deployment.
• Creating a ConfigMap.
• Running kubectl top.

Flag the longer questions and move on.

Pass 2: Focus on high-value questions

Prioritize questions worth 7–8%, starting with the topics you know best.

These questions deserve more time, but you should still avoid getting stuck indefinitely.

Pass 3: Tackle the difficult questions

Use the remaining time for longer or less familiar tasks:

• Writing a CRD from scratch.
• Debugging a broken controller.
• Investigating complex configuration issues.

At this point, you have already secured the points from the easier questions.

My time management rule

I used a simple rule:

Approximately one minute per percentage point.

For example:

• 4% question → around 4 minutes.
• 7% question → around 7 minutes.
• 10% question → around 10 minutes.

If I reached twice the allocated time without making sufficient progress, I flagged the question and moved on.

This strategy did more than improve my score. It also reduced stress because I knew that a difficult question would not prevent me from answering easier ones.

6. The small mistakes that cost me points

Something interesting happened during my preparation.

Most of my lost points were not caused by a lack of Kubernetes knowledge.

They came from small details, forgotten requirements or incorrect assumptions.

Here are the mistakes I encountered most often.

My most important troubleshooting habit

Before moving to the next question, I learned to verify the actual state of the resources.

A successful command does not necessarily mean the task is complete.

For example:

• Is the Pod actually Running?
• Is it READY?
• Is the PVC Bound?
• Are the Service endpoints correct?
• Is the requested configuration really applied?

When something doesn't look right, kubectl describe and kubectl logs are usually good places to start.

7. CKAD topics I recommend practicing more in 2026

Beyond the classic topics such as Deployments, Services, ConfigMaps, Secrets and probes, a few areas deserve particular attention.

Native sidecars

Since Kubernetes 1.29, native sidecars are represented by init containers with:

restartPolicy: Always 

Pay attention to the wording of the task. A native sidecar is not simply another regular container in the Pod specification.

Helm

Helm was one of my weaker areas during the mock exams.

A few things I recommend practicing:

• Adding repositories with helm repo add.
• Installing charts from repositories versus local chart directories.
• Checking releases with helm list -A.
• Specifying namespaces consistently.
• Using --version to select a chart version.
• Using --reuse-values when upgrading a release with custom values.

For example:

helm repo add bitnami https://charts.bitnami.com/bitnami helm install my-release bitnami/nginx -n default 

Remember that a chart version and an application image tag are two different things.

Ingress

Always pay attention to ingressClassName.

If an Ingress keeps returning 404 errors, check the Ingress Controller logs.

In some of my mock exams, the actual cause of the problem was clearly documented in those logs.

NetworkPolicies

Make sure you understand the difference between AND and OR conditions.

• Separate rules (two YAML list entries) represent OR.
• Multiple selectors within the same rule represent AND.

Another important detail: when restricting egress, make sure DNS traffic is allowed on port 53 using both UDP and TCP.

To target a namespace, remember the built-in label:

kubernetes.io/metadata.name 

CRDs

Most of the time, you will need to discover and use existing Custom Resource Definitions.

Useful commands:

kubectl get crd kubectl api-resources kubectl explain <kind>.spec 

If you need to write a CRD, use the official documentation as a reference and pay attention to details such as:

scope: Namespaced 

The capital N matters.

Docker and Podman

Don't overlook container image operations.

Practice:

docker build -t my-image . docker push my-image docker run -d --name my-container my-image docker logs my-container docker save -o image.tar my-image docker load -i image.tar 

Also remember that docker ps displays running containers by default. Use docker ps -a to include stopped containers.

8. Exam day: The experience and the wait for results

I left the exam genuinely unsure whether I had passed.

At around the one-hour mark, I checked the clock and started panicking because I felt far behind.

I took a breath, returned to my three-pass strategy and continued working through the questions.

Looking back, this was probably one of the most important moments of the exam.

What helped me on the day:

• Setting up useful aliases at the beginning:

alias k=kubectl export do="--dry-run=client -o yaml" export now="--force --grace-period 0" 

• Running the SSH and context commands provided at the beginning of each question.
• Generating YAML using imperative commands instead of typing everything manually.
• Checking names, namespaces, image tags, ports and requested output formats before validating each task.
• Following the three-pass strategy instead of spending too long on difficult questions.

Waiting for the results

The results officially arrive by email, generally within 24 hours of finishing the exam.

Some candidates report waiting 24 to 36 hours.

Mine arrived the following afternoon.

One thing I learned: the waiting time doesn't tell you anything about your result.

So try to disconnect after the exam. I know it's easier said than done (I probably refreshed my inbox every five minutes!).

9. What's next?

Passing the CKAD is another milestone in my transition towards Cloud and DevOps engineering.

My next objective is the Prometheus Certified Associate (PCA) certification, to strengthen the observability side of my Kubernetes and cloud profile.

I've already worked with Prometheus and Grafana to monitor LibraryCorner, a project I built and deployed on AWS EKS.

I'll share more about this project and its architecture in an upcoming article.

Final thoughts: My advice if you're preparing for the CKAD

If I had to summarize my preparation in five recommendations:

1. Practice every day. A real terminal is much more valuable than simply watching videos.
2. Keep track of your mistakes. Understanding why something failed is more useful than memorizing the solution.
3. Learn to manage your time. Secure the easy points before tackling complex tasks.
4. Verify everything. A successful command doesn't guarantee the requested final state.
5. Don't panic over mock exam scores. Focus on your progress, identify weaknesses and work on them.

The CKAD is a practical exam. Knowing Kubernetes concepts is important, but being able to apply them quickly and accurately makes the difference.

If you're currently preparing for the CKAD, I hope my experience helps you organize your study plan and avoid some of the mistakes I made.

Good luck with your preparation, and feel free to share your questions or experiences in the comments!