AWS gives you three ways to run your code in the cloud:

1. Lambda - upload a function, AWS runs it when events happen
2. ECS (Elastic Container Service) - run Docker containers, AWS manages the servers
3. EKS (Elastic Kubernetes Service) - run Kubernetes, AWS manages the control plane

All three are production-ready. All three scale. All three integrate with every other AWS service. And all three are a perfectly valid answer to "where should I deploy my web app?"

So which one do you choose?

After deploying across all three (and building TurboDeploy on top of ECS), here's the honest comparison we wish existed when we started.

The Quick Answer

If you're too busy to read the full post:

Now let's look at why.

AWS Lambda - The Event Machine

What It Is

Lambda runs your code in response to events without you managing any servers. You upload a function (a zip file or container image), configure a trigger (HTTP request, S3 upload, SQS message, cron), and AWS handles everything else: provisioning, scaling, patching, and monitoring.

The Good

• Zero infrastructure management : no servers, no containers, no clusters
• Scales to zero : if nobody is using your app, you pay nothing
• Instant horizontal scaling : each request gets its own execution environment
• Generous free tier : 1 million requests + 400,000 GB-seconds per month, forever
• Sub-second billing : charged per millisecond of execution time
• Deep AWS integration : triggers from S3, DynamoDB, SQS, API Gateway, EventBridge

The Bad

• 15-minute maximum timeout : if your function runs longer, it gets killed. No exceptions.
• Cold starts : first invocation after idle takes 100ms–2s extra latency (runtime-dependent)
• Limited compute : max 10 GB memory, 6 vCPUs per function
• Stateless : no persistent local storage between invocations
• Vendor lock-in : Lambda functions are tightly coupled to AWS's event model
• INIT phase billing : since August 2025, AWS charges for the initialization phase too
• Debugging is harder : no SSH, no docker exec, limited local dev experience

Lambda Pricing (us-east-1)

Real-world example: An API handling 5 million requests/month at 200ms avg, 512 MB memory:

Requests:  5M × $0.20/M  = $1.00
Duration:  5M × 200ms × 0.5 GB × $0.0000000083/ms = $4.15
Monthly total: ~$5.15

Lambda is remarkably cheap at low-to-moderate volume.

When Lambda Breaks Down

Lambda's economics flip at high, steady traffic. The same workload at 50 million requests/month:

Requests:  50M × $0.20/M  = $10.00
Duration:  50M × 200ms × 0.5 GB × $0.0000000083/ms = $41.50
Monthly total: ~$51.50

Meanwhile, an ECS Fargate task running 24/7 at 1 vCPU / 2 GB could handle that same throughput for ~$43/mo and without cold starts.

The rule: Lambda is cheapest for bursty, low-volume traffic. For steady 24/7 workloads, containers win.

Best Use Cases for Lambda

Amazon ECS Fargate: The Middle Ground

What It Is

ECS (Elastic Container Service) runs Docker containers on AWS. With Fargate as the launch type, you don't manage any EC2 instances, you define your container, specify how much CPU and memory it needs, and AWS handles the rest.

Think of it as: "Docker containers as a managed service."

The Good

• No servers to manage - Fargate provisions and manages the compute
• No control plane fee - ECS itself is free (you only pay for Fargate compute)
• Full Docker support - run any container (any language, any framework)
• Always warm - no cold starts; your containers are running 24/7 (or auto-scaled)
• No timeout limits - run processes for hours, days, months
• Deep AWS integration - ALB, CloudWatch, IAM, Secrets Manager, all native
• Auto-scaling - scale based on CPU, memory, request count, or custom metrics
• Simpler than Kubernetes - task definitions instead of YAML manifests

The Bad

• Doesn't scale to zero - minimum 1 task always running (you pay even if idle)
• Slower scale-up - new Fargate tasks take 30–60 seconds to provision
• AWS-specific - ECS APIs are not Kubernetes-compatible (not portable)
• Still requires some ops knowledge - task definitions, networking, ALB configuration
• No built-in CI/CD - you bring your own deployment pipeline

