← Back to blog
8 min readEN

From 24 Containers to Kubernetes:
A Real AWS Migration Case Study

A practical breakdown of how I migrated a production CX platform running on 24 loosely managed containers to a proper Kubernetes setup on AWS — including the exact tradeoffs, the numbers, and what I'd do differently.

KubernetesAWSDevOpsGitLab CI/CDHashiCorp VaultCase Study

The starting point

I'm Abdelhamid NOIRA, a DevOps Engineer based in Casablanca, Morocco. During an engagement with Tersea Groupe, I worked on Deskea, their AI-powered omnichannel customer experience platform. The application was already in production and handling real traffic — but its infrastructure was 24 containers, deployed and managed largely by hand, with no orchestration layer tying them together.

That's a common place for a growing product to be: containerized because someone knew Docker was the right call early on, but never taken the next step to actual orchestration. Scaling meant SSH-ing into boxes. Deployments meant manual container restarts. There was no consistent secret management, no blue-green rollout path, and no real observability beyond basic uptime checks.

Why Kubernetes, specifically

Kubernetes isn't always the right answer for 24 containers — plenty of teams run that scale just fine on ECS or a well-organized Compose setup. In this case it made sense because the product roadmap included multi-region expansion and the team wanted a consistent deployment model across environments (staging, production, and eventually a second AWS region). Those requirements — declarative rollouts, environment parity, and horizontal scaling on demand — are exactly what Kubernetes is built for.

AWS (EKS)
Managed control plane — no time spent operating etcd or the API server by hand
Helm
Every service packaged as a chart, versioned alongside the application code
GitLab CI/CD
Fully automated pipelines: build, test, scan, deploy — no manual steps
HashiCorp Vault
Centralized secret management, replacing hardcoded env files
Prometheus & Grafana
Real cluster and application metrics, replacing basic uptime checks
Ansible
Role-based provisioning for anything outside the cluster itself

The migration approach

I didn't move all 24 containers at once. Each service was migrated individually, starting with the lowest-risk, stateless ones — internal APIs with no direct customer traffic — before touching anything customer-facing. Every service got its own Helm chart, and secrets that had previously lived in plain environment files were moved into Vault and injected at runtime.

For rollouts, I set up blue-green deployments for the highest-traffic services and canary releases for everything else, gated by the GitLab CI/CD pipeline. That meant a bad deploy could be caught and rolled back automatically before it reached most of the traffic, instead of a full outage while someone manually reverted a container.

Ansible handled the pieces that didn't belong inside the cluster — things like DNS records, IAM roles, and the bootstrap configuration for new environments — so the whole provisioning process, cluster and surrounding infrastructure alike, stayed reproducible and out of anyone's head.

The results

15%
Lower infrastructure costs
Through right-sized node pools and autoscaling instead of static over-provisioning
10%
Better performance
From proper resource requests/limits and horizontal pod autoscaling
99.9%
Uptime
With blue-green and canary rollouts catching bad deploys before they spread

None of these numbers came from a single big change — they came from the accumulation of small, correct defaults: containers that request only the CPU/memory they actually use, a cluster autoscaler that adds and removes nodes based on real demand, and a deployment pipeline that makes the safe way to ship also the fastest way to ship.

What I'd do differently

Start observability earlier
Prometheus and Grafana went in mid-migration. In hindsight, having real metrics from day one would have made the before/after comparison — and the cost case to stakeholders — much clearer.
Namespace isolation from the start
Early services shared a namespace longer than they should have. Splitting by team or service boundary earlier would have simplified RBAC and made the eventual multi-region split easier.
Document the Vault migration path
Moving secrets out of env files was the right call, but the process wasn't written down until after it was done twice. A short runbook would have saved real time.

Conclusion

Migrating 24 hand-managed containers to Kubernetes wasn't about chasing a trendy technology — it was about replacing manual, error-prone operations with something declarative and repeatable. The cost and performance gains were real, but the bigger win was operational: deployments became routine instead of risky, and the team stopped needing to know which specific server a given service happened to be running on.

If you're running a similar-scale platform on unmanaged containers and weighing whether Kubernetes is worth the complexity, the honest answer is: it depends on where your product is headed. If multi-environment consistency, autoscaling, and safer rollouts are actually on your roadmap, the migration pays for itself quickly. If not, it might just be extra operational overhead.