CKAD course and practice exam: Certified Kubernetes Application Developer

This CKAD course has 35 video lessons and 83 graded labs, and its CKAD practice exam follows the official exam objectives: a 20-question sampler free with an account, the full question bank and timed mock exams with Pro.

Design, build and troubleshoot applications on Kubernetes

Prepares you for the hands-on CKAD exam: pods, deployments, configuration, services, observability and debugging, practised against the clock.

Intermediate · 3 hours · 35 lessons · 91 labs

CKAD exam guide

The CKAD exam (Certified Kubernetes Application Developer, by CNCF / The Linux Foundation): 2 hours; questions: ~15–20 performance-based tasks; pass mark: 66%; cost: USD 445 (includes one free retake).

How do I prepare for the CKAD exam?

Study the open source CNCF curriculum domain by domain, deploying, configuring and debugging applications on a cluster of your own, starting with application environment, configuration and security, the heaviest domain. Registration includes two attempts at an exam simulator provided by Killer.sh (not with CKAD-SINGLE); keep them for a timing check near the end. Linux Foundation, CKA, CKAD and CKS FAQ

Is the CKAD exam difficult?

It is demanding because it is hands-on and timed: 15 to 20 performance-based tasks in 2 hours, solved at a command line, with a pass mark of 66%. Speed at the terminal matters as much as knowing the concepts. Linux Foundation, important tips for the CKA and CKAD

How to prepare for the CKA and CKAD exams, with labs

  • Format: Performance-based: tasks solved in a live Kubernetes environment from the command line
  • Duration: 2 hours
  • Questions: ~15–20 performance-based tasks
  • Pass mark: 66%
  • Cost: USD 445 (includes one free retake)
  • Valid for: 2 years
  • Delivery: Online, proctored (PSI)
  • Prerequisites: None

Exam domains and weights

  • Application Design and Build: 20%
  • Application Deployment: 20%
  • Application Observability and Maintenance: 15%
  • Application Environment, Configuration and Security: 25%
  • Services and Networking: 20%

A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.

10 CKAD sample questions with answers: free to read, no account needed.

Common questions

How long is the CKAD exam?

The CKAD exam lasts 2 hours.

How many questions are on the CKAD exam?

~15–20 performance-based tasks.

What is the CKAD passing score?

The pass mark is 66%.

How much does the CKAD exam cost?

USD 445 (includes one free retake).

Is there a free CKAD practice test?

Yes. A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.

Source: CKAD exam page (Linux Foundation Training) (CNCF / The Linux Foundation), checked 2026-10-01.

Related guides

Who it is for

Intermediate level.

For developers preparing for the hands-on CKAD exam who build, deploy and debug their own applications on Kubernetes.

What you don't need yet:

What helps:

No formal prerequisites. The courses under "Take first" cover what helps.

Take first:

Take next:

Learning paths:

Nobody needs to know everything before they start. Each course builds on the one before, so a learning path takes you there step by step.

What this exam proves, and what it doesn't

The CKAD is a performance-based exam: you build and fix applications from the command line on a live Kubernetes cluster, so passing shows you can do the tasks. It doesn't replace running apps in production; our graded labs use a simulated cluster, not a real one.

Exam objectives this course teaches

Certified Kubernetes Application Developer (CKAD)

Labs

91 labs, 83 of them graded: you write the code, it runs, and graded labs check the result. The outline lists each lesson's labs.

What is free

Start free: First module free with an account. Pro: Every course, lab, handbook, practice exam and certificate.

Course outline

Start Here

  1. Running, And Still Down (2 labs): You can tell Running from Ready, trace a refused request through probe, endpoints and Service, fix a readiness probe with one patch, and read how this course grades labs on cluster state.
  2. Two Hours, Twenty Tasks: Exam Strategy (2 labs): You can describe the exam environment and its allowed resources, rank tasks by marks per minute, and run the generate, edit, apply and verify loop in the namespace a task names.

Kubernetes Exam Core: Speed Kit

  1. Generators Write The YAML, You Decide (2 labs): You can create namespaces, deployments, services, config maps, service accounts, roles and bindings in one command each, and turn a client dry run into a manifest you edit and apply.
  2. Contexts, Namespaces And One-Line Answers (1 lab): You can read a kubeconfig's contexts, pin a namespace, and pull exact answers out of the cluster with JSONPath, custom columns and sort by, then store them where a grader can read them.

Application Design And Build

  1. Container Images The Exam Way (3 labs): You can fix a Dockerfile with pinned bases, a multi-stage build, a non-root user and an exec-form command, name the build, tag and save commands a task needs, and roll a Deployment onto a new image.
  2. Choose The Right Workload Resource (4 labs): You can choose between a Deployment, StatefulSet, DaemonSet, Job and CronJob with four questions, write a Job with completions, parallelism and backoffLimit, and read a DaemonSet manifest field by field.
  3. Sidecars And Init Containers (3 labs): You can order init and app containers, share a volume between a sidecar and its app, diagnose a pod stuck in Init:Error, and declare a native sidecar with restartPolicy: Always.
  4. Persistent And Ephemeral Volumes (2 labs): You can choose emptyDir, configMap, secret, projected or a claim by the data's lifetime, explain a Pending claim under WaitForFirstConsumer, and mount a claim and a config file with the right paths and readOnly.
  5. Jobs And CronJobs That Behave (2 labs): You can write a CronJob schedule from words, choose Allow, Forbid or Replace for overlapping runs, set history limits and deadlines, and test a CronJob at once with create job --from.
  6. Design And Build: Timed Drill And Checkpoint (4 labs): You can complete four design and build tasks, a Job, a multi-container pod, a CronJob and persistent storage, inside an exam time budget, and score yourself the way the exam does.

