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 biggest realizations I had while preparing for and passing the Certified Kubernetes Application Developer (CKAD) exam was this: Deploying containers is easy. Designing cloud-native applicat
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 preparing for the Certified Kubernetes Application Developer (CKAD) exam, I assumed it would simply be a lighter version of the Certified Kubernetes Administrator (CKA).
After all, I had already passed CKA and spent years working with Kubernetes in real-world environments.
I was wrong.
CKAD taught me lessons that went far beyond passing an exam. It fundamentally changed how I think about building, deploying, troubleshooting, and operating Kubernetes applications.
Looking back, these are the biggest lessons I learned from the CKAD journey.
As administrators and DevOps engineers, we often focus on the platform itself:
Nodes
Networking
Storage
Security
Cluster Operations
CKAD forced me to focus on the application layer.
Instead of asking:
Is the cluster healthy?
I started asking:
Can the application run reliably in production?
That shift in perspective changed how I approach Kubernetes today.
A perfectly healthy cluster is meaningless if applications are poorly designed, difficult to scale, or constantly failing health checks.
Before CKAD, I relied heavily on existing manifests and infrastructure repositories.
During exam preparation, I had to create Kubernetes resources quickly from scratch.
This taught me:
How to use imperative commands effectively
How to generate manifests rapidly
How to modify YAML efficiently
How to avoid unnecessary typing
The ability to work quickly with Kubernetes resources is valuable far beyond the exam.
In production environments, speed often matters when troubleshooting incidents or deploying fixes under pressure.
Liveness probes.
Readiness probes.
Startup probes.
Before CKAD, I understood them conceptually.
During preparation, I learned how critical they are for application reliability.
A Kubernetes deployment is not truly production-ready without proper health checks.
Incorrect probe configurations can lead to:
Crash loops
Traffic being routed to unhealthy pods
Slow recoveries
Unnecessary outages
CKAD helped me understand that probes are not just exam objectives — they are operational requirements.
One of the most common mistakes in Kubernetes environments is ignoring resource requests and limits.
CKAD repeatedly reinforced the importance of:
CPU requests
CPU limits
Memory requests
Memory limits
Applications that do not define resources properly can create problems for the entire cluster.
This lesson changed how I review Kubernetes manifests.
Today, missing resource specifications immediately stand out to me as a risk.
Many engineers think troubleshooting is primarily an administrator’s responsibility.
CKAD teaches the opposite.
Developers should understand how to investigate:
Pod failures
Container crashes
Misconfigured services
Failed deployments
Environment variable issues
The exam emphasizes practical troubleshooting rather than memorization.
That mindset aligns closely with real-world Kubernetes operations.
During preparation, I realized how frequently applications depend on external configuration.
CKAD reinforced best practices around:
Environment variables
Configuration management
Secret handling
Application portability
A well-designed Kubernetes application should be able to move between environments with minimal changes.
ConfigMaps and Secrets make that possible.
Before CKAD, scaling often meant:
kubectl scale deployment app --replicas=5
CKAD showed me that scaling is really about application design.
Questions began to emerge:
Is the application stateless?
Can multiple replicas safely run together?
Does the application handle traffic spikes?
Is session persistence required?
The exam helped me think beyond Kubernetes commands and focus on application architecture.
One of the biggest advantages during CKAD is access to Kubernetes documentation.
However, simply having access is not enough.
You must know:
Where information lives
Which examples are useful
How to navigate quickly
Learning to use documentation efficiently became one of the most valuable skills I gained.
This skill continues to help me long after passing the exam.
Many engineers overcomplicate Kubernetes deployments.
CKAD rewards simple, clean, maintainable solutions.
During preparation, I learned to avoid unnecessary complexity and focus on solving the actual problem.
In real-world environments, simple architectures are usually easier to:
Operate
Troubleshoot
Scale
Secure
This may be the most important lesson of all.
CKA taught me how Kubernetes works.
CKAD taught me why applications behave the way they do inside Kubernetes.
After passing CKAD, I became more effective at:
Supporting development teams
Reviewing manifests
Troubleshooting deployments
Designing cloud-native applications
Building production-ready Kubernetes workloads
The certification expanded my perspective beyond infrastructure and into application design.
Passing CKAD was not just another certification milestone.
It helped me bridge the gap between Kubernetes administration and Kubernetes application development.
If CKA teaches you how to manage Kubernetes, CKAD teaches you how to build applications that thrive inside it.
For me, that was the biggest value of the journey.
And it is one of the reasons I believe every Kubernetes professional — whether developer, DevOps engineer, platform engineer, or administrator — can benefit from preparing for CKAD.
The certification may last a few years, but the lessons stay with you much longer.
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.