🚀 Building a Production EKS Platform

From first contact with Kubernetes to deploying a secure, production-grade EKS platform with HTTPS and IRSA.

1️⃣ The Fear I Didn’t Want to Admit

Kubernetes is one of those technologies that carries a reputation.

Powerful. Flexible. Industry-standard.

And honestly? Intimidating.

I had worked with Docker, Terraform, ECS, and CI/CD pipelines before. Those felt structured. Predictable. Kubernetes felt… vast.

There were too many moving parts. Too many YAML files. Too many concepts that seemed simple on paper but overwhelming in practice.

For a while, I stayed on the edges, learning just enough to understand what others were doing.

But I knew avoiding it wasn’t helping me grow.

2️⃣ Choosing Discomfort on Purpose

Instead of starting with toy examples, I made a deliberate decision:

If I was going to learn Kubernetes, I would do it the hard way.

I chose to build a production-style platform on Amazon EKS, not because it was easy, but because it would force me to understand how things actually work.

That meant dealing with:

  • Infrastructure provisioning with Terraform
  • IAM roles and permissions that actually matter
  • Ingress, load balancing, and real networking
  • HTTPS, certificates, and DNS

No shortcuts. No magic abstractions.

3️⃣ When Things Started Breaking 🧩

And break they did.

At first, the cluster existed, but nothing worked the way I expected.

The Application Load Balancer refused to provision. Ingress resources sat there silently. Health checks failed. HTTPS didn’t come up.

The most frustrating part was that Kubernetes rarely screams at you.

It quietly waits while you figure out what you misunderstood.

That forced me to slow down and truly understand:

  • How IAM Roles for Service Accounts (IRSA) actually work
  • Why least-privilege policies are easy to get wrong
  • How ALB health checks interact with container ports
  • Why “it deployed” doesn’t mean “it’s production-ready”

4️⃣ The Moment It Clicked 💡

The breakthrough didn’t come from adding more configuration.

It came from understanding responsibility boundaries.

Terraform wasn’t just creating resources; it was defining ownership.

Kubernetes wasn’t just running containers; it was enforcing contracts between networking, security, and applications.

Once those boundaries became clear, debugging became logical instead of emotional.

The platform stabilized. HTTPS worked. Traffic flowed. Health checks passed.

The system finally behaved like a system.

5️⃣ Why I’m Glad I Didn’t Avoid Kubernetes

Kubernetes is broad. It’s complex. And yes; it can be scary.

But that complexity exists because it solves real problems at scale.

This project taught me that confidence doesn’t come from knowing everything.

It comes from knowing how to approach unfamiliar systems methodically and safely.

I’m still learning Kubernetes. But now I’m learning from experience, not fear.

🎯 Final Reflection

This project wasn’t about mastering Kubernetes overnight.

It was about proving to myself that I could step into uncomfortable territory, build something real, break it, fix it, and understand it.

And that mindset, more than any tool, is what I want my portfolio to reflect.