ECS Fargate Pricing (us-east-1)

Real-world example: A typical web app (1 vCPU, 2 GB RAM, running 24/7):

Compute:  $29.50 (vCPU) + $6.50 (RAM) = $36.00/mo
ALB:      ~$22/mo (load balancer + LCU)
Total:    ~$58/mo for a production-grade deployment

With Compute Savings Plans (1-year commit): ~$25/mo for compute which is a 30% discount.

What Makes ECS the Default for Web Apps

Best Use Cases for ECS

Amazon EKS: Full Kubernetes on AWS

What It Is

EKS (Elastic Kubernetes Service) runs a managed Kubernetes control plane on AWS. You define your workloads using standard Kubernetes manifests (YAML), and EKS manages the master nodes, the API server, and etcd. You bring the worker nodes (EC2 or Fargate).

The Good

• Standard Kubernetes - same API as on-prem, GKE, AKS; truly portable
• Massive ecosystem - Helm, ArgoCD, Istio, KEDA, Prometheus, Operators - all work
• Maximum flexibility - custom schedulers, sidecars, init containers, service mesh
• Multi-cluster/multi-region - sophisticated deployment topologies
• Strong community - Kubernetes is the standard for container orchestration at this point
• Granular scaling - HPA (Horizontal Pod Autoscaler), VPA (Vertical), KEDA (event-driven)
• Infrastructure as Code - fully Terraform/Pulumi/CDK compatible

The Bad

• $73/month just for the control plane - before you run a single container. Per cluster.
• Steep learning curve - Pods, Deployments, Services, Ingress, RBAC, ConfigMaps, Secrets, Namespaces, Operators. It's a LOT of concepts.
• "YAML hell" - even a simple deployment requires 100+ lines of YAML manifests
• Operational overhead - cluster upgrades, node group management, add-on compatibility
• Requires dedicated expertise - realistically, you need someone on the team who knows Kubernetes
• Slow to iterate on - more moving parts = more things to debug
• Overkill for most startups - you're paying the "Kubernetes tax" in both money and engineering time

EKS Pricing (us-east-1)

Real-world example: Same web app (1 vCPU, 2 GB RAM) on EKS with Fargate:

Control plane:  $73.00/mo (unavoidable)
Compute:        $36.00/mo (same Fargate pricing as ECS)
ALB/Ingress:    ~$22/mo
Total:          ~$131/mo

That's $73/month more than ECS for the exact same workload. The Kubernetes control plane is a fixed tax.

The "Team Size" Rule

Here's the uncomfortable truth about EKS:

The exception: If your team already knows Kubernetes deeply (ex-Google, ex-large-enterprise), EKS is fine at any team size. The problem isn't Kubernetes itself, it's the learning curve when your team doesn't have the expertise.

Best Use Cases for EKS

Head-to-Head Comparison

Architecture & Deployment

Scaling

Networking

Observability

The Cost Breakdown (Real Numbers)

Scenario 1: Low-Traffic API (1M requests/month)

Winner: Lambda. For low-traffic, bursty APIs, nothing beats it on price.

Scenario 2: Steady-Traffic SaaS App (10M requests/month)

Winner: ECS Fargate : Lambda's per-request pricing catches up and ECS has no cold starts.

Scenario 3: High-Traffic Platform (100M requests/month)

Winner: ECS Fargate : Lambda is 4.7x more expensive. The "pay per request" model punishes high-volume workloads.

Scenario 4: The Hybrid Approach

Most mature architectures combine services:

Core API (steady traffic)         → ECS Fargate  ($58/mo)
Image processing (S3 triggers)    → Lambda       ($3/mo)
Nightly data export (cron)        → Lambda       ($0.50/mo)
Background email sending (SQS)    → Lambda       ($1/mo)
                                    Total: $62.50/mo

