# What CKAD Taught Me That CKA Didn’t When I started my Kubernetes certification journey, my first goal was clear: Pass the [Certified Kubernetes Administrator (CKA)](https://www.credly.com/badges/e72821a9-97a5-4ee8-a7f6-93f40246e864/public_url) 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)](https://www.credly.com/badges/79423978-8948-451b-bca1-7721fff284e3/public_url). 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](https://www.credly.com/badges/79423978-8948-451b-bca1-7721fff284e3/public_url) taught me that CKA didn’t. ## **The Biggest Shift: From Infrastructure to Applications** 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 Taught Me the Platform** 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. ## **CKAD Taught Me the Application Lifecycle** 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. ## **I Finally Appreciated Probes** During CKA preparation, I understood probes conceptually. But during CKAD preparation, I truly appreciated their importance. ### **Liveness Probe** Answers: > *Is the application still alive?* ### **Readiness Probe** Answers: > *Is the application ready to receive traffic?* ### **Startup Probe** 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. ## **ConfigMaps and Secrets Became More Meaningful** 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. ## **Multi-Container Pods Finally Made Sense** 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. ## **CKAD Taught Me to Think About Design** 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. ## **Troubleshooting Looks Different** 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. ## **YAML Became More Important** 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. ## **CKAD Felt Closer to Real Application Teams** 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. ## **Which Certification Was More Valuable?** This question comes up frequently. The truth is: Neither certification is better. They serve different purposes. ### **CKA teaches:** > *How Kubernetes works.* ### **CKAD teaches:** > *How applications work on Kubernetes.* Together, they create a much stronger understanding than either certification alone. ## **My Biggest Takeaway** 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. ## **Final Thoughts** 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. ## **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 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.