Time Management and Exam Strategy

Knowing Kubernetes is necessary to pass the CKAD exam. It is not sufficient. Candidates who understand every concept in this book still fail because they run out of time, solve tasks in the wrong namespace, or spend 15 minutes on a 4% problem while a 7% problem sits unanswered.

This section provides a strategic layer on top of your technical knowledge.

The Exam Structure

The CKAD exam has the following parameters:

• Duration: 2 hours (120 minutes)
• Tasks: 15–20 (the exact count varies per exam session)
• Environment: Remote desktop via PSI Secure Browser, single terminal, one browser tab for kubernetes.io/docs
• Scoring: Each task has a percentage weight (typically 4% or 7%), totaling 100%
• Passing score: 66%
• Allowed resources: kubernetes.io/docs, kubernetes.io/blog, and the official kubectl cheat sheet

Tasks are not presented in order of difficulty. A 7% multi-container Pod task might appear first, followed by a 4% label-a-Pod task. The exam does not penalize you for solving tasks out of order.

The Three-Pass Strategy

Do not solve tasks sequentially from first to last. Use a three-pass approach:

First Pass: Easy Tasks (2–3 Minutes Each)

Scan all tasks. Identify those you can solve in under 3 minutes with a single imperative command or minimal YAML editing. These typically include:

• Create a Pod with specific labels and image
• Create a ConfigMap from literal values
• Expose a Deployment as a Service
• Create a Secret and reference it in a Pod
• Scale a Deployment
• Create a namespace

These tasks are often worth 4%, but they are guaranteed points. Completing eight 4% tasks in 20 minutes gives you 32% — nearly half the passing score.

Why this works: Easy tasks warm up your hands and build confidence. They also reveal the cluster state — which namespaces exist, which Deployments are running, what context names look like. This information helps with harder tasks later.

Second Pass: Medium Tasks (5–7 Minutes Each)

Return to tasks that require YAML editing beyond what imperative commands provide. These include:

• Create a Deployment with resource limits and probes
• Create a CronJob with specific concurrencyPolicy and deadline settings
• Create a PersistentVolumeClaim and mount it in a Pod
• Configure a multi-container Pod with shared volumes
• Create a Job with specific completion and parallelism settings
• Install or upgrade a Helm release with custom values

For each medium task, use the generate-edit-apply workflow from Section 1:

1. Generate YAML imperatively
2. Edit in vim to add required fields
3. Apply
4. Verify

If a medium task takes longer than 7 minutes, flag it and move on. You can return in the third pass.

Third Pass: Hard Tasks (8–12 Minutes Each)

These are the tasks where you earn or lose the exam:

• NetworkPolicy with specific ingress/egress rules
• Debugging a broken Pod or Deployment (multiple failure causes)
• Ingress configuration with path-based routing and TLS
• Complex multi-step tasks (create resources, verify behavior, fix issues)

Hard tasks require careful reading, multiple kubectl commands, and precise YAML. They are worth 7% each, and skipping two of them is acceptable if the time would be better spent verifying your earlier answers.

Time Budget

A concrete allocation for a 16-task exam:

Pass	Tasks	Time per Task	Total Time	Cumulative
First	6	2.5 min	15 min	15 min
Second	6	6 min	36 min	51 min
Third	4	10 min	40 min	91 min
Review	—	—	29 min	120 min

The review period is not optional. Use it to:

• Re-read each task’s requirements and verify your resource matches
• Check that resources are in the correct namespace
• Run k get commands to confirm Pods are Running, Services have endpoints, and Jobs have completed

Reading Tasks: What to Look For

Every exam task contains critical metadata that you must extract before solving:

Context Name

Most tasks begin with:

Context: kubectl config use-context k8s-cluster-1

Copy and paste this command into your terminal. Do not retype it. Mistyping a context name means you solve the task in the wrong cluster, and you score zero.

Namespace

Tasks specify a namespace in one of two ways:

Create the Pod in namespace production

or

Use the namespace web-apps for all resources

