CKA Study Plan: 30-Day Preparation Roadmap

The path to CKA certification doesn’t require years of study—it requires smart, focused preparation. This 30-day study plan is designed for professionals with foundational Kubernetes knowledge who are ready to ace the certification exam. We’ll break down each week with specific topics, daily tasks, and measurable milestones to keep you on track.

How to Use This Study Plan

This plan assumes you already have:

Basic understanding of Kubernetes concepts (Pods, Deployments, Services)
Comfortable working with command-line tools
Access to a lab environment to practice
1-2 hours daily for study and practice

If you’re new to Kubernetes, consider starting with fundamentals before beginning this 30-day plan. The plan is structured to balance theory and hands-on practice, with increasing difficulty as you progress.

Pre-Study Assessment (Days Before Day 1)

Before starting, evaluate your current knowledge level with these diagnostic tasks:

Diagnostic Test

Take a 50-question practice exam to identify weak areas
Score where you’d realistically perform: Try our CKA mock exam
Note domains where you scored below 70%—these need extra attention

Environment Setup

Ensure you have a working Kubernetes cluster (minikube, kind, or cloud-based)
Install and configure kubectl
Bookmark the official Kubernetes documentation
Set up your study materials and notebooks

Schedule Planning

Block out 1-2 hours daily for study
Identify which topics need extra focus
Schedule practice sessions for high-weightage domains

Week 1: Kubernetes Fundamentals Review (Days 1-7)

Week 1 focuses on solidifying your foundational knowledge and setting up your lab environment properly.

Day 1-2: Cluster Architecture and Core Concepts

Study Topics:

Kubernetes architecture (control plane, worker nodes, etcd)
API server, controller manager, scheduler, kubelet
Container runtime and kube-proxy
Namespaces and resource quotas

Hands-On Tasks:

# Explore cluster information
kubectl cluster-info
kubectl get nodes
kubectl get componentstatuses
kubectl api-resources

Milestone: Understand how a Kubernetes cluster is structured and can explain each control plane component.

Day 3-4: Pod Fundamentals and Imperative Commands

Study Topics:

Pod lifecycle and states
Creating pods imperatively with kubectl run
Pod manifests and specifications
Multi-container pods and sidecar pattern

Hands-On Tasks:

# Create pods imperatively
kubectl run nginx --image=nginx --port=80
kubectl run debug-pod --image=busybox -it -- sh
kubectl create namespace practice
kubectl run test-pod --namespace=practice --image=alpine sleep 3600

Milestone: Able to create and manage pods efficiently using kubectl imperative commands.

Day 5-6: Deployments and ReplicaSets

Study Topics:

Deployment specification and replicas
Rolling updates and rollback strategy
Selectors and labels
Resource requests and limits

Hands-On Tasks:

# Create and manage deployments
kubectl create deployment web --image=nginx --replicas=3
kubectl set image deployment/web nginx=nginx:latest
kubectl rollout status deployment/web
kubectl rollout history deployment/web
kubectl rollout undo deployment/web

Milestone: Comfortable creating deployments and performing rolling updates/rollbacks.

Day 7: Services and Networking Basics

Study Topics:

Service types (ClusterIP, NodePort, LoadBalancer)
Endpoints and kube-proxy
DNS within the cluster
Service discovery

Hands-On Tasks:

# Expose deployments as services
kubectl expose deployment web --type=ClusterIP --port=80
kubectl expose deployment web --type=NodePort --port=80
kubectl get svc
kubectl get endpoints

Milestone: Can expose applications via Services and understand traffic routing.

Week 2: Advanced Workloads and Storage (Days 8-14)

Week 2 elevates your skills to more complex workload types and storage management.

Day 8-9: StatefulSets and DaemonSets

Study Topics:

StatefulSet ordering and persistence
DaemonSet use cases
Headless services for StatefulSets
Persistent identity and stable hostnames

Hands-On Tasks:

# Create a StatefulSet
kubectl create statefulset mysql --image=mysql --replicas=3
kubectl get pods -o wide
# Create a DaemonSet
kubectl create daemonset monitoring --image=prometheus

Milestone: Understand when to use StatefulSets vs Deployments and can implement both.

Day 10-11: Storage and Persistent Volumes

Study Topics:

PersistentVolume (PV) and PersistentVolumeClaim (PVC)
StorageClass and dynamic provisioning
Volume types (local, hostPath, emptyDir, nfs)
Access modes and reclaim policies

Hands-On Tasks:

# Create storage resources
kubectl apply -f - << EOF
apiVersion: v1
kind: PersistentVolume
metadata:
  name: pv-local
spec:
  capacity:
    storage: 10Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: /data
EOF

# Create a PVC
kubectl apply -f - << EOF
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: data-claim
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 5Gi
EOF

Milestone: Can create PVs, PVCs, and StorageClasses; understand provisioning workflow.

Day 12-13: ConfigMaps and Secrets

Study Topics:

ConfigMap creation and usage
Secret types and management
Mounting ConfigMaps and Secrets in pods
Environment variables and volume mounts

Hands-On Tasks:

# Create ConfigMaps
kubectl create configmap app-config --from-literal=DATABASE_URL=postgres://db:5432/app
kubectl create secret generic db-credentials --from-literal=username=admin --from-literal=password=secret

# Mount in pod
kubectl run app --image=myapp --env="CONFIG_PATH=/etc/config/app.conf"

Milestone: Can create and manage application configuration without hardcoding values.

Day 14: Review and Practice Tests

Activities:

Review week 2 topics
Take a 50-question practice exam focusing on workloads and storage
Identify remaining weak areas
Adjust study plan if needed

Milestone: Scoring 75%+ on practice exams for workload and storage domains.

Week 3: Security, Networking, and Cluster Management (Days 15-21)

Week 3 tackles the more complex security and cluster administration topics.

Day 15-16: RBAC and Authentication

Study Topics:

Role and ClusterRole definitions
RoleBinding and ClusterRoleBinding
ServiceAccounts and user authentication
Authorization modes

Hands-On Tasks:

# Create RBAC resources
kubectl create role developer --verb=get,list,watch --resource=pods,deployments
kubectl create rolebinding dev-binding --clusterrole=developer --serviceaccount=default:dev-user
kubectl auth can-i get pods --as=dev-user
kubectl create serviceaccount app-sa

Milestone: Can create RBAC policies and understand permission models.

Day 17-18: Network Policies

Study Topics:

NetworkPolicy specification
Ingress and egress rules
Label selectors for policies
Default deny and allow patterns

Hands-On Tasks:

# Create network policies
kubectl apply -f - << EOF
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: deny-all-ingress
spec:
  podSelector: {}
  policyTypes:
  - Ingress
EOF

# Allow specific traffic
kubectl apply -f - << EOF
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-frontend
spec:
  podSelector:
    matchLabels:
      tier: backend
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          tier: frontend
EOF

Milestone: Can design and implement network policies for security.

Day 19-20: Ingress and Advanced Networking

Study Topics:

Ingress resources and controllers
Ingress rules and TLS termination
Ingress controller deployment
Service mesh basics

Hands-On Tasks:

# Create Ingress resource
kubectl apply -f - << EOF
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: web-ingress
spec:
  rules:
  - host: example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: web
            port:
              number: 80
EOF

Milestone: Can expose applications via Ingress and manage external access.

Day 21: Cluster Administration

Study Topics:

Node management and cordoning
Cluster upgrades
etcd backup and restore
Cluster certificates

Hands-On Tasks:

# Manage nodes
kubectl cordon node-1
kubectl drain node-1 --ignore-daemonsets --delete-emptydir-data
kubectl uncordon node-1

# Check cluster certificates
kubectl get csr
kubectl certificate approve <csr-name>

Milestone: Understand cluster lifecycle management and maintenance procedures.

Week 4: Troubleshooting and Final Preparation (Days 22-30)

