Cloud Run vs Lambda vs Azure Functions: Cost Comparison

Three serverless platforms, three billing models, very different costs at scale. Here's the honest comparison with real numbers at 5M, 50M, and 500M requests.

By Andrii Votiakov on 2026-02-10

I get asked this question often: "Should we use Lambda, Cloud Run, or Azure Functions?" The honest answer is: it depends on your traffic pattern and which cloud you're already in. But the cost differences are large enough to matter, and some clear rules emerge once you model the numbers. Here's the breakdown I run when a team is choosing or reconsidering their serverless platform.

Quick answer

Lambda wins for event-driven, low-latency, AWS-native workloads. Cloud Run wins for HTTP services with variable traffic, especially at medium-high scale where per-request billing beats per-invocation overheads. Azure Functions wins when you're already in Azure and need deep integration with Service Bus, Blob Storage, or Logic Apps. At less than 1M requests/month, all three are nearly free. At 50M+ requests/month, pricing diverges significantly.

The billing models explained

All three platforms charge on similar axes but with different rates and rounding behaviour.

AWS Lambda charges:

• $0.20 per million invocations (after 1M free/month)
• $0.0000166667 per GB-second (after 400,000 GB-seconds free/month)
• Billed in 1ms increments (since 2021), minimum 1ms

GCP Cloud Run charges:

• $0.40 per million requests (after 2M free/month)
• $0.00002400 per vCPU-second (after 180,000 vCPU-seconds free/month)
• $0.00000250 per GB-second (after 360,000 GB-seconds free/month)
• 100ms minimum billing increment

Azure Functions (Consumption) charges:

• $0.20 per million executions (after 1M free/month)
• $0.000016 per GB-second (after 400,000 GB-seconds free/month)
• 1ms increments, minimum 1ms

On paper, Lambda and Azure Functions look nearly identical. Cloud Run charges more per request but less per GB-second of memory. The split becomes meaningful at scale.

Scenario 1: low traffic API (100k requests/month, 200ms avg, 256 MB)

At this scale, all three platforms are essentially free thanks to generous free tiers.

The free tiers are genuinely useful for small services, dev environments, and internal tools. Pick whichever integrates best with your existing stack.

Scenario 2: medium traffic API (5M requests/month, 300ms avg, 512 MB)

This is where differences start showing up.

Lambda:

• Invocations: (5M - 1M free) × $0.20/M = $0.80
• GB-seconds: 5M × 0.3s × 0.5 GB = 750,000 GB-s; (750,000 - 400,000) × $0.0000166667 = $5.83
• Total: ~$6.63/month

Cloud Run:

• Requests: (5M - 2M free) × $0.40/M = $1.20
• vCPU-seconds: Cloud Run allocates proportional to your container's CPU. Assuming 1 vCPU: 5M × 0.3s = 1.5M vCPU-s; (1.5M - 180k) × $0.000024 = $31.68
• Memory GB-seconds: 5M × 0.3s × 0.5 GB = 750,000 GB-s; (750,000 - 360k) × $0.0000025 = $0.975
• Total: ~$33.85/month

Azure Functions:

• Executions: (5M - 1M free) × $0.20/M = $0.80
• GB-seconds: 5M × 0.3s × 0.5 GB = 750,000 GB-s; (750,000 - 400,000) × $0.000016 = $5.60
• Total: ~$6.40/month

At 5M requests, Lambda and Azure Functions cost roughly the same. Cloud Run is 5x more expensive at this scale because vCPU billing dominates.

Scenario 3: high traffic API (50M requests/month, 150ms avg, 1 GB)

Lambda:

• Invocations: (50M - 1M) × $0.20/M = $9.80
• GB-seconds: 50M × 0.15s × 1 GB = 7.5M GB-s; (7.5M - 400k) × $0.0000166667 = $118.33
• Total: ~$128/month

