When I first started learning Kubernetes, my focus was almost entirely on infrastructure.
I wanted to understand:
Pods
Services
Networking
Storage
Scheduling
Cluster operations
This naturally led me toward the Certified Kubernetes Administrator (CKA) certification.
The CKA gave me a strong understanding of how Kubernetes works behind the scenes.
But after passing the Certified Kubernetes Application Developer (CKAD), I realized something important:
Kubernetes isn’t just a platform to manage. It’s a platform to build on.
That shift fundamentally changed the way I think about applications running inside Kubernetes.
Before CKAD, I Thought Mostly About Infrastructure
As a DevOps Engineer, I was naturally drawn toward operational topics.
When I looked at a Kubernetes cluster, I thought about questions like:
Are the nodes healthy?
Is networking working?
Is storage configured correctly?
Are workloads scheduled properly?
Are resources being utilized efficiently?
These are all important questions.
In fact, they’re critical.
But they focus on the platform itself.
What I wasn’t thinking about enough was the application experience.
CKAD Forced Me to Think Like a Developer
One of the biggest lessons from CKAD was learning to view Kubernetes from the perspective of the application.
Instead of asking:
“Is the cluster healthy?”
I started asking:
“Can the application function correctly inside the cluster?
That may sound like a small difference.
In reality, it’s a completely different mindset.
Applications don’t care how elegant the cluster architecture is.
They care about:
Connectivity
Configuration
Availability
Reliability
Scalability
CKAD helped me focus on those concerns.
I Started Thinking More About Application Lifecycles
Before CKAD, deploying an application often felt like the final step.
After CKAD, I realized deployment is only the beginning.
Every application has a lifecycle:
Build
Deploy
Configure
Scale
Monitor
Update
Recover
Kubernetes touches every stage of that lifecycle.
The more I learned, the more I appreciated how much planning goes into running applications successfully.
Probes Became One of My Favorite Kubernetes Features
During my early Kubernetes learning journey, probes felt like another exam objective.
CKAD changed that.
I began understanding how critical they are for production reliability.
Readiness Probes
Answer:
Is the application ready to receive traffic?
Liveness Probes
Answer:
Is the application still functioning correctly?
Startup Probes
Answer:
Has the application finished initializing?
These simple configurations can dramatically improve application resilience.
Today, I rarely look at deployments without thinking about probe design.
ConfigMaps and Secrets Became Design Decisions
Before CKAD, ConfigMaps and Secrets were resources I created because the exam required them.
After CKAD, I began seeing them as architectural decisions.
Questions I now consider:
What should be externalized?
What belongs in a Secret?
How will this application behave across environments?
How will configuration changes be managed?
These decisions directly affect maintainability and scalability.
YAML Stopped Being Just YAML
One of the biggest surprises was how much my relationship with YAML changed.
Before CKAD:
YAML was configuration.
After CKAD:
YAML became application design.
A Deployment manifest isn’t just syntax.
It’s a description of how an application should behave.
Every field communicates intent.
Every configuration impacts reliability.
Every resource definition influences operations.
CKAD helped me appreciate that.
I Learned the Difference Between Running Containers and Running Applications
This was probably the biggest mindset shift of all.
Containers are easy.
Applications are not.
A container can start successfully and still fail to deliver business value.
An application needs:
Networking
Configuration
Health checks
Storage
Secrets
Scaling
CKAD taught me that successful Kubernetes deployments require thinking beyond containers.
You must think about the complete application ecosystem.
Multi-Container Pods Finally Made Sense
During CKAD preparation, I spent more time understanding application design patterns.
Concepts like:
Sidecar
Ambassador
Adapter
began making practical sense.
Instead of viewing Pods as single-container units, I started understanding them as collaborative application environments.
This significantly expanded my understanding of Kubernetes architecture.
Troubleshooting Became More Application-Centric
My troubleshooting process also evolved.
Before CKAD, my troubleshooting often focused on infrastructure.
Questions like:
Is the node healthy?
Is networking working?
Is storage attached?
After CKAD, I added another layer:
Is the application configured correctly?
Is the readiness probe failing?
Are environment variables missing?
Are Secrets mounted properly?
Is the application behaving as expected?
This broader perspective has helped me solve production issues more effectively.
CKAD Helped Me Appreciate Developer Challenges
One unexpected benefit of CKAD was gaining a better understanding of developer concerns.
As DevOps engineers, we often focus on platforms.
Developers focus on delivering applications.
CKAD helped bridge that gap.
It taught me to think about:
Developer experience
Deployment simplicity
Configuration management
Application reliability
These are areas where infrastructure and application teams must work together.
The Certification Was Valuable. The Mindset Shift Was More Valuable.
Passing CKAD was a great achievement.
But the certification itself wasn’t the most valuable outcome.
The real value came from changing how I think.
I stopped viewing Kubernetes solely as infrastructure.
I started viewing it as an application platform.
That perspective has influenced how I design, deploy, troubleshoot, and operate workloads.
Final Thoughts
Looking back, CKA taught me how Kubernetes works.
CKAD taught me how applications work within Kubernetes.
Both certifications were valuable.
But together, they provided something much bigger:
A more complete understanding of cloud-native systems.
Today, when I look at a Kubernetes environment, I no longer see just clusters, nodes, and Pods.
I see applications.
I see user experiences.
I see reliability requirements.
I see design decisions.
And I believe that mindset shift is one of the most valuable lessons CKAD gave me.
Connect With Me
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 on 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.
