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 started my Kubernetes certification journey, my first goal was clear: Pass the Certified Kubernetes Administrator (CKA) exam. The CKA taught me how Kubernetes works. It taught me how to manage
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.
Passing the Certified Kubernetes Administrator (CKA) was one of the most rewarding milestones in my cloud-native journey.
The certification challenged me to understand Kubernetes from an administrator’s perspective:
Cluster architecture
Networking
Storage
Security
Troubleshooting
Cluster maintenance
It taught me how Kubernetes works.
It taught me how to operate Kubernetes.
Most importantly, it taught me how to think under pressure when things break.
But after earning my CKA and reflecting on my learning journey, I realized something important:
Knowing how to operate Kubernetes is only one side of the story.
The other side is understanding how applications are designed, deployed, configured, and managed inside Kubernetes.
And that’s exactly why I’ve decided to pursue the Certified Kubernetes Application Developer (CKAD) certification.
Before preparing for the CKA, Kubernetes felt like a massive collection of YAML files, commands, and concepts.
By the end of my preparation, I understood:
How Pods communicate
How Services expose applications
How Storage works
How to troubleshoot cluster issues
How to manage Kubernetes resources
The CKA gave me a strong operational foundation.
But it also revealed a gap in my knowledge.
I understood the platform.
I wanted to better understand the applications running on the platform.
One of the biggest realizations I had during my CKA journey was this:
Most users don’t care about Kubernetes.
They care about applications.
Developers care about:
Deploying applications
Managing configurations
Handling secrets
Scaling workloads
Building reliable services
As DevOps engineers, we often focus heavily on infrastructure.
But Kubernetes was created to run applications.
To truly understand Kubernetes, I believe we need to understand both sides:
The administrator perspective
The developer perspective
The CKA teaches you how to operate Kubernetes clusters.
Typical topics include:
✅ Cluster Maintenance
✅ Networking
✅ Storage
✅ Security
✅ Troubleshooting
✅ Scheduling
✅ RBAC
These skills are essential.
Without them, clusters become unreliable.
But many application-level concepts receive less attention.
The CKAD approaches Kubernetes from a different angle.
Instead of asking:
“How do I manage the cluster?”
It asks:
“How do I build and run applications effectively on Kubernetes?”
Topics include:
Application deployment
Configuration management
Multi-container Pods
Health checks
Jobs and CronJobs
Application observability
Kubernetes design patterns
This shift in perspective is exactly what interests me.
One lesson I’ve learned throughout my DevOps career is that great engineers understand both infrastructure and applications.
You can build the most reliable Kubernetes cluster in the world.
But if you don’t understand:
Application behavior
Deployment strategies
Container design
Configuration patterns
you’re only seeing half the picture.
CKAD helps bridge that gap.
In production environments, problems rarely stay within one domain.
A deployment issue might involve:
Application configuration
Secrets
Networking
Resource limits
Storage
Understanding both the platform and the workload makes troubleshooting significantly easier.
The more I work with Kubernetes, the more I realize that successful engineers don’t think in silos.
They understand the complete system.
As I begin my CKAD journey, these are the areas I’m most excited to explore:
Understanding patterns like:
Sidecar
Ambassador
Adapter
How applications are deployed, updated, and maintained inside Kubernetes.
Learning how readiness, liveness, and startup probes contribute to application reliability.
Using ConfigMaps and Secrets effectively in real-world environments.
Understanding how containers collaborate within Pods.
Just like with the CKA, my goal isn’t simply to pass an exam.
The certification is important.
But the learning is more important.
The objective is to become a better engineer.
A better troubleshooter.
A better Kubernetes practitioner.
A better DevOps professional.
CKAD is simply the next step in that journey.
The CKA taught me how to manage Kubernetes.
Now I want to learn how to build on Kubernetes.
That’s why CKAD feels like the natural next step.
As cloud-native adoption continues to grow, understanding both operations and application development becomes increasingly valuable.
For me, this isn’t just about collecting certifications.
It’s about becoming a more complete Kubernetes engineer.
The journey continues.
And CKAD is the next chapter.
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.
