AWS Lambda vs Google Cloud Run vs Azure Functions — Which Serverless in 2026

Serverless compute is a core part of modern cloud architecture, but each major cloud takes a different approach. AWS Lambda, Google Cloud Run, and Azure Functions have evolved significantly — choosing the wrong one for your use case means hitting limits and paying more than you need to.

Here's the full breakdown.

Quick Comparison

AWS Lambda

Lambda is the most mature serverless platform. It was the first (2014) and has the largest ecosystem.

How it works

You write a handler function. Lambda packages it, manages infrastructure, and scales from 0 to 10,000+ concurrent executions automatically.

def handler(event, context):
    name = event.get('name', 'World')
    return {
        'statusCode': 200,
        'body': f'Hello, {name}!'
    }

Strengths

Deep AWS integration: Lambda connects natively with S3, SQS, DynamoDB, API Gateway, EventBridge, Kinesis, and more. Event-driven architectures on AWS are genuinely excellent.

Lambda@Edge / CloudFront Functions: Run code at edge locations globally — useful for auth, redirects, personalization at CDN layer.

Provisioned concurrency: Pre-warm Lambda instances to eliminate cold starts for latency-sensitive workloads. You pay extra but cold starts become near-zero.

Container image support (up to 10GB): Package ML models, complex dependencies — anything that fits in a container image.

SnapStart (Java): Lambda SnapStart snapshots JVM after initialization, cutting cold starts from 10s to under 1s for Java workloads.

Weaknesses

• 15-minute max execution time (can't run long batch jobs)
• 10 GB memory ceiling (limited for in-memory ML inference)
• Cold starts on VPC-attached functions were historically bad (improved, but still a consideration)
• Vendor lock-in is real — Lambda event bindings are AWS-specific
• Debugging and local development is still more awkward than containers

Pricing (2026)

• $0.20 per 1M requests
• $0.0000166667 per GB-second
• Free tier: 1M requests + 400,000 GB-seconds/month

Google Cloud Run

Cloud Run is container-native serverless. You give it a Docker container, it handles scaling from 0 to N.

How it works

Any container that listens on a port can run on Cloud Run. No framework changes, no SDK required.

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["gunicorn", "--bind", "0.0.0.0:8080", "app:app"]

gcloud run deploy my-service \
  --image gcr.io/my-project/my-service \
  --region us-central1 \
  --allow-unauthenticated

Strengths

Zero vendor lock-in. Standard containers work anywhere. Move to GKE, AWS ECS, or anywhere else without code changes.

60-minute timeout. Much more useful for processing-heavy workloads, video processing, long API calls.

32 GB memory. Run mid-size ML inference models (Mistral 7B with quantization fits).

Faster deployment iteration. Build image → push → deploy is a simple workflow engineers already know.

Jobs support. Cloud Run Jobs run containers to completion — great for batch processing, data pipelines, cron jobs.

CPU always-on option. CPU is only allocated during requests by default, but you can enable CPU always-on — useful for background processing or maintaining WebSocket connections.

Weaknesses

• Cold starts are slower than Lambda (container startup vs function initialization)
• Less deep integration with GCP event sources compared to Lambda on AWS
• More verbose configuration than Lambda for simple event-driven patterns
• Concurrency model (per-container requests) requires understanding to configure properly

Pricing (2026)

• $0.00002400 per vCPU-second
• $0.00000250 per GB-second
• $0.40 per million requests
• Free tier: 2M requests/month, 360,000 vCPU-seconds/month

Azure Functions

Azure Functions has the most tightly integrated enterprise story, especially for .NET workloads and Microsoft ecosystem.

How it works

Multiple hosting plans with different tradeoffs:

• Consumption Plan — true serverless, pay per execution
• Premium Plan — pre-warmed, VNet integration, more power
• Dedicated (App Service) — runs on regular App Service with functions

[FunctionName("HttpExample")]
public static async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequest req,
    ILogger log)
{
    string name = req.Query["name"];
    return new OkObjectResult($"Hello, {name}");
}

Strengths

Durable Functions: Stateful serverless — orchestrations, activity functions, entity functions. Uniquely powerful for complex multi-step workflows without managing state externally.

Microsoft ecosystem integration: Teams, Office 365, SharePoint, Azure Service Bus, Event Hubs — deep integrations out of the box.

Flex Consumption plan (2026): Newer tier with faster cold starts, VNet support, and concurrency controls — closing the gap with Lambda.

.NET performance: If you're a .NET shop, Azure Functions is the most natural home.

Logic Apps integration: Connect functions to no-code workflow automation.

Weaknesses

• 10-minute execution limit on Consumption plan (Premium extends this)
• Cold starts on Consumption plan are still a pain point for latency-sensitive apps
• Developer experience for non-.NET languages is less polished
• More complex pricing with multiple plan tiers

Pricing (2026, Consumption plan)

• $0.20 per 1M executions
• $0.000016 per GB-second
• Free tier: 1M executions/month, 400,000 GB-seconds/month

Cold Start Comparison

Cold starts are the biggest practical concern:

Practical impact: For API endpoints that need <500ms response, provision concurrency (Lambda) or the Premium/always-on option (Cloud Run/Azure).

Which One to Choose

Choose AWS Lambda if:

• You're already on AWS and want tight event source integration
• You need massive scale with AWS ecosystem (SQS → Lambda → DynamoDB pipelines)
• You need Lambda@Edge for CDN-layer logic
• Your workloads are short (under 15 minutes)

Choose Google Cloud Run if:

• You want container-native serverless with zero lock-in
• You have workloads that run 15-60 minutes
• You need large memory (up to 32GB) for ML inference
• You prefer standard Docker workflows
• You're multi-cloud or concerned about portability

Choose Azure Functions if:

• You're a Microsoft/.NET shop
• You need Durable Functions for complex workflows
• You're deeply integrated with Azure Services (Service Bus, Event Hubs)
• Your enterprise uses Microsoft 365 and you want integration there

Multi-cloud teams: Cloud Run's container model is the most portable. Lambda and Azure Functions have more lock-in.

The Real Question: Containers vs Functions

Lambda and Azure Functions push you toward the function-as-unit-of-deployment model. Cloud Run lets you think in containers.

In 2026, the container model is winning mindshare because:

• Same tooling as Kubernetes (Dockerfile, registries)
• Easier local development (just docker run)
• No framework-specific packaging
• Portable across cloud and on-prem

Lambda's event binding ecosystem is still its biggest advantage — nothing else comes close for AWS-native event-driven architectures.

Related: AWS VPC Networking Guide | KEDA Event-Driven Autoscaling

Affiliate note: AWS Lambda free tier covers 1M requests/month — plenty for getting started. Google Cloud Run free tier includes 2M requests/month with no credit card required to start.