Cloud Run (with concurrency): Cloud Run handles multiple concurrent requests per container instance, which changes the math considerably. With concurrency set to 80 (Cloud Run's default), one container instance can handle many simultaneous requests, sharing the vCPU billing.

Assuming 80 concurrency, 50 RPS average: actual vCPU-seconds = (50M / 80) × 0.15s = 93,750 vCPU-seconds

• vCPU: 93,750 vCPU-seconds — within the 180,000 free tier, so $0
• Memory: (50M × 0.15s × 1 GB) / 80 = 93,750 GB-seconds — within the 360,000 free tier, so $0
• Requests: (50M - 2M free) × $0.40/M = $19.20
• Total: ~$19-20/month (with good concurrency config)

In practice, a well-configured Cloud Run service at 50M requests/month typically costs $15-40/month depending on actual concurrency achieved.

Azure Functions:

• Same math as Lambda approximately: ~$120/month

Cloud Run's per-request concurrency model makes it dramatically cheaper at high sustained traffic. Lambda and Azure Functions charge per invocation regardless of concurrency on the server side.

Where each platform actually wins

Lambda wins when:

• You need tight AWS service integration (SQS, SNS, DynamoDB Streams, S3 events)
• Sub-10ms cold starts are important (Lambda SnapStart for Java, or small Node/Python functions)
• You need fine-grained per-function memory tuning for cost optimisation
• Event-driven architecture is the primary pattern

Cloud Run wins when:

• You have an existing containerised service (just ship the Docker image)
• Traffic is sustained and concurrent (Cloud Run's concurrency model saves money at scale)
• You need easy multi-region deployment
• You want scale-to-zero with a path to always-on without changing platforms (min-instances: 1)

Azure Functions wins when:

• You're already in Azure and need Service Bus, Blob Storage, or Event Grid triggers
• You need Durable Functions for orchestration (no equivalent on Lambda or Cloud Run without Step Functions/Workflows)
• Your team is .NET-first and wants first-class tooling
• You need on-premises or hybrid connectivity via Azure Arc

The cold start comparison

Cold starts matter for user-facing APIs and less for background processing.

Cloud Run consistently cold-starts slower than Lambda for small functions because it starts a full container. Lambda's execution environment initialisation is lighter. For latency-sensitive applications, Lambda's edge (pun intended) on cold starts is real.

The concurrency model matters

This is the most important difference that pricing tables don't show clearly.

Lambda: 1 invocation = 1 concurrent execution. 100 simultaneous requests = 100 concurrent Lambda instances. You pay for 100 simultaneous executions.

Cloud Run: 1 container = up to 1,000 concurrent requests (default 80). 100 simultaneous requests might be 2 container instances sharing the load. You pay for 2 containers.

Azure Functions Consumption: similar to Lambda, but host-level concurrency can batch event-source triggers.

This concurrency model explains why Cloud Run gets cheaper at scale. The vCPU billing sounds expensive per-unit but gets shared across hundreds of requests.

Decision rules I actually use

1. Already in AWS with event-driven architecture? Lambda. No contest.
2. Existing Docker container you want to deploy serverlessly? Cloud Run.
3. Azure-first team with Service Bus, Logic Apps, or Durable orchestration? Azure Functions.
4. Sustained high-traffic HTTP API, cloud-agnostic? Cloud Run (concurrency model wins).
5. Spiky, unpredictable traffic under 10M requests/month? Any of the three — pick by ecosystem.
6. Need zero cold starts without paying for idle capacity? Lambda with SnapStart (Java) or Cloud Run with min-instances: 1.

For deeper dives into the individual platforms: /blog/lambda-cost-optimisation and /blog/azure-functions-cost-optimisation.

Realistic numbers at different scales

Assumptions: 150-300ms avg duration, 512 MB memory, good concurrency config on Cloud Run.

If you're deciding between platforms, or if you're already committed to one and the bill is bigger than expected, book a call. I'll model your actual traffic against each platform's pricing and show you the numbers.