You get always-warm containers for latency-sensitive APIs and scale-to-zero functions for event-driven tasks. Best of both.

The Hidden Cost: Engineering Time

Pricing isn't just about AWS bills. There's an engineering cost too:

If your engineering team costs $150/hour, the EKS operational overhead (~20 hrs/mo extra) is an additional $3,000/month in engineering time. That's the real "Kubernetes tax."

When to Migrate Between Services

Lambda → ECS (Most Common Migration Path)

Signs it's time:

• Your Lambda bill exceeds your projected Fargate cost
• You're hitting the 15-minute timeout
• Cold starts are impacting user experience
• You need WebSocket connections
• You need persistent local state or large memory

Migration effort: Medium (1–2 weeks). You need to:

1. Containerize your app
2. Deploy to ECS
3. Update your API Gateway to point to the ALB (or replace with ALB)

ECS → EKS (Less Common, Higher Stakes)

Signs it's time:

• You need multi-cloud portability (running on AWS + GCP/Azure)
• You have 50+ microservices and need a service mesh
• Your team has deep Kubernetes expertise
• You're investing in a full internal developer platform
• Compliance requires Kubernetes-native policy engines

Migration effort: High (1–3 months). You need to:

1. Convert ECS task definitions to Kubernetes Deployments/Services
2. Replace ALB with Ingress controller
3. Set up cluster monitoring (Prometheus/Grafana)
4. Train the team on Kubernetes operations

Our honest opinion: If you're considering ECS → EKS, first ask: "Is there a specific Kubernetes feature I need that ECS doesn't provide?" If the answer is vague ("flexibility" or "it's the industry standard"), you probably don't need EKS yet.

The Decision Framework

Choose Lambda If:

• ✅ Tasks are event-driven (S3 triggers, SQS, webhooks)
• ✅ Execution time is under 15 minutes
• ✅ Traffic is bursty or unpredictable
• ✅ You want zero ops burden
• ✅ Monthly request volume is under 10 million
• ❌ NOT for: WebSockets, long-running processes, high-volume steady APIs

Choose ECS Fargate If:

• ✅ You're building a web app, API, or microservice
• ✅ Traffic is steady or predictable
• ✅ You need no timeout limits
• ✅ Your team is 1–15 engineers
• ✅ You want AWS-native simplicity
• ✅ You're coming from Heroku/Railway/Render
• ❌ NOT for: Event-driven functions (use Lambda) or complex multi-cloud K8s

Choose EKS If:

• ✅ You require Kubernetes-specific features (operators, CRDs, service mesh)
• ✅ You have a dedicated platform/DevOps team
• ✅ You need multi-cloud portability
• ✅ You're running 30+ microservices at scale
• ✅ You're migrating from on-prem Kubernetes
• ❌ NOT for: Small teams, simple web apps, cost-sensitive startups

What We Chose (And Why)

At TurboDeploy, we deploy your apps on ECS Fargate. Here's why:

1. No control plane cost : ECS is free. The $73/mo EKS tax can't be justified for our users' workloads.
2. Simpler is better : our startup users don't need Kubernetes. They need git push → running app.
3. Docker-native : a Dockerfile is all you need. No YAML manifests, no Helm charts, no operators.
4. Full AWS integration : ALB, HTTPS, IAM roles, auto-scaling, CloudWatch - all "just work" with ECS.
5. Migration path exists : if a user outgrows ECS, migrating to EKS is straightforward because the Docker images are the same.

We use Lambda for internal automation (webhook processing, cron cleanup tasks, notification delivery) where scale-to-zero makes sense.

We don't use EKS. Not because it's bad but because it solves problems we (and most of our users) don't have.

TL;DR

Don't want to think about compute choices? TurboDeploy deploys your app on ECS Fargate with ALB, HTTPS, auto-scaling, and monitoring set up for you. Connect your repo and go.

Start deploying