# How Passing CKAD Changed the Way I Think About Kubernetes Applications 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)](https://www.credly.com/badges/e72821a9-97a5-4ee8-a7f6-93f40246e864/public_url) certification. The CKA gave me a strong understanding of how Kubernetes works behind the scenes. But after passing the [Certified Kubernetes Application Developer (CKAD)](https://www.credly.com/badges/79423978-8948-451b-bca1-7721fff284e3/public_url), 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/](https://www.linkedin.com/in/shahzadaliahmad/) LFX Profile: [https://openprofile.dev/profile/shahzadahmad91](https://openprofile.dev/profile/shahzadahmad91) Credly: [https://www.credly.com/users/shahzadahmad](https://www.credly.com/users/shahzadahmad) Website: [https://shahzadahmad.dev/](https://shahzadahmad.dev/) If you found this article helpful, consider sharing it with others in the Kubernetes community.