Microservices as One Engineer (Go + AWS + Terraform)

Microservices for one engineer pay off when you have the right tooling: small Go binaries, Terraform IaC, AWS ECS Fargate. I run this pattern across Shahriar Labs products. Here is the exact setup.

Why microservices solo

The standard advice is "monolith first." That's right when you have a team. When you are solo, the calculus shifts:

Blast radius matters more. A bug in one service should not take down the others.
Mental model matters. A 5k-line Go service fits in your head; a 50k-line monolith does not.
Deploy independence matters. I want to deploy LetX's API without touching BikroyBuddy.

The trade-off — operational complexity — is solved by Terraform.

The stack

Layer	Tech
Runtime	Go (Gin), 5-10 MB binaries
Container	Docker, distroless base
Orchestration	AWS ECS Fargate
IaC	Terraform
Networking	ALB + private VPC + AWS PrivateLink
Observability	CloudWatch + OpenTelemetry
Secrets	AWS Secrets Manager

Why Go for small services

Go is 5-10 MB binaries idle at 5 MB of RAM. Python's equivalent service idles at 50 MB. When you pay per MB-hour on Fargate, Go pays for itself.

Why ECS Fargate (not k8s)

Fargate runs containers without managing nodes. For under ~50 services, that is right. k8s pays off above that scale; below it, the operational overhead destroys solo founders.

I covered the whole solo stack in The Solo Founder Stack.

Terraform is the rest of the answer

Every service has a terraform/ directory:

terraform/
  main.tf          # ECS service, task def, IAM
  variables.tf
  outputs.tf

terraform apply reproduces the entire service. New region? Same apply. Disaster recovery? Same apply.

The 80/20 of solo microservices

Do:

One service = one Go binary = one Terraform module
Healthchecks, retries, idempotency in every endpoint
Shared observability stack

Don't:

Service mesh (yet)
Per-service database (use one Postgres until you can't)
Custom platform abstractions

When to merge services

When a 2-service deploy correlation is 90%+, fold them. When data flows mostly in one direction, fold them. The micro in microservice is a guideline, not a law.

I touch on related architecture in Building Context-Heavy and How I Built BikroyBuddy.

FAQ

Q: How many services do you run? A: Around 20 across all products. Each is small.

Q: Is k8s ever worth it solo? A: Rarely. The case is "you have an existing k8s skillset and want to leverage it." Otherwise, Fargate.

Q: What about Cloud Run instead of Fargate? A: Cloud Run is excellent for stateless services with cold-start tolerance. Fargate gives me always-warm instances and tighter VPC control. Choose either.

Written by Shihab Shahriar Antor. Hire me for cloud architecture work at Shahriar Labs.