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.
One of the most common questions I receive from Kubernetes learners is: “Should I start with CKA or CKAD?” It’s a fair question. Both certifications are highly respected within the Kubernetes ecosys
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 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 clusters, troubleshoot issues, configure networking, and understand the infrastructure behind Kubernetes.
After passing the CKA, I felt confident in my Kubernetes knowledge.
Then I started preparing for the Certified Kubernetes Application Developer (CKAD).
That’s when I realized something important:
Knowing how Kubernetes works is very different from knowing how applications work on Kubernetes.
The CKAD didn’t replace what I learned during the CKA journey.
Instead, it completed the picture.
In this article, I want to share the biggest lessons CKAD taught me that CKA didn’t.
The CKA focuses heavily on cluster operations.
You learn about:
Nodes
Networking
Storage
Scheduling
Cluster Maintenance
Security
Troubleshooting
The primary question becomes:
“How do I keep Kubernetes running?”
CKAD asks a different question:
“How do I build and run applications effectively on Kubernetes?”
That shift completely changed my perspective.
Instead of thinking about clusters, I started thinking about workloads.
Instead of focusing on infrastructure, I focused on application behavior.
CKA helped me understand:
How Kubernetes components interact
How Pods are scheduled
How Services work
How cluster networking functions
How to troubleshoot failures
These skills are essential.
Without them, managing Kubernetes in production becomes difficult.
However, I realized that understanding the platform alone isn’t enough.
Applications are the reason Kubernetes exists in the first place.
One of the biggest lessons from CKAD was understanding the complete lifecycle of an application.
Questions I started asking:
How is the application deployed?
How is it configured?
How is it updated?
How is it scaled?
How is it monitored?
How does it recover from failures?
These questions rarely appeared during my early Kubernetes learning journey.
CKAD brought them to the forefront.
During CKA preparation, I understood probes conceptually.
But during CKAD preparation, I truly appreciated their importance.
Answers:
Is the application still alive?
Answers:
Is the application ready to receive traffic?
Answers:
Has the application finished starting?
Before CKAD, probes felt like another Kubernetes feature.
After CKAD, they felt like one of the most important tools for application reliability.
During CKA preparation, ConfigMaps and Secrets were simply resources to create.
During CKAD preparation, I began thinking about them from a developer’s perspective.
Questions like:
How should applications consume configuration?
What belongs in a Secret?
What should be externalized?
How do we manage environment-specific settings?
This was a completely different way of thinking.
One topic I underestimated during CKA preparation was multi-container Pods.
CKAD introduced me to patterns such as:
Sidecar
Ambassador
Adapter
These patterns helped me understand how multiple containers can collaborate within a single Pod.
More importantly, they showed me how Kubernetes solves real application problems.
One thing that surprised me was how much application design appears throughout CKAD.
The exam isn’t just about writing YAML.
It’s about making decisions.
Questions like:
Should this be a Deployment or a Job?
When should I use a CronJob?
How should this application be exposed?
Where should configuration live?
These decisions affect how applications behave in production.
CKAD encourages you to think like an architect, not just an operator.
CKA troubleshooting often focuses on:
Cluster issues
Node issues
Networking problems
Storage failures
CKAD troubleshooting often focuses on:
Application failures
Misconfigurations
Container startup issues
Health checks
Deployment behavior
The troubleshooting mindset remains the same.
The scope changes.
The more I progressed through CKAD, the more I realized how important YAML is.
CKA often allows you to solve problems through administration tasks.
CKAD requires you to describe applications accurately through manifests.
Every field matters.
Every indentation matters.
Every specification matters.
Writing Kubernetes manifests became a skill in itself.
One unexpected realization was that CKAD often feels closer to what developers and platform teams encounter daily.
Topics such as:
Deployments
Probes
ConfigMaps
Secrets
Jobs
Scaling
appear constantly in production environments.
Many of the challenges developers face revolve around these concepts.
This question comes up frequently.
The truth is:
Neither certification is better.
They serve different purposes.
How Kubernetes works.
How applications work on Kubernetes.
Together, they create a much stronger understanding than either certification alone.
If CKA taught me how to operate Kubernetes, CKAD taught me why Kubernetes exists.
Applications are the reason organizations adopt Kubernetes.
Applications are what users interact with.
Applications are what businesses depend on.
Understanding how to build, deploy, configure, and maintain those applications has made me a better Kubernetes practitioner.
Looking back, earning both certifications gave me a more complete view of Kubernetes.
CKA helped me understand the platform.
CKAD helped me understand the workloads running on that platform.
Both perspectives matter.
And together, they transformed the way I think about Kubernetes.
For anyone considering the next step after CKA, CKAD isn’t just another certification.
It’s an opportunity to see Kubernetes through a completely different lens.
And in my experience, that’s where some of the most valuable learning begins.
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.