Immediately after switching context, run:

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

This prevents you from accidentally creating resources in the default namespace.

Resource Names

Tasks specify exact names for resources:

Create a Deployment named api-server

Use that exact name. Not api, not apiserver, not api-Server. The grading script checks resource names exactly.

Specific Fields

Look for precise requirements buried in the task text:

The container should have a memory request of 64Mi and a CPU limit of 250m

Set the restart policy to Never

The CronJob should retain the last 3 successful job runs

Each of these maps to a specific YAML field. Missing one means partial or zero credit for the task.

Using the Official Documentation

You have access to kubernetes.io/docs during the exam. This is a powerful resource, but only if you know where to find what you need.

Key Pages to Navigate Quickly

Know the path to these pages before exam day:

• kubectl Cheat Sheet — kubernetes.io/docs/reference/kubectl/cheatsheet/ — Contains the alias setup, imperative commands, and common operations.
• Pods — kubernetes.io/docs/concepts/workloads/pods/ — Pod spec reference, init containers, lifecycle.
• Deployments — kubernetes.io/docs/concepts/workloads/controllers/deployment/ — Rolling update strategy, rollback.
• Services — kubernetes.io/docs/concepts/services-networking/service/ — ClusterIP, NodePort, selectors.
• ConfigMaps — kubernetes.io/docs/concepts/configuration/configmap/ — Mounting as volumes vs environment variables.
• Secrets — kubernetes.io/docs/concepts/configuration/secret/ — Types, usage patterns.
• PersistentVolumeClaims — kubernetes.io/docs/concepts/storage/persistent-volumes/ — PVC spec, access modes.
• NetworkPolicies — kubernetes.io/docs/concepts/services-networking/network-policies/ — Ingress/egress rules, pod/namespace selectors.
• Ingress — kubernetes.io/docs/concepts/services-networking/ingress/ — Path-based routing, TLS.
• Jobs and CronJobs — kubernetes.io/docs/concepts/workloads/controllers/job/ — Completions, parallelism, backoff.
• Helm — kubernetes.io/docs/ links to the Helm documentation at helm.sh/docs — but verify whether Helm docs are accessible in your exam session.

The Copy-Paste Pattern

The documentation contains complete YAML examples. When a task requires a NetworkPolicy and you cannot remember the exact syntax, navigate to the NetworkPolicy page, find the example YAML, copy it, paste it into your terminal, and edit it to match the task requirements.

This is faster than writing YAML from scratch and eliminates syntax errors. The exam allows and encourages using the documentation this way.

Technique: Use the browser’s search function (Ctrl+F) on documentation pages. Searching for networkpolicy on the Services and Networking concepts page takes you directly to the relevant section.

Do Not Browse — Search

Do not browse the documentation hierarchy. Navigate directly using the search bar at kubernetes.io/docs. Type the resource type you need, click the first relevant result, and find the YAML example. The entire process should take under 30 seconds.

Common Traps and How to Avoid Them

Trap 1: Wrong Namespace

What happens: You create a Pod in the default namespace instead of the production namespace specified in the task. The grading script checks production and finds nothing. Score: 0.

Prevention: Run kubectl config set-context --current --namespace=<ns> at the start of every task. Always verify after creation: k get pod -n <ns>.

Trap 2: Wrong Context

What happens: You solve a task in the wrong cluster. The resource exists on k8s-cluster-1 but the task required k8s-cluster-2. Score: 0.

Prevention: Copy and paste the kubectl config use-context command from the task. Never type context names manually.

Trap 3: Unsaved File

What happens: You edit a YAML file in vim, apply it, and the resource is created — but you forgot to save the file (:w) before applying. The applied version is the old version, not your edited version.

Prevention: In vim, use :wq to save and quit, then apply. Alternatively, use :w to save without quitting, switch to another terminal pane, and apply. Develop the habit: edit, save, apply, verify.

Trap 4: Indentation Errors in YAML

