Exam Format and Scoring Strategy

Knowing Kubernetes is necessary to pass the CKAD. It’s not sufficient. Candidates who understand Deployments, Services, and ConfigMaps still fail — regularly — because they walked into the exam without a strategy for how to spend their 120 minutes. This section gives you that strategy, built on top of a precise understanding of how the exam environment works, how tasks are scored, and where most candidates leave points on the table.

The Exam Environment: What You’re Walking Into

The CKAD is delivered through the PSI Secure Browser, a locked-down proctoring platform that takes over your entire screen. Before the exam starts, a proctor verifies your identity via webcam, checks your room for unauthorized materials, and ensures your desk is clear. This check-in process typically takes 15-30 minutes before your timer starts, so plan to be seated and ready well ahead of your scheduled time.

Once the exam begins, you’ll see a split interface:

Component	Description
Left panel	The task description — what you need to accomplish
Right panel	A Linux terminal connected to one or more Kubernetes clusters
Top bar	Task navigation, timer, and notepad
Browser tab	One additional tab allowed for documentation

You work in a real Linux terminal with kubectl, vim/nano, and standard command-line tools pre-installed. The clusters are pre-configured — you don’t install anything. Each task specifies which cluster context to use, and you switch between them with kubectl config use-context.

A few critical constraints to internalize:

• Single monitor only. External displays must be disconnected.
• No second applications. You cannot alt-tab to a local terminal, notes app, or IDE.
• One extra browser tab. You can open documentation from a specific allowlist (more on this below).
• Webcam and microphone stay on. The proctor monitors you throughout the exam.
• No one else in the room. No talking, no headphones with music, no background assistance.

The environment feels restrictive the first time you encounter it. The terminal font might not be what you’re used to. The copy-paste behavior is different from your local machine. The screen real estate is limited. All of this is why practicing in a similar environment beforehand matters so much.

Task Structure: What the Questions Look Like

Each task follows a consistent pattern:

1. Context switch instruction — “Set the context to cluster3 by running: kubectl config use-context cluster3”
2. Scenario description — A paragraph describing the situation and what needs to be created, modified, or fixed
3. Specific requirements — Bullet points listing exact specifications (names, namespaces, images, ports, labels, etc.)
4. Namespace specification — Almost every task specifies a namespace you must work in

Here’s a representative example of what a task feels like (this is not an actual exam question):

Task 7 (5%)

Set context: kubectl config use-context cluster2

A Deployment named web-frontend exists in namespace staging. It currently runs 2 replicas of nginx:1.24. Update the Deployment to:

• Use image nginx:1.25
• Scale to 4 replicas
• Add a readiness probe that performs an HTTP GET on port 80 at path /healthz with an initial delay of 5 seconds

Notice the precision. The task gives you exact names, exact namespaces, exact values. Your job is to implement exactly what’s asked — no more, no less.

Tasks fall into several categories:

Task Type	Example	Typical Weight
Create from scratch	Create a Pod, Deployment, Service, Job	3-6%
Modify existing	Add probes, resource limits, or volumes to a running workload	4-7%
Fix broken config	A Deployment isn’t starting — find and fix the issue	5-8%
Multi-step	Create a PVC, mount it into a Pod, verify data persists	6-8%
Quick config	Create a ConfigMap, create a Secret, expose a port	2-4%

Scoring: How Points Are Calculated

Your score is the weighted sum of points earned across all tasks. Each task has a percentage weight — when you see “Task 7 (5%)” in the exam, that task is worth 5% of your total score. The weights across all tasks sum to 100%.

Partial credit is real and significant. Automated grading scripts check your work against specific criteria. If a task has four requirements and you nail three of them, you earn roughly 75% of that task’s weight. This changes your strategy in an important way: a partially correct answer is vastly better than skipping a task entirely.

Consider this scenario across two hypothetical candidates:

Task	Weight	Candidate A (perfectionist)	Candidate B (pragmatist)
Task 1	4%	4% (perfect, 8 min)	4% (perfect, 4 min)
Task 2	7%	7% (perfect, 15 min)	5% (partial, 6 min)
Task 3	3%	3% (perfect, 5 min)	3% (perfect, 2 min)
Task 4	6%	0% (ran out of time)	4% (partial, 6 min)
Task 5	5%	0% (ran out of time)	3% (partial, 5 min)
Total	25%	14%	19%

Candidate B earned 35% more points on the same five tasks by accepting partial credit and moving forward. Over 15-20 tasks, this difference compounds dramatically.

The critical threshold is 66%. You don’t need to be perfect. You need 66 points out of 100. That means you can get a third of the exam wrong and still pass. Let that recalibrate your mindset: the exam rewards coverage over perfection.

Time Management: The 120-Minute Battle Plan

Two hours. Fifteen to twenty tasks. That gives you an average of 6 to 8 minutes per task. Some tasks you’ll finish in 90 seconds. Others could consume 12 minutes if you let them. The key word is if you let them.

Here is a structured approach to managing your time:

Phase 1: The First Pass (0:00 – 1:30, roughly 90 minutes)

Work through every task in order. For each task:

1. Read the entire task before touching the keyboard. Identify the namespace, the resource type, and the specific requirements.
2. Switch context immediately. Run the kubectl config use-context command the task specifies. Do this first, every time, without exception.
3. Set the namespace. Run kubectl config set-context --current --namespace=<ns> so every subsequent command targets the right namespace.
4. Execute the task. Use imperative commands where possible. Fall back to YAML only when needed.
5. Time-box to 6 minutes. If you’re not close to done after 6 minutes, flag the task and move on. You’ll come back.

The flag/bookmark feature in the exam interface exists for exactly this purpose. Use it without guilt. A flagged task isn’t a failed task — it’s a deliberate tactical decision.

Phase 2: The Return Pass (1:30 – 2:00, final 30 minutes)

Go back to every flagged task. You now have two advantages:

• Reduced pressure. You’ve already banked points on the easier tasks.
• Fresh eyes. Problems that seemed intractable 45 minutes ago often click the second time around.

Prioritize flagged tasks by their weight. An 8% task deserves your remaining time more than a 3% task. If you can earn even partial credit on two or three flagged tasks, that might be the difference between 64% and 70%.

The Quick-Wins-First Variant

An alternative approach that many successful candidates use: skim all tasks first (spend 30 seconds each) and reorder by difficulty. Attack the easiest, lowest-weight tasks first. These are typically “create a ConfigMap,” “create a Secret,” or “create a Service” tasks that take 1-2 minutes for a prepared candidate.

Why this works:

• You bank 15-25% of your score in the first 15-20 minutes
• The psychological momentum is powerful — you feel in control, not frantic
• You now have 100 minutes for the harder tasks, with a comfortable score cushion

The downside is that skimming all tasks upfront costs 8-10 minutes. Whether that trade-off works for you depends on your style. Try both approaches during practice and commit to one before exam day.

Allowed Resources: Your Open-Book Advantage

The CKAD is an open-book exam — but with a very specific bookshelf. You may open one additional browser tab with access to:

Allowed Domain	What’s There
kubernetes.io/docs	Official Kubernetes documentation
kubernetes.io/blog	Kubernetes blog posts
helm.sh/docs	Helm documentation

That’s it. No Stack Overflow. No personal notes. No bookmarked Notion pages. No ChatGPT.

This constraint makes how you use the documentation a competitive skill. Here’s how to be fast:

Search, Don’t Browse

The kubernetes.io/docs site has a search bar. Use it. Typing “networkpolicy” into the search bar gets you to the NetworkPolicy reference page in 3 seconds. Clicking through the sidebar navigation takes 15-30 seconds. Over 20 tasks, that difference adds up to minutes.

Know the High-Value Pages

Certain documentation pages are worth bookmarking in your muscle memory. During the exam, you can type these URLs directly:

kubernetes.io/docs/reference/kubectl/cheatsheet/
kubernetes.io/docs/concepts/workloads/pods/
kubernetes.io/docs/concepts/services-networking/network-policies/
kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-startup-probes/
kubernetes.io/docs/concepts/configuration/secret/
kubernetes.io/docs/concepts/storage/persistent-volumes/

The kubectl cheatsheet page is particularly valuable. It contains ready-to-copy command templates for the most common operations. Getting to this page should be a reflex.

Copy YAML Snippets, Don’t Memorize Them

The documentation contains complete, correct YAML examples for every resource type. A readiness probe example in the docs is syntactically perfect — copy it, paste it into your terminal, and modify the values. This is faster and more reliable than typing probe YAML from memory.

Copy-Paste in the Exam Environment

Copy-paste behavior in the PSI browser is different from your desktop and it trips people up. Here are the mechanics:

Action	How To
Copy from docs tab	Select text → Ctrl+C (works normally)
Paste into terminal	Ctrl+Shift+V or right-click → Paste
Copy from terminal	Select text → Ctrl+Shift+C or right-click → Copy
Copy within terminal	Select text with mouse, middle-click to paste (if supported)

The critical gotcha: Ctrl+V does not paste into the terminal. It sends a control character. You must use Ctrl+Shift+V. Practice this until it’s automatic. Fumbling with copy-paste under exam pressure wastes more time than you’d expect.

Another useful technique: if you need to reproduce a command you already ran, use the up arrow key to scroll through your terminal history, or use Ctrl+R to reverse-search your command history. Both are faster than retyping.

Using the Built-In Notepad

The exam interface includes a notepad widget. It’s basic — plain text, no formatting — but useful for jotting down:

• Task numbers you want to return to
• Resource names from earlier tasks that later tasks reference
• Quick notes like “Task 12: needs PVC from Task 9”

Don’t over-use it. Writing detailed notes costs time. Short references are enough.

Putting It All Together: Your Exam Day Checklist

Before you start the exam:

• Ensure your room is clean, desk is clear, one monitor connected
• Have your government-issued ID ready
• Close all applications except the PSI browser
• Test your webcam and microphone
• Use the bathroom — you can’t leave during the exam without forfeiting time

In the first 2 minutes of the exam:

• Set up your shell environment (aliases, bash completion — covered in CH1-S2)
• Open the kubernetes.io/docs cheatsheet in your allowed browser tab
• Take a breath. You’ve prepared for this.

Then execute your chosen strategy — sequential with time-boxing, or quick-wins-first — and trust your preparation. You know the format. You know the scoring. Now it’s about execution.