Application Deployment

  1. Rolling Updates And Rollbacks (2 labs): You can predict the pods during a rolling update from maxSurge and maxUnavailable, choose budgets for a stated requirement, read rollout history and roll back a broken release to a chosen revision.
  2. Blue/Green With Labels And A Service (2 labs): You can run blue and green Deployments side by side, switch all traffic with one Service selector patch, switch back and park the old colour, and pick rolling, Recreate or blue/green from a stated requirement.
  3. Canary Releases From Replica Counts (2 labs): You can build a canary from two Deployments and one Service, compute the replica counts for a traffic share, keep the selectors from overlapping, and promote or abandon the canary.
  4. Helm: Install, Upgrade And Roll Back (3 labs): You can predict the values a release gets from defaults, files and --set, install a chart into a namespace, find its settings with show values, and upgrade, inspect and roll back a release.
  5. Kustomize Bases, Overlays And Patches (3 labs): You can build a base and an overlay with kubectl kustomize, change namespace, names, images and replicas, add a patch and a generator, explain the generated hash suffix, and deploy with apply -k.
  6. Deployment: Timed Drill And Checkpoint (4 labs): You can complete a Kustomize overlay, a budgeted rolling update with a recorded cause, a blue/green switch and a canary inside an exam time budget, and check your deployment knowledge in an eight-question checkpoint.

Application Observability And Maintenance

  1. API Deprecations And Migrations (2 labs): You can explain how an API version is deprecated and removed, find the versions a cluster serves with api-resources and explain, and migrate a removed CronJob and Ingress to their stable versions.
  2. Probes And Health Checks (2 labs): You can say what a failing liveness, readiness or startup probe does, diagnose a probe-driven restart loop from describe and events, and write all three probes with timing that matches the application.
  3. Monitoring With The Built-in CLI (2 labs): You can triage a namespace with get -o wide, sorted events and describe, map each broken status to its cause, fix image and resource faults from the command line, and read kubectl top against requests.
  4. Container Logs (2 labs): You can read the right container and the right run with -c and --previous, limit output with --tail and --since, read logs through a Deployment or Job, and record a log line in the cluster for an exam task.
  5. Debugging Applications In Kubernetes (2 labs): You can test a request hop by hop with exec, nslookup and wget, find a wrong targetPort from endpoints, fix it with a named port, change an environment variable with set env, and choose debug or port-forward when there is no shell.
  6. Observability: Timed Drill And Checkpoint (4 labs): You can migrate a removed API, add probes to a live Deployment, record a crashed container's error and fix a Service selector, each inside an exam time budget, and check the module in an eight-question checkpoint.

Application Environment, Configuration And Security

  1. ConfigMaps And Secrets (2 labs): You can create ConfigMaps and Secrets with generators, consume them as single variables, all variables or files, explain why base64 is not protection, and fix a pod stuck in CreateContainerConfigError.
  2. Requests, Limits And Quotas (3 labs): You can set requests and limits, predict scheduling, throttling and OOMKilled outcomes, name a pod's QoS class, and explain how a ResourceQuota and LimitRange accept, default or reject pods at admission.
  3. ServiceAccounts And Tokens (2 labs): You can give a workload its own service account, bind it a least-privilege role, set it in the pod template, test it with impersonation, turn off token mounting, and issue a short-lived token on demand.
  4. Authentication, Authorisation And Admission (2 labs): You can place a refusal at authentication, authorisation or admission, grant least privilege with Roles, ClusterRoles and bindings to users, groups and service accounts, and set Pod Security levels per namespace.
  5. SecurityContexts And Capabilities (2 labs): You can set pod- and container-level security contexts, predict which level wins, harden a container to the restricted standard with non-root, no escalation, dropped capabilities and seccomp, and patch it without leaving old capabilities behind.
  6. Custom Resources And Operators (4 labs): You can explain how a CRD, a custom resource and an operator fit together, discover a custom kind with get crd, api-resources and explain, read schema validation errors and create a valid instance.
  7. Configuration And Security: Timed Drill And Checkpoint (4 labs): You can wire ConfigMaps and Secrets into a Deployment, fix a resource request, give a workload a least-privilege identity and harden a pod to restricted, each inside an exam time budget, and pass an eight-question checkpoint on the domain.

Services And Networking

  1. Services And Empty Endpoints (2 labs): You can expose a Deployment as ClusterIP and NodePort Services, reach it across namespaces by DNS name, choose a Service type, and name the cause of an empty or wrong endpoint list from one read.
  2. NetworkPolicy Truth Tables: One Dash Decides (2 labs): You can predict, source by source, what a NetworkPolicy lets in, tell an AND peer from an OR peer by its dashes, and write a policy that admits exactly the pods and namespaces a task names.
  3. Ingress: Hosts, Paths And The Class That Serves Them (1 lab): You can write an Ingress in one command with hosts, Prefix and Exact paths, a class and TLS, read which backend a URL will reach, and tell a routing mistake from a missing controller.
  4. Services And Networking: Timed Drill And Checkpoint (4 labs): You can expose a workload on a named port, write a NetworkPolicy that admits exactly the clients a task names, route a host to two Services over TLS with an Ingress and repair a path with two faults, each inside an exam time budget, and pass an eight-question checkpoint on the domain.

Mock Exam And Review

  1. Mock Exam: Sixteen Tasks Against The Clock (6 labs): You can sit a timed, sixteen-task mock exam that covers all five CKAD domains in the weights of the curriculum, triage tasks against a pass mark, and turn every failed check into a specific lesson to redo.
  2. Final Review: Where Your Marks Are At Risk (2 labs): You can turn a mock exam result into a final-week study plan weighted by marks at risk, repair a release broken five ways across the CKAD domains, and walk into the exam knowing its environment, tools and allowed documentation.

Certification courses