CKAD — Exam Tips & Strategies

The Difference Between Knowing and Passing

Many people who know Kubernetes still fail the CKAD. Why? Because the exam tests speed and execution under pressure — not just knowledge. These tips bridge the gap between understanding concepts and passing the exam.

Time Management

You have 2 hours for 15–20 tasks. That averages to roughly 6–8 minutes per task.

The 3-Pass Strategy

Use this approach for optimal time management:

Pass	Focus	Time	Strategy
Pass 1	Easy questions	40–50 min	Solve everything you can do quickly (1–4 min each)
Pass 2	Medium questions	40–50 min	Tackle questions that need YAML editing or debugging
Pass 3	Hard questions	20–30 min	Attempt remaining flagged questions

Time Rules

1. Never spend more than 10 minutes on a single question during Pass 1
2. Flag and skip questions you can’t solve in 3 minutes
3. Easy points first — a 2% question solved in 1 minute beats a 5% question taking 15 minutes
4. Don’t perfect — complete — a partially correct answer earns partial credit

Tip: Questions have different weights. Check the percentage shown for each question. Prioritize high-weight questions that you can solve quickly.

Essential Exam Shortcuts

First 2 Minutes — Set Up Your Environment

# Run these immediately when the exam starts
alias k=kubectl
complete -o default -F __start_kubectl k
export do="--dry-run=client -o yaml"
export now="--force --grace-period 0"

Speed Commands

Task	Fast Way
Create any resource YAML	k run/create ... $do > file.yaml
Delete a resource fast	k delete pod nginx $now
Check field names	k explain pod.spec.containers
Find running resources	k get all -n <namespace>
Quick debug	k describe pod <name> \| tail -20
View logs	k logs <pod> --tail=50

vi Editor Shortcuts

You will edit YAML in the terminal. If you use vi, these shortcuts save time:

Shortcut	Action
i	Enter insert mode
Esc	Exit insert mode
:wq	Save and quit
:q!	Quit without saving
dd	Delete a line
yy + p	Copy and paste a line
/search	Search for text
u	Undo
:set number	Show line numbers
:%s/old/new/g	Find and replace

Tip: Add :set number and :set tabstop=2 shiftwidth=2 expandtab to your .vimrc at the start of the exam for easier YAML editing.

YAML Best Practices for the Exam

Indentation Matters

YAML errors are the #1 time killer in the exam. Follow these rules:

1. Always use 2 spaces for indentation (never tabs)
2. Use kubectl explain to verify field names before writing YAML
3. Generate first, edit later — start with --dry-run=client -o yaml, then modify
4. Validate before applying — use kubectl apply --dry-run=server -f file.yaml to catch errors

Common YAML Mistakes

Mistake	Example	Fix
Wrong indentation	containers: at wrong level	Check with kubectl explain
Tabs instead of spaces	Invisible error	:set expandtab in vi
Missing - for list items	name: nginx instead of - name: nginx	Check if parent field is an array
Wrong field name	Container instead of containers	Use kubectl explain
String/int confusion	port: "80" instead of port: 80	Ports are integers, not strings

Common Exam Traps

Trap 1: Wrong Context

Every question specifies a cluster context. If you don’t switch, you work on the wrong cluster.

# ALWAYS run this before starting a question
kubectl config use-context <context-name>

Trap 2: Wrong Namespace

Questions specify namespaces. If you create a resource in the default namespace instead of the required one, you get zero points.

# Set the namespace before working
kubectl config set-context --current --namespace=<ns>

Trap 3: Not Reading the Full Question

Exam questions often have specific requirements buried in the text:

• Specific labels or annotations
• Specific port numbers
• Resources must be in a specific namespace
• Pods must run as a specific user

Read the entire question before starting. Underline key requirements mentally.

Trap 4: Over-Engineering

Don’t add things that aren’t asked for. If the question says “create a Pod with image nginx,” don’t add health checks, resource limits, or security contexts unless specifically requested.

Trap 5: Forgetting to Verify

After creating a resource, always verify it works:

# Verify Pod is running
k get pod <name> -n <namespace>

# Verify Service endpoints
k get endpoints <service-name>

# Verify ConfigMap content
k describe configmap <name>

# Test Service connectivity
k run test --image=busybox --rm -it -- wget -O- http://<service>:<port>

Exam Day Checklist

30 Minutes Before

• Close all unnecessary applications
• Ensure stable internet (wired if possible)
• Have government-issued ID ready
• Clear your desk completely
• Close your room door
• Use the restroom
• Take a deep breath — you’ve got this

First 2 Minutes of Exam

• Set up kubectl alias: alias k=kubectl
• Set up bash completion for alias
• Set up $do and $now exports
• Test with: k get nodes

During the Exam

• Read each question completely before starting
• Switch context for every question
• Set namespace for every question
• Use imperative commands when possible
• Verify your work before moving on
• Flag hard questions and move on
• Keep an eye on the clock

Scoring Strategy

Since the passing score is 66%, you can afford to miss some questions. Here is how to think about it:

Scenario	Questions Solved	Approximate Score
Safe pass	14–15 out of 20	~70–75%
Close pass	13 out of 20	~65–70%
Fail zone	12 or fewer	Below 66%

Strategy: Aim to fully solve 14+ questions. Partially solve any remaining ones for partial credit.

Partial Credit

The CKAD exam awards partial credit. Even if you can’t complete a question fully:

• Create the resource, even if one field is wrong
• Get the basic structure right, even if advanced configuration is missing
• A partially correct answer > a blank answer

Key Takeaways

1. Practice on a real cluster — Use minikube, kind, or killer.sh (included with your exam purchase)
2. Master imperative commands — kubectl run, kubectl create, kubectl expose save minutes per task
3. Use --dry-run=client -o yaml — Generate YAML templates fast, then edit them
4. Learn kubectl explain — Use kubectl explain pod.spec.containers to check field names during the exam
5. Time management — Solve easy questions first, flag hard ones, come back later
6. Read questions carefully — Pay attention to the namespace, context, and exact resource names
7. Practice vi/nano — You will edit YAML files in the terminal. Pick one editor and get fast with it

---

FAQ

Q: What if I run out of time?

Focus on answering as many questions as possible in Pass 1. Partial answers with the resource created (even with minor issues) earn partial credit. Don’t spend 15 minutes perfecting one answer at the cost of attempting three more.

Q: How similar is killer.sh to the real exam?

Killer.sh is intentionally harder than the real exam. If you can score 60%+ on killer.sh, you are very likely to pass the real CKAD. The interface and style are very similar.

Q: Can I go back to previous questions?

Yes — you can navigate between questions freely and flag questions for review. Use the 3-pass strategy to maximize your score.