AWS Builder Center
EKS in Production: What Actually Matters

EKS in Production: What Actually Matters

Event: AWS User Group UK Meetup | Speaker: Areg Hovakimyan (Senior DevOps Engineer, CNCF Kubestronaut) | Date: 11 May 2026 | Location: AutogenAI, London

Kubernetes talks have a habit of staying theoretical,  architecture diagrams, best-practice slides, the usual. Areg Hovakimyan's lightning talk at the AWS User Group UK meetup went the other way. He came with battle scars, and he was refreshingly upfront about it, joking that he'd swapped his usual blue jacket for a t-shirt because "it's hot," before diving into what actually happens once EKS clusters hit production.
Kubernetes Isn't the Hard Part Anymore
Areg's opening point set the tone for the whole talk: learning Kubernetes itself,  pods, secrets, deployments isn’t the challenge it used to be. Restarting a broken pod and watching it come back healthy is almost a reflex at this point, which is why he joked that SRE really stands for "Senior Restart Engineer."
The real difficulty, he argued, lives in the connective tissue around the cluster, the IAM role that's misconfigured, the service account that can't assume the right permissions, the networking and ingress setup that quietly breaks something three layers away. Storage and secrets management round out the list of places where things tend to go wrong. He specifically called out the gap left by not using an External Secrets Operator alongside a proper secrets manager, though he kept that as a "topic for the hallway track" rather than digging in during a short slot.
Expectations vs. Reality: The CI/CD Sprawl Problem
From there, Areg pivoted to a familiar story: teams start with a clean mental model apps, database, infrastructure and expect their tooling to match it. Reality is messier. Jenkins is still everywhere, even as companies migrate toward GitHub Actions, GitLab CI, or CircleCI, and coverage gaps creep in fast. Monitoring gets bolted on late, secrets management becomes an afterthought, a developer ships an undocumented deploy script, a junior engineer introduces a new Helm chart nobody reviewed and suddenly compliance is playing catch-up.
Terraform module sprawl was another pain point he flagged: public modules are generally solid, but private, internally maintained modules tend to accumulate technical debt that nobody has time to address.
What Actually Works: ArgoCD and Karpenter
This is where the talk turned genuinely useful. Areg highlighted two AWS-native capabilities he considers real wins for production teams:
ArgoCD, now available as a managed capability on EKS, removes a huge amount of the setup burden, installing it, wiring up the "app of apps" pattern, configuring auto-sync. He spoke from experience here, having previously deployed and championed ArgoCD manually at a former company ("developers said they wanted to build me a statue for it"). Having AWS offer it out of the box means teams get GitOps-driven visibility, a clean UI instead of grepping through kubectl get all -n <namespace> output,  without the usual setup tax.
Karpenter, paired with EKS Auto Mode, was his second recommendation. It handles resource provisioning more intelligently than traditional autoscalers, which he noted often fall short when GPU workloads are in the mix, increasingly relevant given current AI infrastructure demand. His caveat: Karpenter still needs a human keeping an eye on it. Flexibility isn't a substitute for ownership.
A Cautionary Tale: When "Simple" Tools Collide
The most memorable part of the talk was a story about a colleague using ACK (AWS Controllers for Kubernetes) to provision an S3 bucket directly from Kubernetes. It sounded convenient, until it turned out the same bucket already existed in Terraform. The conflict broke the front end tied to that bucket, and the outage landed during a Black Friday deployment window, lasting about an hour. Areg didn't name the company (NDA, understandably), but the lesson was clear: overlapping tools managing the same resource is a recipe for exactly this kind of collision. Keep tooling boundaries simple and explicit.
The Complexity Spectrum
Areg sketched out a rough spectrum of how much operational complexity teams take on:
  1. A simple cluster on Auto Mode - a few clicks, minimal overhead
  1. CI/CD plus basic automation for an internal platform
  1. Teams building their own custom CRDs and controllers to manage everything
His advice: stay as far left on that spectrum as your use case genuinely allows. Custom controllers and CRDs are powerful, but they're also, in his words, "mind-blowing" in the amount of ongoing maintenance they demand.
Key Takeaways
  • Reduce operational overhead wherever managed services let you.
  • Avoid unnecessary abstraction - don’t build custom tooling for problems AWS already solves.
  • Prefer simplicity over flexibility, especially early on.
  • Don't fight the platform. If you're managing everything manually, you're working against AWS rather than with it. Automate and lean on managed services where the cost trade-off makes sense - as Areg put it, it's often better to pay a bit more now than pay significantly more later.
Q&A: EKS vs. ECS
During Q&A, someone pushed back - only half-joking  about how many of the day's talks had centered on Kubernetes. The question that followed was a good one: if the goal is simplicity, why not skip EKS altogether and go with ECS?
Areg's answer was honest rather than dogmatic: it depends heavily on scaling needs and billing considerations - reserved instances, cost predictability, and how the infrastructure is expected to grow. He acknowledged both paths are valid, but was upfront that his own preference leans toward EKS, while conceding that when the client wants the simplest possible solution, that preference doesn't always win.
Final Thought
What made this talk land wasn't a new framework or a clever architecture pattern, it was the willingness to admit where things break in practice. EKS today gives teams a lot of managed capability out of the box (ArgoCD and Karpenter chief among them), but the underlying advice hasn't changed: choose tools deliberately, keep ownership boundaries clear, and resist the urge to over-engineer just because you can.


Big shout-out to our sponsors:
👏 Cloudscaler -  www.cloudscaler.com 
👏 Rayo -  www.rayo.cloud 
👏 The Scale Factory -  www.scalefactory.com 
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article