What happens: A field is indented 3 spaces instead of 2, or a list item uses a tab character. kubectl apply fails with a parse error. You spend 5 minutes debugging whitespace.

Prevention: Configure .vimrc as described in Section 1. Use kubectl apply --dry-run=client -f file.yaml to validate YAML before applying. The --dry-run=client flag catches syntax errors without creating resources.

Trap 5: Forgetting to Verify

What happens: You create a Deployment and move to the next task. Ten minutes later, you realize the Deployment’s Pods are in CrashLoopBackOff because you specified the wrong image tag. By then, you have lost time context-switching back.

Prevention: After every kubectl apply, run a verification command:

k get pods                    # Check status is Running
k describe pod <name>         # Check events for errors
k logs <pod-name>             # Check container logs

This takes 15 seconds and catches errors immediately.

Trap 6: Overthinking

What happens: A task asks you to create a Pod with a specific label. You spend 3 minutes considering whether you also need a Service, a Deployment, or a ReplicaSet. The task asked for a Pod. Create a Pod.

Prevention: Answer exactly what the task asks. Do not add resources, fields, or configurations that are not explicitly requested. The grading script checks for specific resources with specific configurations — extra resources do not earn extra points.

Pre-Exam Checklist

Complete these actions before exam day:

• Practice the shell setup — Type the alias, completion, and .vimrc block from memory in under 30 seconds.
• Memorize imperative commands — k run, k create deployment, k expose, k create configmap, k create secret generic, k create job, k create cronjob. Know the flags for each.
• Memorize short names — po, deploy, svc, cm, pvc, ns, ing, netpol, cj, sa.
• Practice the copy-paste workflow — Navigate to kubernetes.io/docs, find a NetworkPolicy example, copy it, paste it into a terminal, edit it, and apply it. Time yourself — it should take under 60 seconds.
• Take at least two mock exams — Chapters 26–27 provide a full mock exam. Complete it under timed conditions.
• Practice context switching — Set up a multi-context kubeconfig and switch between contexts and namespaces until it is automatic.
• Review the exam environment — The PSI Secure Browser has specific requirements (webcam, clean desk, ID). Review these requirements at training.linuxfoundation.org before exam day.
• Sleep well — Fatigue causes namespace mistakes, YAML typos, and poor time decisions. A rested 85% score beats a tired 60%.

Mental Model: Task Categories

Every CKAD task falls into one of these categories. Knowing the category tells you the expected time and approach:

Create (2–5 minutes)

Create a resource from scratch. Use imperative generation, edit if needed, apply.

Configure (4–7 minutes)

Modify an existing resource or create one with specific configuration (probes, volumes, env vars, tolerations). Generate scaffold, add configuration, apply.

Debug (5–10 minutes)

A resource exists but is broken. Use k describe, k logs, and k get events to identify the issue. Fix the manifest and reapply, or use k edit for in-place fixes.

Multi-Step (7–12 minutes)

Create multiple resources that interact (Pod + Service + Ingress, or Deployment + PVC + ConfigMap). Plan the dependency order, create each resource, verify interactions.

Map each task to its category during your first scan, and you will know immediately how much time to allocate.

The Final 10 Minutes

When 10 minutes remain:

1. Stop working on new tasks. Any task you have not started will take longer than 10 minutes. The math does not work.

2. Review completed tasks. Go back to each task and verify:

   • Is the resource in the correct namespace?
   • Is the resource in the correct context/cluster?
   • Does the resource name match exactly?
   • Are all required fields present?

3. Fix quick issues. If a Pod is in ImagePullBackOff because of a typo in the image name, fix it. If a Service targets the wrong port, update it. These are 30-second fixes that rescue 4–7% of your score.

4. Do not attempt partial solutions. Creating half of a NetworkPolicy and applying it will not earn partial credit if the required rules are missing. Either complete the task or move to the next review item.

The candidates who pass are not the ones who attempt every task. They are the ones who get maximum credit on the tasks they complete. Speed is the tool. Accuracy is the goal.