A 35-service CRM on EKS

I deployed a CRM made up of 35+ microservices, with an Angular frontend and Spring Boot services, on AWS EKS. Its AWS infrastructure was automated with Terraform.

Deployments took about two hours. With this many services, a slow release path limits how often a team can safely ship.

A system of this shape generally needs the following, whatever the domain.

• –Each service deployable on its own, without coordinating 35 teams or scripts
• –Reproducible environments, created from code
• –Requests and limits set per service, because the JVM makes memory sizing matter

The diagram shows the general shape of the system: images flow from CI through a registry into the cluster, Terraform provisions what the cluster runs on, and ingress routes traffic in. Services and stores vary by design.

The reasoning that usually sits behind this stack.

• –Managed Kubernetes removes control-plane work, which matters when one engineer is covering many services.
• –Terraform makes each environment a reviewable artifact, not a sequence of console clicks.
• –A shared chart keeps 35 services consistent, with each one overriding only what differs.

With this many services, the safe order is to prove the pattern on one, then template it. Migrating everything at once hides which failures come from the platform and which come from the service.

CI/CD pipeline efficiency improved by 40%, and deployment time fell from about 2 hours to about 30 minutes.

The baseline for a cluster like this: workloads in private subnets, per-service IAM through IRSA instead of node-wide permissions, secrets kept out of images, and TLS terminated at ingress.

At this service count, a per-service view built on rate, errors and duration matters more than host metrics. Spring Boot Actuator exposes the signals, and probes should separate "alive" from "ready for traffic".

Problems that are typical at this scale, and how they are normally handled.

• –Slow JVM startup makes probes kill pods that are still booting. Startup probes fix this.
• –Sum of requests exceeds node capacity sooner than expected. Size from observed usage.
• –Deployment order between dependent services. Backward-compatible APIs remove the need for ordering.

The outcomes I recorded from this work.

• –35+ microservices deployed
• –Deployment time reduced from 2 hours to 30 minutes
• –CI/CD pipeline efficiency improved by 40%
• –AWS infrastructure automated with Terraform