AWS Lambda vs Fargate cost calculator: the serverless vs containers break-even point

How it is calculated

M = 2,592,000 s (a 30-day month)    R = rps × M requests
T = duration ÷ 1000 s    m = memory_mb ÷ 1024 GB
L = rps × T requests in flight (× peak_to_avg_ratio in static_peak mode)

C_L = R ÷ 10^6 × r_req + R × T × m × r_gbs

n = max(min_containers, ceil(L ÷ (cc × u)))
cc = concurrency per container, u = target utilization as a fraction
utilization = (rps × T) ÷ (n × cc)

C_F = n × 720 × (v′ × r_vcpu_hour + m′ × r_gb_hour)
(v′, m′) = the cheapest valid Fargate vCPU and memory pair at or above (vCPU, m)

C_R = (R × T ÷ cc) × (v × r_cpu_s + m × r_mem_s)
    + R ÷ 10^6 × r_req
    + min_containers × M × (v × r_idle_cpu_s + m × r_idle_mem_s)

per instance = floor(0.85 × min(instance vCPU ÷ v, instance GiB ÷ m))
instances = max(2, ceil(n ÷ per instance))
C_V = instances × 720 × hourly rate

Evaluate every platform at 120 log-spaced request rates from 0.1 to 10,000 per second (widened to include your rate).
Break-even = the lowest rate above which the cheapest container platform (Fargate, VM cluster) stays cheaper than the cheapest serverless one (Lambda, Cloud Run) to the end of the range.
If containers scale in steps and the lead changes more than once, the first crossing is shown as well.

Assumptions

• A month is 30 days (2,592,000 seconds, 720 hours) for every platform. Traffic is the monthly average; spikes only change container counts in static_peak mode.
• Containers are sized from requests in flight (Little's law) at the target utilization, with a minimum container count for availability. Utilization shown is average load divided by capacity.
• Lambda is priced at list request and GB-second rates in US East (N. Virginia). Higher-volume duration tiers, provisioned concurrency and the extra cost of memory-driven CPU are not modelled.
• Fargate is priced on Linux tasks in US East (N. Virginia). The vCPU and memory pair is rounded up to the cheapest valid combination in the dataset.
• Cloud Run is priced with request-based billing at Tier 1 (us-central1) rates: busy instance-seconds are requests × duration ÷ concurrency, and the minimum instances are billed at idle rates for the whole month on top. The free allowance, when on, is taken off the busy usage and the request count.
• The VM cluster stands in for Kubernetes nodes you run yourself: always-on instances at on-demand rates, 85% of each instance usable by containers, at least 2 instances. Control-plane fees, storage and networking are not included.
• Prices are list prices in USD with no savings plans, Spot, committed-use or negotiated discounts. API gateway, load balancer, data transfer, NAT and logging charges are excluded.
• The Arm option changes the Lambda and Fargate rates. Cloud Run has one rate, and the VM follows the instance you choose.

The data behind it

Three ways to reduce this number

1. Use arm64 where the dataset shows a lower rate: switch the architecture above and compare the Lambda and Fargate rows.
2. Right-size memory. More memory often shortens duration enough to lower the Lambda bill, so sweep memory and test your function at a few sizes.
3. Raise container concurrency so fewer, fuller containers carry the load, and keep the minimum container count no higher than your availability needs.

Use it from code

The same engine is available as a REST endpoint and as an MCP tool named calc_serverless_vs_containers_breakeven. Your scenario as an API call:

curl -X POST 'https://api.x12i.com/v1/calc/serverless-vs-containers-breakeven' \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
  "input": {
    "requests_per_second": 20,
    "peak_to_avg_ratio": 3,
    "avg_duration_ms": 120,
    "memory_mb": 512,
    "vcpu_per_task": 0.5,
    "arch": "x86",
    "concurrency_per_container": 10,
    "target_utilization_pct": 60,
    "min_containers": 2,
    "scaling_mode": "follows_load",
    "platforms": [
      "lambda",
      "fargate",
      "cloud_run",
      "vm_cluster"
    ],
    "include_free_tier": false,
    "vm_instance": "m7i.xlarge",
    "current_platform": "none",
    "migration_stage": "evaluating"
  },
  "options": {
    "explain": false
  }
}'

Copy as API call Schema: GET /v1/calc/serverless-vs-containers-breakeven/schema

Frequently asked questions

Related calculators