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.
During my CKA preparation, I realized that one of the biggest differences between knowing Kubernetes and working efficiently with Kubernetes was mastering kubectl. In the beginning, I understood conce
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 first started learning Kubernetes, the ecosystem felt overwhelming.
There were so many concepts to understand:
Pods
Deployments
Networking
Storage
RBAC
Services
Containers
YAML
Control Plane components
At the beginning, I often wondered:
“Where should I actually start?”
Over time, after consistent hands-on practice, building labs, troubleshooting clusters, and eventually earning the Certified Kubernetes Administrator (CKA) certification, I realized something important:
Learning Kubernetes becomes much easier when you follow a structured roadmap.
In this article, I want to share the roadmap that helped me move from Kubernetes beginner to CKA-certified administrator.
This is not the only path — but it is the one that worked for me.
Before Kubernetes, I focused on Linux fundamentals.
This step is extremely important because Kubernetes environments are heavily Linux-based.
Topics I practiced:
Linux commands
File permissions
Processes
Networking basics
Systemd
SSH
Package management
Logs
Disk management
Commands like these became part of my daily workflow:
ps
top
grep
curl
netstat
ss
journalctl
systemctl
Strong Linux fundamentals make Kubernetes troubleshooting significantly easier.
Before learning Kubernetes itself, I spent time understanding containers.
This helped me understand:
Images
Containers
Registries
Dockerfiles
Volumes
Networking
I practiced using:
Docker
Container images
Basic container networking
This stage helped me understand what Kubernetes is actually orchestrating.
Once I was comfortable with containers, I started learning core Kubernetes concepts.
This was the foundation stage.
Topics I focused on:
Pods
ReplicaSets
Deployments
Services
Namespaces
ConfigMaps
Secrets
At this point, I was not focused on certification.
I simply wanted to understand:
How Kubernetes actually works.
One of the biggest turning points in my learning journey was creating a practice environment on my laptop.
I used local Kubernetes clusters to:
Deploy applications
Create workloads
Break configurations
Practice troubleshooting
Repeat tasks daily
This hands-on experience was far more valuable than passive learning.
Kubernetes becomes easier when you interact with it every day.
kubectl became one of my most important tools.
I practiced commands constantly:
kubectl get
kubectl describe
kubectl logs
kubectl exec
kubectl apply
kubectl delete
Over time, these commands became natural.
This helped tremendously during CKA preparation.
This was one of the more challenging stages for me.
Topics that required deeper understanding included:
Services
DNS
Network Policies
Persistent Volumes
Persistent Volume Claims
Storage Classes
These concepts are critical for both the CKA exam and real-world Kubernetes environments.
I spent extra time practicing these areas repeatedly.
This was probably the most valuable skill I developed.
Instead of only creating resources, I started intentionally breaking things.
Examples:
CrashLoopBackOff
ImagePullBackOff
Failed Scheduling
DNS Issues
Storage Failures
Service Connectivity Problems
Then I fixed them.
This process improved my confidence significantly.
The more problems I solved, the more comfortable I became with Kubernetes.
Once I had strong Kubernetes fundamentals, I started preparing specifically for the CKA exam.
My preparation included:
Hands-on labs
Mock exams
Documentation practice
Time management
Troubleshooting exercises
I focused heavily on:
Practical learning
Speed
Repetition
Real cluster interaction
The CKA exam rewards hands-on experience far more than memorization.
One of the most underrated Kubernetes skills is knowing how to use documentation effectively.
During preparation, I practiced:
Searching efficiently
Finding YAML examples
Using Kubernetes references quickly
This became a huge advantage during the exam.
One of the biggest realizations I had after earning CKA was this:
Kubernetes learning never really stops.
After CKA, I continued exploring:
GitOps
Argo CD
Helm
Observability
Platform Engineering
Security
CI/CD
Cloud-native ecosystems
The CKA gave me the foundation.
Real-world projects expanded that knowledge much further.
The approach that helped me most was simple:
Understand the concept.
Apply it in a lab.
Create problems intentionally.
Fix the issues yourself.
Repeat until the concepts become natural.
This cycle accelerated my learning more than anything else.
If you’re starting Kubernetes today, my advice would be:
✅ Focus on fundamentals first
✅ Practice every day
✅ Build labs
✅ Learn Linux properly
✅ Troubleshoot intentionally
✅ Use documentation effectively
✅ Don’t rush certification preparation
The certification becomes much easier when the fundamentals are strong.
Kubernetes can feel intimidating at first.
The ecosystem is massive, and there is always more to learn.
But with consistent practice, hands-on labs, troubleshooting experience, and a structured roadmap, the learning process becomes much more manageable.
For me, the journey from beginner to CKA was not just about passing an exam.
It was about building confidence, improving troubleshooting skills, and developing a deeper understanding of cloud-native technologies.
And in many ways, that journey is still continuing today.
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 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.