Direct answer: for us-east-1, Linux x86, 730 hours/month, 200 ms per request and Lambda 1,769MB≈1 vCPU, 2026 monthly costs are roughly: 10M requests, Lambda x86 60.97, Lambda ARM 49.18 and Fargate 1 vCPU/2GB 36.04; 5M requests, Lambda x86 30.48, ARM 24.59 and Fargate 36.04; 20M requests, Lambda x86 121.94, ARM 98.36 and Fargate 2 vCPU/4GB 72.08. The break-even is about 5.9M requests/month (x86) or 7.3M (ARM): below that, Lambda’s per-request/GB-s model is cheaper; above it, Fargate’s always-on 1 vCPU/2GB is cheaper. But Fargate charges for always-on capacity, while Lambda charges for requests, GB-s and concurrency/cold starts; calculate “requests × duration × memory” and “how many always-on vCPUs you need” first.
This guide is for engineering, platform and procurement teams choosing an AWS compute model or moving scheduled jobs/APIs from Lambda to containers or back. Data cut-off: 5 November 2026; prices are AWS US East (N. Virginia, us-east-1) public Lambda/Fargate pricing and the AWS Price List API, in USD, excluding tax; the TCO is an editorial calculation, not an AWS quote. Lambda and Fargate bill differently: Lambda is “requests + GB-s”, Fargate is “vCPU hours + GB hours”; this article uses 1,769MB≈1 vCPU for equivalence, while actual CPU varies with memory configuration.
Lambda x86 is 0.20 per million requests + 0.0000166667/GB-s; ARM is 0.0000133334/GB-s. Fargate x86 is 0.04048/vCPU-hour + 0.004445/GB-hour; ARM is 0.03238 + 0.00356. At 1,769MB≈1 vCPU, Lambda at full load is about 0.106/vCPU-hour, while Fargate 1 vCPU/2GB is about 0.049/vCPU+2GB-hour; Fargate’s unit compute is cheaper, but it runs 24/7. Low-volume/bursty: Lambda; stable high utilization: Fargate.
Two billing models: requests + GB-s, vCPU + GB hours
Lambda: 0.20 per million requests; x86 0.0000166667 per GB-s, ARM 0.0000133334; 1M requests + 400,000 GB-s free per month; Provisioned Concurrency is separate (x86 0.0000041667/GB-s, ARM 0.0000033334/GB-s). Fargate: x86 0.04048 per vCPU-hour and 0.004445 per GB-hour; ARM 0.03238 and 0.00356; Windows is higher; Ephemeral Storage beyond the included amount is separate (0.000111/GB-hour); minimum 0.25 vCPU/0.5GB. The “hour” is not the same: Lambda bills only while executing, Fargate bills from task start to stop.
| Platform | Billing unit | Entry/free | x86 | ARM | Billing boundary |
|---|---|---|---|---|---|
| Lambda | Requests + GB-s | 1M requests + 400k GB-s/month | 0.20/million requests; 0.0000166667/GB-s | 0.20/million requests; 0.0000133334/GB-s | Per execution ms; Provisioned separate |
| Fargate | vCPU hours + GB hours | Minimum 0.25 vCPU/0.5GB | 0.04048/vCPU-h; 0.004445/GB-h | 0.03238/vCPU-h; 0.00356/GB-h | Task running time; Ephemeral separate |
Sources: AWS Lambda Pricing, AWS Fargate Pricing and the AWS Price List API (AWSLambda, AmazonECS, October 2026 publication). Accessed 5 November 2026; USD, excluding tax; Lambda free tier is monthly; Fargate Windows/Ephemeral/Spot are separate and this article only models Linux x86/ARM vCPU+memory.
Normalize the units: cost per vCPU-hour
At 1,769MB≈1 vCPU: Lambda x86 at full load is 1.769GB×3,600s×0.0000166667 = 0.1061 per vCPU-hour; ARM is 0.0849. Fargate 1 vCPU/2GB per hour is 0.04048 + 2×0.004445 = 0.04937; vCPU alone is 0.04048 plus 0.00889 memory. Fargate’s vCPU rate is about 38% of Lambda x86 and 48% of ARM, but Fargate bills 24/7 while Lambda bills only during execution. For a same-architecture comparison, Lambda is cheaper below about 47% utilization; Fargate x86 versus Lambda ARM is about 58%.
| Basis | Lambda x86 | Lambda ARM | Fargate x86 1vCPU/2GB | Fargate ARM 1vCPU/2GB |
|---|---|---|---|---|
| Per vCPU-hour | 0.1061 | 0.0849 | 0.04048 + memory | 0.03238 + memory |
| Per vCPU+2GB-hour | About 0.1061 (1.769GB) | About 0.0849 | 0.04937 | 0.03950 |
| 730 hours/month | 77.48 (full load) | 61.98 (full load) | 36.04 | 28.84 |
| Billing | Only while executing | Only while executing | While the task runs | While the task runs |
Editorial calculation, not a quote. Lambda 1,769MB≈1 vCPU is a common configuration mapping and actual CPU varies with memory; Fargate 1 vCPU/2GB assumes 730 hours/month; Lambda full load assumes 730 hours of execution and excludes request/Provisioned charges; Fargate excludes Ephemeral Storage, logs, NAT, egress and tax.
10M / 5M / 20M requests: monthly TCO
At 200 ms per request, 1,769MB, Linux x86/ARM: 10M requests, Lambda x86 60.97, ARM 49.18; Fargate 1 vCPU/2GB 36.04. 5M requests, Lambda x86 30.48, ARM 24.59; Fargate 36.04. 20M requests, Lambda x86 121.94, ARM 98.36; Fargate 2 vCPU/4GB 72.08 (1 vCPU lacks capacity). About 5.9M requests/month is the x86 break-even and about 7.3M for ARM; below it Lambda saves, above it Fargate saves.
| Monthly requests (200ms) | Lambda x86 | Lambda ARM | Fargate x86 | Lowest |
|---|---|---|---|---|
| 1M | 6.10 | 4.92 | 36.04 (1vCPU/2GB) | Lambda ARM |
| 5M | 30.48 | 24.59 | 36.04 (1vCPU/2GB) | Lambda ARM |
| 10M | 60.97 | 49.18 | 36.04 (1vCPU/2GB) | Fargate |
| 20M | 121.94 | 98.36 | 72.08 (2vCPU/4GB) | Fargate |
Editorial calculation, not a quote. Lambda = requests×0.20/million + requests×0.2s×1.769GB×GB-s rate; Fargate = vCPU×730×0.04048 + GB×730×0.004445; 10M/5M use 1vCPU/2GB and 20M uses 2vCPU/4GB to cover average concurrency; excludes free tier, Provisioned Concurrency, storage, logs, NAT, egress and tax. Fargate capacity uses average concurrency; peak needs headroom.
Break-even: how much Fargate, how many Lambda requests
Fargate 0.25 vCPU/0.5GB is 9.01/month, 0.5 vCPU/1GB 18.02, 1 vCPU/2GB 36.04 and 2 vCPU/4GB 72.08 (730 hours). At 200ms/1,769MB: x86 costs about 0.00000610 per request and ARM about 0.00000492; break-even is about 1.48M (x86)/1.83M (ARM) at 0.25, 2.96M/3.66M at 0.5, 5.91M/7.33M at 1 and 11.82M/14.65M at 2. This is not “Fargate is always cheaper”; it is “at that capacity, Fargate is cheaper only above the break-even request volume”.
| Fargate size | Monthly cost (730h) | x86 break-even requests/month | ARM break-even requests/month | Fit |
|---|---|---|---|---|
| 0.25 vCPU / 0.5GB | 9.01 | About 1.48M | About 1.83M | Very light/low concurrency |
| 0.5 vCPU / 1GB | 18.02 | About 2.96M | About 3.66M | Small API/scheduled jobs |
| 1 vCPU / 2GB | 36.04 | About 5.91M | About 7.33M | Regular API/worker |
| 2 vCPU / 4GB | 72.08 | About 11.82M | About 14.65M | Higher concurrency |
Editorial calculation, not a quote. Break-even requests = Fargate monthly cost / (0.2s×1.769GB×Lambda GB-s rate + 0.20/million requests); excludes Lambda free tier, Provisioned Concurrency, Fargate peak headroom/auto-scaling, logs/storage/egress/tax. Fargate 0.25/0.5/1/2 vCPU are common sizes; actual combinations follow AWS.
Hidden costs: requests, Provisioned, storage, NAT, logs
Lambda hidden items: request fees, Provisioned Concurrency (x86 0.0000041667/GB-s, ARM 0.0000033334/GB-s), GB-s while provisioned, CloudWatch logs, egress/NAT, EFS//tmp. Fargate hidden items: Ephemeral Storage beyond 20GB at 0.000111/GB-h, CloudWatch logs, NAT Gateway/data processing, egress, ALB, ECR, Secrets and Fargate Spot discounts (not modelled). All three exclude tax, support, CI/CD and migration; Fargate also pays for idle capacity, Lambda pays for cold starts/concurrency limits.
| Item | Lambda | Fargate |
|---|---|---|
| Requests/invocations | 0.20/million; 1M free/month | No per-request fee; task running time billed |
| Reserved/always-on | Provisioned Concurrency separate | Always-on vCPU/memory; idle billed |
| Ephemeral storage | /tmp 512MB–10GB; EFS separate | From 20GB; excess 0.000111/GB-h |
| Network/logs | NAT/egress, CloudWatch separate | NAT/egress, ALB, CloudWatch separate |
| Tax/support/migration | Excluded | Excluded |
Sources: AWS Lambda Pricing, AWS Fargate Pricing and the AWS Price List API (AWSLambda, AmazonECS). Accessed 5 November 2026; USD, excluding tax; “separate” means confirm on the product page/actual usage and is not guessed here; the 20GB Fargate ephemeral default depends on task configuration.
Which option fits which scenario?
Low-volume/bursty/event-driven: Lambda; stable high utilization/always-on services/long connections or large memory: Fargate; precise vCPU/memory ratios and acceptable idle: Fargate; millisecond cold starts/per-request billing: Lambda (Provisioned extra); ARM savings: both support it, Lambda ARM GB-s is 20% lower and Fargate ARM vCPU/GB is about 20% lower. For a small team with
| Scenario | First choice | Why | Watch |
|---|---|---|---|
| Low-volume/bursty/events | Lambda | Pay only for execution; free tier | Cold starts/concurrency/15-minute limit |
| Stable high-utilization API | Fargate | Low vCPU rate, predictable always-on | Idle billed; leave peak headroom |
| Long connections/WebSocket | Fargate | Persistent process/connections | Scaling/connection draining |
| Batch/scheduled | Lambda or Fargate | Short jobs Lambda; long jobs Fargate | 15-minute/memory/tmp limits |
| ARM savings | Both ARM | Lambda GB-s 20% lower; Fargate vCPU/GB about 20% lower | Dependency/image compatibility |
Sources: AWS Lambda/Fargate Pricing and Price List API (accessed 5 November 2026). This is an editorial decision matrix, not AWS advice; actual cold starts, concurrency limits, long-connection behavior, ARM compatibility and migration effort were not tested.
What should procurement and acceptance specify?
At least eight things: monthly/peak requests, average/P95 duration, memory/vCPU, concurrency/cold start, always-on hours, ephemeral storage, network/logs/egress and free-tier/Provisioned/Spot. Use a 2–4 week POC with real traffic and record P50/P95/P99, cold starts, errors, concurrency, vCPU/memory, requests, GB-s and the bill; do not compare only “per million requests” or “per vCPU-hour”.
- Requests/duration: monthly/peak, average/P95 ms; Lambda bills per 1 ms, and long tails amplify.
- Memory/vCPU: Lambda memory determines CPU; Fargate vCPU/memory combinations; select by real P95.
- Concurrency/always-on: Lambda concurrency/cold starts; Fargate always-on/scaling; leave peak headroom.
- Ephemeral storage: Lambda /tmp, EFS; Fargate 20GB+Ephemeral.
- Network/logs: NAT, egress, ALB, CloudWatch, Secrets, ECR.
- Free/reserved: Lambda free tier/Provisioned; Fargate Spot/Savings Plans.
- Compatibility: ARM images/dependencies, runtime, 15-minute/connection limits.
- POC: 2–4 weeks of real traffic; record P50/P95/P99, cold starts, concurrency, CPU/memory and the bill.
FAQ
5M requests/month: Lambda or Fargate?
At 200ms/1,769MB: Lambda x86 30.48, ARM 24.59; Fargate 1vCPU/2GB 36.04. Below about 5.9M (x86)/7.3M (ARM) requests, Lambda is cheaper; ARM is lowest.
What about 10M requests/month?
Lambda x86 60.97, ARM 49.18; Fargate 1vCPU/2GB 36.04. Above the break-even, Fargate is cheaper, but confirm 1 vCPU covers peak concurrency or add size/replicas.
What about 20M requests/month?
Lambda x86 121.94, ARM 98.36; Fargate 2vCPU/4GB 72.08. The higher the request volume, the more Fargate’s always-on capacity is amortized; if peak is far above average, Lambda’s elasticity may still fit better.
Why is Fargate’s vCPU rate lower but not always cheaper?
Fargate bills 24/7, including idle time; Lambda bills only during execution. Fargate 1 vCPU/2GB is 36.04/month; Lambda at full 1 vCPU load is 77.48. For a same-architecture comparison, Lambda is cheaper below about 47%; Fargate x86 versus Lambda ARM is about 58%.
How much cheaper is Lambda ARM?
GB-s 0.0000133334 vs 0.0000166667, about 20% lower; requests are the same. At 10M requests/200ms/1,769MB, ARM is 49.18 vs x86 60.97. Confirm arm64 dependencies/images.
How much cheaper is Fargate ARM?
vCPU 0.03238 vs 0.04048 and GB 0.00356 vs 0.004445, about 20% lower; 1vCPU/2GB is 28.84 vs 36.04. Images/dependencies must support arm64.
Should Provisioned Concurrency be included?
Yes. Provisioned Concurrency adds x86 0.0000041667/GB-s and ARM 0.0000033334/GB-s, charged while provisioned; this article’s Lambda price excludes it, so cold-start-sensitive APIs must add it.
What other hidden costs exist?
Lambda: requests, Provisioned, CloudWatch, NAT/egress, EFS//tmp; Fargate: ephemeral above 20GB, ALB, NAT/egress, CloudWatch, ECR/Secrets. All exclude tax, support, CI/CD and migration.
Research method and limitations
This article separates “official facts” from “editorial modelling”: Lambda request/GB-s, Fargate vCPU/GB-hour, free tier/Provisioned prices come from the AWS official pricing pages and the Price List API (AWSLambda, AmazonECS, us-east-1); the 10M/5M/20M-request TCO is arithmetic under 200ms, 1,769MB≈1 vCPU and 730 hours/month, not an AWS quote. It does not compare actual cold starts, concurrency limits, long-connection behavior, ARM compatibility or migration effort.
Eight limitations: (1) only us-east-1 public list prices are used, excluding tax, discounts, Savings Plans/Spot/private pricing; (2) 1,769MB≈1 vCPU is a common mapping and actual CPU varies with memory; (3) only Lambda requests+GB-s and Fargate vCPU+memory are counted, excluding free tier, Provisioned, Ephemeral, logs, NAT, egress, ALB, ECR/Secrets; (4) Fargate capacity is estimated from average concurrency, while peak/scaling changes the size; (5) only Linux x86/ARM are modelled; (6) 15-minute/memory/tmp/concurrency limits were not tested; (7) EC2/Spot/Kubernetes/App Runner alternatives were not compared; (8) real performance, cold starts, availability and migration cost were not tested. Treat this as a unit-alignment template and replace assumptions with a 2–4 week real-traffic POC.
Sources and basis
- AWS, Lambda Pricing: aws.amazon.com/lambda/pricing. Requests 0.20/million; x86 GB-s 0.0000166667, ARM 0.0000133334; 1M requests + 400k GB-s free/month; Provisioned x86 0.0000041667/GB-s, ARM 0.0000033334/GB-s. Accessed 5 November 2026.
- AWS, Fargate Pricing: aws.amazon.com/fargate/pricing. x86 0.04048/vCPU-h, 0.004445/GB-h; ARM 0.03238, 0.00356; Windows/Ephemeral separate; minimum 0.25 vCPU/0.5GB. Accessed 5 November 2026.
- AWS Price List API, AWSLambda (current): pricing.us-east-1.amazonaws.com/.../AWSLambda/current/index.json. us-east-1 request/GB-s/Provisioned prices. Accessed 5 November 2026.
- AWS Price List API, AmazonECS (current): pricing.us-east-1.amazonaws.com/.../AmazonECS/current/index.json. us-east-1 Fargate x86/ARM/Windows/Ephemeral prices. Accessed 5 November 2026.
Data cut-off 5 November 2026; prices are public list prices excluding tax; all models are editorial calculations. This is not procurement advice.