Cloudflare Workers wins when latency matters and your code fits the V8-isolate model: edge APIs, transformations, A/B routing, lightweight backends. AWS Lambda wins when you need a full Linux runtime, deep AWS integration, or the long-tail of languages and native modules. Most apps end up using both — Workers at the edge for cold-path-sensitive surfaces, Lambda for everything else.
Cloudflare Workers
V8 isolates at the edge. Sub-millisecond cold start, ~300 PoPs.
These aren't the same shape of tool even though both are "serverless functions". A Worker is a V8 isolate that starts in under 5 ms and runs at the closest data centre to the user. A Lambda is a containerised function that takes 50-500 ms to cold-start and runs in a single AWS region. Workers trade flexibility for proximity and speed; Lambda trades latency for capability and ecosystem.
Quick takes
If you're…
You're fronting an existing origin with edge logic (A/B, auth, rewrites)→CF WorkersThis is exactly what Workers were built for. Run code before the request hits your origin.
You need to run Python with NumPy or a native compiled module→LambdaWorkers run V8 isolates only; no Python, no native modules. Lambda runs anything.
Cold start is on your SLO→CF Workers~5 ms vs 50-500 ms. Massive win for user-facing paths.
You're deeply integrated with AWS (SQS, S3, RDS in VPC)→LambdaLambda's IAM + VPC integration is unmatched. Workers can call AWS but it's outside-in.
You need to run for more than 5 minutes→LambdaWorkers have a 30-second CPU time limit. Lambda goes up to 15 minutes.
You want to serve from 300+ data centres globally with no config→CF WorkersWorkers run at every Cloudflare PoP automatically. Lambda is single-region (or use Lambda@Edge with limitations).
You're building API endpoints under 1 ms response time→CF WorkersEdge proximity + isolate startup math. Lambda's round-trip from US-East alone is often slower.
You need to call a relational DB inside a VPC→LambdaLambda + VPC + RDS works. Workers can connect via Hyperdrive or AWS public endpoints but it's more setup.
V8 isolates. Each request gets a lightweight V8 context that shares the engine with other isolates. Sub-millisecond startup. Memory limited to ~128 MB.
Lambda
Full Linux runtime (Amazon Linux 2 / 2023). Each cold start spins up a microVM (Firecracker), boots the runtime, loads the function. 50-500 ms cold start typical. Up to 10 GB memory.
core
Language support
edge: Lambda
CF Workers
JavaScript, TypeScript, WASM (any language that compiles to WASM — Rust, Go via TinyGo, C++ via Emscripten). Python via Pyodide (beta). No native modules.
Lambda
Node.js, Python, Java, .NET, Go, Ruby, custom runtimes via container images. Native modules work. Anything you can run on Linux runs on Lambda.
core
Cold start
edge: CF Workers
CF Workers
~5 ms typical. The isolate-per-request model means there is functionally no cold start in the way other platforms have one.
Lambda
50 ms (Node) to 500+ ms (Java with cold JVM). Provisioned concurrency mitigates but costs money. SnapStart helps for Java specifically.
features
Geographic distribution
edge: CF Workers
CF Workers
Runs in every Cloudflare data centre — ~300 PoPs across 100+ countries. Code runs near every user automatically, no configuration.
Lambda
Single-region by default. Lambda@Edge runs at CloudFront edge but with limitations (no env vars, smaller code, 5s timeout). Multi-region active-active requires real architecture work.
features
Platform integration
edge: Lambda
CF Workers
Workers Bindings: KV, R2, D1, Queues, Durable Objects, Vectorize, Hyperdrive, AI Workers. All Cloudflare's own services, well-integrated. Outside the CF ecosystem, you're using HTTP.
Lambda
Deep AWS integration. IAM, VPC, SQS, SNS, EventBridge, S3, DynamoDB, RDS Proxy, Kinesis — all native. Triggers from any AWS event source.
ops
Pricing model
depends
CF Workers
$5/mo for 10M requests + $0.30/M after. Workers Paid plan removes the 100k/day free tier limit. CPU time is metered separately on Unbound plan.
Lambda
$0.20/M requests + $0.0000166667/GB-second compute. The free tier (1M requests + 400K GB-seconds/month) is generous. Costs compound on chatty workloads.
ops
Tooling
edge: CF Workers
CF Workers
Wrangler CLI is excellent. Dev mode runs Workers locally with miniflare. Deploy is a single command. GitHub integration via the dashboard.
Lambda
AWS SAM, Serverless Framework, AWS CDK, Architect. Many options, each opinionated. Local dev is harder (LocalStack helps).
core
Limits
edge: Lambda
CF Workers
30 s CPU time (Unbound), 50 sub-requests per request, 128 MB memory, 10 ms CPU per request on Free / Bundled.
Lambda
15 min execution time, 10 GB memory, 6 MB request payload, 512 MB-10 GB ephemeral storage. Functionally limitless for long-running batch.
Benchmark
Round-trip latency from US East user, simple JSON API
Test client in Virginia, US. Both functions return the same 1 KB JSON payload, no DB call. Worker deployed globally (auto-routed to nearest PoP); Lambda deployed in us-east-1 behind API Gateway. Numbers from public benchmarks plus a Semicolony retest (2026).
Metric
CF Workers
Lambda
Better
p50 cold start + execute
Worker isolates start in ~5ms; Lambda + API Gateway adds overhead.
12 ms
142 ms
CF Workers
p50 warm
8 ms
38 ms
CF Workers
p99 latency
Lambda's cold-start tail is real.
18 ms
290 ms
CF Workers
Cost per 10M requests (no compute)
Lambda wins on raw request cost; Workers includes more in $5/mo base.