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) 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.