Week 4 focuses on troubleshooting skills and full-length practice exams.

Day 22-23: Logging and Debugging

Study Topics:

Application logging best practices
kubectl logs and log aggregation
Container and pod debugging
Events and status investigation

Hands-On Tasks:

# Debug applications
kubectl logs pod-name
kubectl logs pod-name -c container-name
kubectl describe pod pod-name
kubectl get events
kubectl debug pod-name -it --image=busybox

Milestone: Can quickly identify and troubleshoot application issues.

Day 24-25: Cluster Troubleshooting

Study Topics:

Control plane component issues
Node problems and status
Pod scheduling issues
Network connectivity problems

Hands-On Tasks:

# Check cluster health
kubectl get nodes
kubectl get componentstatuses
kubectl describe node node-name
kubectl top nodes
kubectl logs -n kube-system -l component=kubelet

Milestone: Can diagnose and resolve cluster-level issues.

Day 26-27: Full-Length Mock Exams

Activities:

Take two full 2-hour mock exams under exam conditions
Simulate actual exam environment (proctored, timed)
Review answers immediately after
Use Sailor.sh mock exams for realistic practice
Score goal: 75%+

Milestone: Consistently scoring above passing threshold in mock exams.

Day 28: Weak Area Review

Activities:

Review domains where you scored below 75%
Complete targeted practice questions
Do 10-15 practice questions on each weak domain
Study any unfamiliar kubectl commands

Milestone: Identify and address any remaining knowledge gaps.

Day 29: Exam Preparation and Strategy

Activities:

Review exam day logistics and requirements
Practice kubectl aliases and efficiency tricks
Set up your exam environment (desk, monitors, etc.)
Review the official Kubernetes documentation structure
Plan your question approach strategy

Key Strategies:

Spend 1-2 minutes reading each question thoroughly
Start with questions you’re most confident about
Mark difficult questions and return to them last
Keep your hands warm and type smoothly
Manage time to leave 10-15 minutes for review

Milestone: Feel confident and prepared for exam day.

Day 30: Final Review and Rest

Activities:

Light review of high-weightage domains only
Avoid learning new material—focus on confidence
Get good sleep tonight
Prepare your physical environment
Complete a final 30-minute practice quiz
Review your test-taking strategy

Milestone: Exam-ready with confidence and momentum.

Study Plan Timeline Overview

Week	Focus Area	Primary Domain	Goal
Week 1	Fundamentals	Workloads (15%)	Solid foundation
Week 2	Workloads & Storage	Storage (10%), Workloads (15%)	Advanced concepts
Week 3	Security & Networking	Cluster Architecture (25%), Services (20%)	Complex scenarios
Week 4	Troubleshooting & Review	Troubleshooting (30%)	Exam readiness

Daily Study Schedule Template

Here’s how to structure your daily study time:

Morning Session (45 minutes)

Review yesterday’s concepts (10 min)
Learn new material via video or documentation (20 min)
Read sample code or architecture diagrams (15 min)

Afternoon Session (45 minutes)

Hands-on lab practice of that day’s topic (30 min)
Complete practice questions on the topic (15 min)

Evening Session (Optional, 30 minutes)

Review difficult concepts
Complete the day’s practice exercises
Plan next day’s study

Recommended Resources

Official Resources:

Kubernetes official documentation
Linux Foundation CKA training course
Sample exam questions from CNCF

Mock Exam Platforms:

Sailor.sh CKA mock exams for realistic practice
Practice questions and detailed explanations

Community Resources:

Kubernetes Slack #cka channel
Linux Foundation forums
GitHub repos with curated CKA study guides

Key Study Tips for Success

1. Hands-On First Never just read about Kubernetes concepts. Always practice them in a real cluster. Theory without practice leads to exam failure.

2. Use Aliases and Shortcuts During the exam, you’ll save enormous amounts of time with kubectl aliases:

