Search for a command to run...
No comments yet. Be the first to comment.
Follow my journey from DevOps Engineer to Kubestronaut as I explore Kubernetes, CNCF certifications, cloud-native technologies, and hands-on learning. In this series, I share my experiences preparing for and passing certifications such as CKA, CKAD, and CKS, along with exam strategies, study resources, troubleshooting lessons, and practical insights gained from real-world Kubernetes environments. Whether you're just starting with Kubernetes or pursuing advanced CNCF certifications, I hope these experiences help guide your own cloud-native journey.
When I first started learning Kubernetes, my world revolved around: Pods Deployments Services YAML files kubectl commands CKA exam objectives My goal was simple: Understand Kubernetes and ear
Kubernetes Control Plane explained in a practical way for engineers who manage real-world clusters. Introduction When I first started learning Kubernetes, I could create Pods, Deployments, and Service
Kubernetes networking is one of the most important — and often most confusing — topics for beginners. Pods have IP addresses, Services have virtual IPs, DNS magically resolves names, Ingress routes tr
One of the most common questions developers ask when they start working with Kubernetes is: “What actually happens when a user sends a request to my application?” We deploy Pods, create Services, co
Most developers know that Kubernetes can automatically restart failed applications. But have you ever wondered what actually happens behind the scenes when a Pod crashes? When I first started learning
When developers first start learning Kubernetes, they quickly understand Pods and Deployments. You create a Deployment, Kubernetes creates Pods, and your application starts running. Simple, right? Not
Shahzad Ahmad | Kubernetes, DevOps & Cloud Native Journey
32 posts
Senior DevOps Engineer documenting my journey through Kubernetes, CNCF certifications, cloud-native technologies, platform engineering, and automation. Here you'll find hands-on tutorials, certification experiences (CKA, CKAD, CKS), exam strategies, troubleshooting guides, and lessons learned from real-world DevOps and Kubernetes environments. My goal is to share practical knowledge, help others in their cloud-native journey, and ultimately document the path from DevOps Engineer to Kubestronaut.
When I started preparing for the Certified Kubernetes Administrator (CKA) exam, I did what most people do.
I watched courses.
I took notes.
I practiced labs.
I collected resources.
And I constantly wondered:
“Am I preparing the right way?”
Looking back after passing the CKA and continuing my cloud-native journey toward becoming a Kubestronaut, I realized something important:
I spent too much time trying to learn everything and not enough time focusing on what actually mattered.
If I had to start my CKA preparation from scratch today, I would approach it very differently.
This article is the roadmap I wish someone had given me on Day 1.
Like many candidates, I believed success would come from consuming more content.
I downloaded:
PDFs
Cheat sheets
Notes
Practice questions
Multiple courses
The problem wasn’t a lack of resources.
The problem was information overload.
I spent weeks collecting resources when I should have been spending more time inside a Kubernetes cluster.
One lesson became very clear:
Kubernetes is learned by doing, not by reading.
If I were starting again, I would spend my first week strengthening Linux skills.
Many candidates underestimate how important Linux is for the CKA.
You should be comfortable with:
grep
awk
sed
vim
systemctl
journalctl
ssh
tar
networking commands
The CKA is not purely a Kubernetes exam.
Linux knowledge saves valuable minutes during troubleshooting tasks.
I would avoid jumping directly into mock exams.
Instead, I would focus on understanding:
Pods
Deployments
Services
ConfigMaps
Secrets
Namespaces
Persistent Volumes
RBAC
Networking
The goal would be understanding, not memorization.
Many exam tasks become easier when you understand why Kubernetes behaves a certain way.
If I started again, I would create a lab environment during Week 1.
Possible options:
Minikube
Kind
K3s
kubeadm-based cluster
Then I would:
Break things
Fix things
Deploy applications
Experiment freely
Nothing accelerates learning faster than hands-on practice.
This is probably the biggest change I would make.
Many candidates prepare as if they need to memorize everything.
You don’t.
The official Kubernetes documentation is available during the exam.
I would practice every lab with documentation open.
Whenever I forgot something, I would search:
kubectl reference
task guides
By exam day, documentation navigation would feel natural.
If I had to start again, I would spend more time mastering kubectl.
This includes:
kubectl get
kubectl describe
kubectl logs
kubectl exec
kubectl edit
kubectl apply
kubectl expose
kubectl create
kubectl explain
And especially:
kubectl explain
This command is one of the most underrated tools for CKA preparation.
One mistake I made was manually writing YAML too often.
Today, I would immediately learn commands like:
kubectl create deployment nginx \
--image=nginx \
--dry-run=client -o yaml
and
kubectl run nginx \
--image=nginx \
--dry-run=client -o yaml
Generating templates is significantly faster than writing everything from scratch.
Those saved minutes matter during the exam.
The biggest lesson from my CKA journey is this:
Troubleshooting is more valuable than memorization.
I would intentionally create problems such as:
CrashLoopBackOff
ImagePullBackOff
Failed Services
Broken RBAC
Storage issues
Node failures
Then practice fixing them repeatedly.
The exam rewards problem-solving more than memorization.
During preparation, many candidates spend unlimited time solving tasks.
The real exam doesn’t work that way.
If I started again, I would:
Set timers
Simulate exam pressure
Practice switching tasks quickly
Learning when to move on is an important exam skill.
I would stop trying to memorize everything.
Instead, I would focus on:
Frequently used kubectl commands
YAML structures
Common troubleshooting workflows
Documentation locations
Everything else can be verified through documentation.
The goal is efficiency, not perfect memory.
If I started again, my resource stack would be simple:
Kubernetes Official Documentation
Kubernetes the Hard Way (selected concepts)
Killer Shell
Personal Lab Environment
Killer CKA Simulator
Timed practice sessions
That’s it.
Too many resources often slow progress.
Focus on:
Linux
Pods
Deployments
Services
Namespaces
Focus on:
Storage
Networking
RBAC
ConfigMaps
Secrets
Focus on:
Cluster Architecture
Scheduling
Troubleshooting
etcd
Focus on:
Mock Exams
Time Management
Documentation Navigation
Weak Areas
If I could give my past self only one piece of advice, it would be:
Spend less time collecting resources and more time inside a Kubernetes cluster.
The candidates who pass the CKA aren’t necessarily the ones who watch the most videos.
They’re the ones who practice consistently.
Every hour spent troubleshooting a real Kubernetes problem teaches more than hours of passive learning.
If I had to prepare for the CKA again, I would focus on:
✅ Linux fundamentals
✅ Kubernetes concepts
✅ Hands-on labs
✅ Documentation navigation
✅ Troubleshooting skills
✅ Time management
And I would spend far less time searching for the perfect resource.
Passing the CKA isn’t about knowing everything.
It’s about knowing enough to solve problems efficiently under pressure.
The sooner you realize that, the faster your preparation becomes.
I’d love to hear your thoughts and experiences.
Follow me for more Kubernetes, CNCF, DevOps, and Kubestronaut journey content.
If you’re preparing for Kubernetes certifications, pursuing the Kubestronaut journey, or working in the cloud-native ecosystem, I’d love to connect.
Follow me for more articles on Kubernetes, CNCF certifications, DevOps, Platform Engineering, and Cloud-Native technologies.
LinkedIn: https://www.linkedin.com/in/shahzadaliahmad/
LFX Profile: https://openprofile.dev/profile/shahzadahmad91
Credly: https://www.credly.com/users/shahzadahmad
Website: https://shahzadahmad.dev/
If you found this article helpful, consider sharing it with others in the Kubernetes community.