CKAD Exam Guide 2026: Complete Preparation Guide

The Certified Kubernetes Application Developer (CKAD) certification has become the gold standard for developers working with Kubernetes. Whether you’re looking to advance your career, validate your skills, or simply deepen your understanding of container orchestration, this comprehensive guide will walk you through everything you need to know about the CKAD exam in 2026.

What is the CKAD Certification?

The CKAD is a performance-based exam administered by the Cloud Native Computing Foundation (CNCF). Unlike traditional multiple-choice exams, CKAD tests your practical ability to design, build, configure, and expose small to medium-sized applications using Kubernetes.

The certification validates that a developer can:

• Design and build Kubernetes applications
• Develop cloud-native applications
• Containerize applications
• Deploy applications using Kubernetes
• Configure and troubleshoot Kubernetes applications
• Understand networking and security in Kubernetes

This certification is particularly valuable for developers who want to demonstrate their hands-on proficiency with Kubernetes in production environments.

CKAD Exam Format: What to Expect

Test Duration and Environment

The CKAD exam is a practical, hands-on test lasting 2 hours. You’ll be working directly in a live Kubernetes environment, solving real-world problems using kubectl commands, YAML files, and the Kubernetes API.

The exam is proctored remotely, and you’ll need:

• A stable internet connection (minimum 5 Mbps download, 1 Mbps upload)
• A quiet, private room
• A webcam and microphone
• Valid government-issued ID for verification
• A modern web browser

Exam Format Overview

Rather than selecting answers from multiple choice options, you’ll:

1. Read problem statements describing tasks you need to complete
2. Connect to a pre-configured Kubernetes cluster via the terminal
3. Use kubectl commands and edit YAML files to solve each problem
4. Verify your solutions work as expected

This format ensures you’re testing real-world skills that can be applied immediately in production environments.

Types of Tasks

The exam includes various task types:

• Imperative commands: Creating resources quickly using kubectl flags
• Declarative YAML files: Writing and applying manifest files
• Troubleshooting: Diagnosing and fixing broken deployments and configurations
• Configuration management: Working with ConfigMaps, Secrets, and environment variables
• Networking: Exposing applications via Services and Ingress
• Security: Implementing RBAC, Pod Security Policies, and network policies

CKAD Exam Domains and Weightage (2026)

The CKAD exam covers five major domains, each with specific weightage:

Domain	Weightage	Key Topics
Application Design and Build	20%	Docker images, container basics, multi-container pods, multi-stage builds
Application Deployment	20%	Deployments, StatefulSets, DaemonSets, Rolling updates, Rollback strategies
Application Observability and Maintenance	15%	Logging, monitoring, debugging, troubleshooting
Application Environment, Config & Security	25%	ConfigMaps, Secrets, SecurityContext, RBAC, Network policies
Services & Networking	20%	Services (ClusterIP, NodePort, LoadBalancer), Ingress, DNS, Service discovery

Let’s dive deeper into each domain:

1. Application Design and Build (20%)

This domain focuses on container fundamentals and building cloud-native applications.

Key Topics:

• Understanding Docker and OCI container standards
• Creating and optimizing Docker images
• Working with image registries (Docker Hub, private registries)
• Building multi-stage Docker images for smaller image sizes
• Understanding multi-container pod patterns (sidecar, init containers, ambassador)

Important kubectl Commands:

# Create a simple deployment with a specific image
kubectl create deployment nginx --image=nginx:latest

# Create a pod with multiple containers
kubectl run multi-container --image=image1 -i -t

# Check image details in a pod
kubectl describe pod <pod-name>

2. Application Deployment (20%)

Deploying applications reliably and managing their lifecycle in Kubernetes.

Key Topics:

• Creating and managing Deployments
• Understanding ReplicaSets and their role
• StatefulSets for stateful applications
• DaemonSets for node-level utilities
• Rolling updates and rollback strategies
• Deployment strategies (blue-green, canary)

Important kubectl Commands:

# Create a deployment
kubectl create deployment my-app --image=myapp:v1 --replicas=3

# Scale a deployment
kubectl scale deployment my-app --replicas=5

# Check rollout status
kubectl rollout status deployment/my-app

# Undo a deployment update
kubectl rollout undo deployment/my-app

3. Application Observability and Maintenance (15%)

Monitoring, logging, and troubleshooting applications in production.

Key Topics:

• Accessing logs (pod logs, container logs, previous logs)
• Monitoring resource usage and performance
• Debugging application issues
• Health checks (liveness probes, readiness probes, startup probes)
• Collecting metrics and understanding Prometheus basics