alias k=kubectl
alias kgp='kubectl get pods'
alias kgd='kubectl get deployments'
alias kaf='kubectl apply -f'
alias kdp='kubectl describe pod'

3. Learn vim Efficiently The exam environment includes vim. Practice these commands:

Insert mode: i
Exit insert: ESC
Save and quit: :wq
Quit without saving: :q!
Go to line: :50 (goes to line 50)

4. Master Declarative YAML While imperative commands are useful, many tasks require YAML editing. Practice writing pod, deployment, and service manifests from scratch.

5. Bookmark Documentation Pages During the exam, you can access Kubernetes docs. Familiarize yourself with:

API reference for each resource type
Task documentation
Kubectl cheat sheet

6. Time Management

Easy questions: 2-3 minutes
Medium questions: 4-6 minutes
Complex questions: 7-10 minutes
Buffer: 5-10 minutes for review

Tracking Your Progress

Use this milestone checklist to track progress:

Week 1 Milestones

Can explain cluster architecture
Comfortable with kubectl imperative commands
Can create and manage pods and deployments
Understand basic networking with Services

Week 2 Milestones

Can create StatefulSets and DaemonSets
Understand PV, PVC, and StorageClass workflow
Can manage ConfigMaps and Secrets
Score 70%+ on workload/storage practice exams

Week 3 Milestones

Can create and verify RBAC policies
Understand and implement NetworkPolicies
Can create Ingress resources
Comfortable with node management and upgrades

Week 4 Milestones

Can troubleshoot application and cluster issues
Scoring 75%+ on full-length mock exams
Know all important kubectl commands
Feel confident about exam day

What to Do if You Fall Behind

Life happens. If you fall behind your schedule:

Fallen 2-3 Days Behind:

Extend your timeline by a week
Focus on high-weightage domains (Troubleshooting 30%, Cluster Architecture 25%)
Reduce study time in low-weightage domains (Storage 10%, Workloads 15%)

Fallen a Week Behind:

Extend timeline to 6 weeks
Focus intensively on your weakest domains
Skip deep dives into less critical topics
Increase mock exam frequency

Close to Exam Date but Not Ready:

Postpone your exam
Better to wait and pass than rush and fail
Reschedule when you consistently score 75%+ on mocks

Avoiding Common Study Mistakes

Mistake 1: Too Much Theory, Not Enough Practice Reading about Kubernetes doesn’t prepare you for hands-on tasks. Spend 70% of time in a lab, 30% on theory.

Mistake 2: Ignoring Weak Domains If you struggle with networking, you’ll likely encounter network troubleshooting on the exam. Dedicate extra time to weak areas.

Mistake 3: Memorizing Instead of Understanding The exam tests problem-solving, not memorization. Understand why things work the way they do.

Mistake 4: Not Using Official Documentation Get familiar with the official Kubernetes docs during study. You can access them during the exam, and knowing where information is located is crucial.

Mistake 5: Skipping Mock Exams Mock exams are the best predictor of real exam performance. Take at least 4-5 full-length mocks before exam day.

FAQ

Q: Can I skip some topics if I’m short on time? A: Prioritize by weight: Troubleshooting (30%) > Cluster Architecture (25%) > Services (20%) > Workloads (15%) > Storage (10%).

Q: How many mock exams should I take? A: Minimum 3-4 full-length mocks. If you’re consistently scoring 75%+, you’re ready for the real exam.

Q: Is 30 days enough time to prepare? A: Yes, if you dedicate 1-2 hours daily and have foundational Kubernetes knowledge. Adjust to 6-8 weeks if you’re newer to Kubernetes.

Q: Should I take the exam on a specific day of the week? A: Choose a day when you’re typically alert (usually not Monday mornings or late Friday afternoons). Ensure you’re well-rested.

Q: Can I adjust this plan to my schedule? A: Absolutely. The principles matter more than the exact timeline. Adjust weeks and days as needed, but maintain the progressive difficulty.

Ready to follow this study plan? Start your CKA journey with Sailor.sh mock exams to track your progress and measure your readiness.