Important kubectl Commands:

# View pod logs
kubectl logs <pod-name>

# View logs from a specific container in multi-container pod
kubectl logs <pod-name> -c <container-name>

# View previous logs (useful for crashed containers)
kubectl logs <pod-name> --previous

# Monitor pod resource usage in real-time
kubectl top pod

# Describe a pod to see events and status
kubectl describe pod <pod-name>

4. Application Environment, Config & Security (25%)

The largest domain, covering configuration management and security best practices.

Key Topics:

• ConfigMaps for application configuration
• Secrets for sensitive data (passwords, API keys, tokens)
• Environment variables and volume mounts
• SecurityContext for pod and container security
• Service Accounts and Role-Based Access Control (RBAC)
• Network Policies for application isolation
• Pod Security Policies and Pod Security Standards

Important kubectl Commands:

# Create a ConfigMap from literals
kubectl create configmap app-config --from-literal=key=value

# Create a Secret for storing sensitive data
kubectl create secret generic db-secret --from-literal=password=mysecret

# Create a ServiceAccount
kubectl create serviceaccount my-app-sa

# Create a ClusterRole
kubectl create clusterrole pod-reader --verb=get,list --resource=pods

# Bind a role to a service account
kubectl create clusterrolebinding pod-reader-binding --clusterrole=pod-reader --serviceaccount=default:my-app-sa

5. Services & Networking (20%)

Exposing applications and managing network communication.

Key Topics:

• Service types (ClusterIP, NodePort, LoadBalancer)
• Ingress resources for HTTP(S) routing
• Network policies for traffic control
• DNS and service discovery
• Exposing applications on different ports

Important kubectl Commands:

# Expose a deployment as a ClusterIP service
kubectl expose deployment my-app --port=8080 --target-port=8080

# Expose as a NodePort service
kubectl expose deployment my-app --type=NodePort --port=8080

# Create an Ingress resource
kubectl create ingress my-ingress --rule="example.com/*=my-app:8080"

# Check service endpoints
kubectl get endpoints my-app

Passing Score and Exam Scoring

To pass the CKAD exam, you need to score 66% or higher. This means out of 100 points, you need at least 66 points to pass.

Scoring Details:

• Each question is worth a certain number of points based on difficulty and implementation effort
• Partial credit is given for partially correct solutions
• You don’t need to solve every question perfectly to pass
• Solutions are evaluated automatically against defined criteria

The grading is binary for each task—your solution either meets the requirements or it doesn’t. There’s no partial scoring within individual questions.

Exam Cost and Registration

CKAD Exam Price (2026)

The CKAD certification exam costs $395 USD (or local currency equivalent). This is the standard exam price and includes:

• One exam attempt
• Two hours of exam time
• Remote proctoring
• Official CKAD certificate (if you pass)
• One free retake (within one year of purchase)

How to Register

1. Visit the CNCF Portal: Go to Linux Foundation Training & Certification
2. Create an Account: Register or log in with your Linux Foundation ID
3. Search for CKAD: Find “Certified Kubernetes Application Developer (CKAD)” exam
4. Purchase: Add to cart and complete payment
5. Schedule: Book your exam time slot within available windows
6. Prepare: Study using official resources and practice exams
7. Take the Exam: Connect to the proctored environment at your scheduled time

Important Registration Details

• You’ll need a valid government-issued ID (passport, driver’s license, etc.)
• The exam is available 24/7 in most time zones
• You should register at least 2-3 weeks before your desired exam date
• If you need to reschedule, most changes can be made free of charge up to 24 hours before the exam

What to Expect During the Exam

The Exam Environment

You’ll be working in a browser-based terminal with access to:

• A pre-configured Kubernetes cluster (typically a three-node cluster)
• The ability to create, edit, and delete resources
• Documentation and kubectl references (you can use the official Kubernetes documentation during the exam)
• Built-in text editor (similar to nano or vim)
• Multiple clusters in some questions (requiring context switching)

Important Exam Rules

1. Documentation Access: You can reference the official Kubernetes documentation (kubernetes.io)
2. Single Tab Policy: You can have two browser tabs open—one for the exam and one for documentation
3. Time Management: You have exactly 2 hours; the timer is visible throughout the exam
4. No External Help: You cannot use external tools, AI assistants, or seek help from others
5. Private Environment: You must be in a quiet, private room alone
6. No Copy-Paste from External Sources: You can copy-paste within the exam environment but not from external sources

Common Exam Scenarios

The exam typically includes 15-20 questions covering:

• Creating and managing deployments with specific configurations
• Configuring applications with ConfigMaps and Secrets
• Setting up Services and Ingress for application exposure
• Implementing security controls and RBAC
• Troubleshooting failing applications
• Managing application updates and rollbacks
• Working with persistent storage and StatefulSets

Key Differences: CKAD vs CKA

While CKAD focuses on application development and deployment, the Certified Kubernetes Administrator (CKA) exam focuses on infrastructure and administration. Here’s a quick comparison:

Aspect	CKAD	CKA
Focus	Application deployment and use	Infrastructure administration
Audience	Developers	System administrators
Exam Cost	$395	$395
Duration	2 hours	3 hours
Passing Score	66%	66%
Key Topics	Deployments, ConfigMaps, Services	Cluster setup, ETCD, networking

For more detailed comparison, check our CKAD vs CKA guide.

How Long Should You Study?

Most developers require 4-8 weeks of dedicated study to prepare for the CKAD exam. This depends on:

• Your existing Kubernetes experience
• Your Docker and containerization knowledge
• Your preferred learning style
• The time you can dedicate daily

A structured approach works best. We recommend starting with our 4-week CKAD study plan which breaks down exactly what to study each week.

Best Resources for CKAD Preparation

Official Resources

• Kubernetes Documentation: kubernetes.io (accessible during exam)
• CNCF Training: Official courses from Cloud Native Computing Foundation
• Free Practice Resources: Official CNCF sandbox environments and community resources

Practice Platforms

• Sailor.sh: Comprehensive CKAD mock exams with detailed explanations
• Kubernetes Hands-on Labs: Interactive practice environments
• Community Learning Groups: Peer-led study and practice sessions

Study Materials

• Official Kubernetes Docs: Start with tutorials and concepts
• hands-on Labs: Practical, real-world scenarios
• Mock Exams: Essential for exam readiness

For a comprehensive comparison of practice platforms, see our best CKAD practice tests guide.

Pro Tips for CKAD Success

1. Practice imperative commands: Get comfortable with kubectl shortcuts and flags
2. Master vim/nano: You’ll be editing YAML in the exam; speed matters
3. Know common kubectl aliases: Create shortcuts for frequently used commands
4. Practice under time pressure: Take full-length practice exams with timer
5. Read questions carefully: Understand exactly what’s being asked before coding
6. Validate your solutions: Always verify that your solutions actually work
7. Learn to debug quickly: Know how to troubleshoot issues efficiently

Getting Started with Your CKAD Journey

Ready to start your CKAD preparation? Here’s your action plan:

1. Assess Your Current Level: Take a practice exam to understand your baseline
2. Follow a Structured Plan: Use our CKAD study plan as your roadmap
3. Study Daily: Dedicate 1-2 hours daily to learning and practice
4. Take Mock Exams: Use Sailor.sh for comprehensive practice exams
5. Review Weak Areas: Focus on domains where you’re scoring lower
6. Schedule Your Exam: Book your exam date after consistent 70%+ scores on practice tests
7. Stay Calm: Remember that 66% is passing; you don’t need perfection

The CKAD certification is within your reach with proper preparation and consistent practice. Start your journey today with Sailor.sh’s comprehensive CKAD mock exams.

FAQ

Q: What’s the difference between CKAD and CKA? A: CKAD focuses on application deployment and management, while CKA focuses on cluster administration and infrastructure. See our detailed comparison for more information.

Q: Can I use any resources during the exam? A: Yes, you can access kubernetes.io documentation and have one additional browser tab open. You cannot use external tools, AI assistants, or seek external help.

Q: How many questions are on the CKAD exam? A: The exam typically has 15-20 questions covering various Kubernetes concepts and practical scenarios.

Q: What if I fail the first attempt? A: You receive one free retake within one year of your exam purchase. After that, you can purchase additional retakes.

Q: Is CKAD worth getting? A: Yes, CKAD validates your practical Kubernetes skills and is highly valued by employers. It demonstrates you can design, build, and deploy Kubernetes applications in production.

Q: Do I need CKA before taking CKAD? A: No, there are no prerequisites. However, some background knowledge of Kubernetes concepts is helpful. You can take CKAD first as an application developer.

Q: How long is the CKAD certificate valid? A: The CKAD certification is valid for 3 years from the date you pass the exam.

Q: Can I retake the exam if I pass? A: No, once you pass, you receive your certificate. However, you can choose to pursue higher-level certifications like CKA or CKS.

Ready to begin your CKAD preparation? Start with Sailor.sh today for comprehensive mock exams and study materials tailored specifically for CKAD success.