Cloudflare Workers vs AWS Lambda vs Vercel Edge Functions: Which Serverless Platform Wins in 2026?
🔍 Want the best deal? Check current prices and availability.
Compare Prices →When you buy through links on our site, we may earn a commission.
Cloudflare Workers vs AWS Lambda vs Vercel Edge Functions: Which Serverless Platform Wins in 2026?
Three platforms dominate the conversation when developers start shopping for serverless compute: Cloudflare Workers, AWS Lambda, and Vercel Edge Functions. They all promise the same headline — "run code without managing servers" — but they solve very different problems. Pick the wrong one and you'll spend weeks fighting cold starts, surprise bills, or a runtime that doesn't support the npm package you need.
I've shipped production workloads on all three. Here's what actually matters when you're choosing between them, and where each one falls apart.
The 30-Second Version
- Cloudflare Workers runs your code in V8 isolates across 300+ locations. Cold starts are effectively zero. The free tier is generous enough for real projects.
- AWS Lambda is the most flexible option. It supports almost every runtime, runs up to 15 minutes, and integrates with the entire AWS ecosystem — at the cost of cold starts and a pricing model that rewards careful tuning.
- Vercel Edge Functions is the easiest path if you're already on Next.js. It's built on the same isolate model as Workers, but you're paying for convenience and you're locked into Vercel's deployment pipeline.
That's the summary. Now the details.
How Each Platform Actually Runs Your Code
This is the part most comparisons gloss over, and it's the single biggest factor in performance.
Cloudflare Workers: V8 Isolates
Workers doesn't spin up a container per request. It uses V8 isolates — the same sandboxing engine Chrome uses for separate tabs. Multiple requests from different customers share one process, but each isolate is isolated from the others. The practical result: cold starts measured in single-digit milliseconds, often under 5ms. There's no "warm-up" concept in the traditional sense because there's nothing to warm up.
The tradeoff is a constrained runtime. Workers runs JavaScript and TypeScript (plus WASM and Python in beta). No native Node.js binaries. If your code depends on a package that shells out to a C library, you're out of luck unless someone has ported it to WASM.
AWS Lambda: Firecracker MicroVMs
Lambda runs each execution environment in a Firecracker microVM — a lightweight virtual machine. That gives you a full OS-level sandbox with real Node.js, Python, Go, Java, .NET, and Ruby runtimes. You can bring native dependencies. You can run a 15-minute job. You can attach up to 10GB of memory.
The cost of that flexibility is cold starts. A cold Node.js Lambda typically takes 200–400ms to initialize. Java and .NET can push past a second. If your function loads a large dependency tree or connects to a database, add more. Provisioned Concurrency fixes this — at a price.
Vercel Edge Functions: V8 Isolates on Vercel's Network
Vercel Edge Functions run on the same isolate model as Workers. Cold starts are near-instant. But Vercel's edge network is smaller than Cloudflare's, and the runtime is deliberately limited to the Web API standard. You get fetch, Request, Response, and a subset of Node.js APIs — but not the full Node runtime. Vercel also offers traditional serverless functions (Node.js) for heavier work, so you end up choosing per-route.
Feature Breakdown
Execution Limits
| Limit | Cloudflare Workers | AWS Lambda | Vercel Edge Functions |
|---|---|---|---|
| Max execution time | 30s CPU (configurable up to 5 min) | 15 minutes | 30 seconds |
| Max memory | 128 MB per isolate | Up to 10,240 MB | 128 MB |
| Cold start | ~0–5ms | 200ms–1s+ | ~0–5ms |
| Runtime support | JS/TS, WASM, Python (beta) | Node, Python, Go, Java, .NET, Ruby, custom | JS/TS, Web API subset |
| Max bundle size | 10 MB (paid) | 250 MB unzipped | 4 MB |
| Global locations | 300+ | ~30 regions (opt-in) | ~20 regions |
| Persistent connections | Yes (Durable Objects) | Yes | No |
| Cron / scheduled | Yes | Yes (EventBridge) | Yes (Vercel Cron) |
Pricing Model
This is where the three platforms diverge sharply. Lambda charges for both requests and compute duration. Workers charges primarily for requests, with CPU time as a secondary meter. Vercel bundles edge invocations into your plan and charges overage.
Cloudflare Workers
- Free: 100,000 requests/day, 10ms CPU per request
- Paid: $5/month base, includes 10 million requests and 30 million CPU milliseconds. Additional requests: $0.30 per million. Additional CPU: $0.02 per million ms.
AWS Lambda
- Free tier: 1 million requests and 400,000 GB-seconds per month
- Requests: $0.20 per million
- Compute: $0.0000166667 per GB-second
- Provisioned Concurrency: extra, roughly $0.0000041667 per GB-second
Vercel Edge Functions
- Hobby: Free, includes 1M edge invocations and 100 GB-hours
- Pro: $20/user/month, includes 1M edge invocations; overage around $0.60 per million
- Enterprise: custom
Here's the thing about Lambda pricing that trips people up: you pay for wall-clock duration, not CPU time. A function that spends 900ms waiting on a database call still bills you for those 900ms. Workers only bills CPU time — time spent actually executing code, not waiting on I/O. For I/O-heavy workloads, that difference can be enormous.
Ecosystem and Integrations
Lambda wins on raw integration surface. Anything in AWS — S3, DynamoDB, SQS, SNS, Step Functions, RDS — is a native trigger. If you're already running infrastructure on AWS, Lambda slots in without friction. Check AWS Lambda ->
Workers has its own growing stack: KV for key-value, R2 for object storage (S3-compatible, no egress fees), D1 for SQLite, Durable Objects for stateful coordination, Queues for async work. It's not as deep as AWS, but it's cohesive and the egress pricing on R2 is genuinely aggressive.
Vercel's ecosystem is really the Next.js ecosystem. If your app is a Next.js app, edge functions integrate with middleware, ISR, and the deployment pipeline in a way the others can't match. Outside of that, you're using Vercel as a host for standalone functions. Check Vercel ->
Local Development
Cloudflare's wrangler CLI is excellent. wrangler dev runs your Worker locally in a workerd runtime that mirrors production closely. Miniflare powers it, and you can simulate KV, R2, and D1 locally.
AWS SAM and the Serverless Framework both work well for Lambda, but local emulation is never quite production. Docker-based Lambda emulation gets close, but subtle differences in IAM, VPC networking, and cold start behavior will bite you eventually.
Vercel's vercel dev is fine for Next.js projects. For standalone edge functions it's less polished, and you'll often find yourself deploying to a preview branch just to test edge-specific behavior.
Pros and Cons
Cloudflare Workers
Pros
- Cold starts are effectively nonexistent
- Free tier covers most side projects and small production apps
- CPU-time billing is fair for I/O-heavy workloads
- R2 storage has no egress fees, which changes the math on data-heavy apps
- Durable Objects give you stateful coordination without a separate database
Cons
- No full Node.js runtime — native dependencies are a problem
- 128MB memory ceiling limits what you can process in one invocation
- Smaller ecosystem of third-party libraries compared to AWS
- Debugging isolate-level issues can be opaque
AWS Lambda
Pros
- Supports essentially every runtime and native dependency
- 15-minute execution window handles real batch jobs
- Deepest integration with cloud infrastructure anywhere
- Mature tooling: SAM, CDK, Serverless Framework, Terraform providers
- Scales to enormous concurrency without configuration
Cons
- Cold starts are real and require workarounds
- Wall-clock billing punishes I/O-bound functions
- Pricing is hard to predict without careful monitoring
- VPC-attached functions historically had worse cold starts (improved but not gone)
- The AWS console is a maze
Vercel Edge Functions
Pros
- Best-in-class experience if you're on Next.js
- Deployment is a git push, previews included
- Near-instant cold starts
- Middleware runs before your app, which is genuinely useful for auth and A/B tests
- Zero-config for the common case
Cons
- Locked into Vercel's platform and pricing
- 30-second execution limit and 4MB bundle size
- No persistent connections or stateful primitives
- Overage pricing adds up fast at scale
- Runtime is a Web API subset — some npm packages won't work
Which One Should You Actually Pick?
Choose Cloudflare Workers if: you're building an API, a proxy, an auth layer, or anything I/O-heavy that needs to be fast everywhere. The CPU-time billing model and zero cold starts Make it the best value for request-response workloads. If you're cost-sensitive and don't need native Node modules, this is the default answer. Check Cloudflare Workers ->
Choose AWS Lambda if: you need a specific runtime, native dependencies, long-running jobs, or you're already deep in AWS. It's the most capable platform and the most complex. If your workload doesn't fit in a 30-second window or needs a real Node.js runtime, Lambda is the only one of the three that will do the job.
Choose Vercel Edge Functions if: your app is Next.js and you want the deployment experience to disappear. The convenience is real, and for small-to-mid projects the pricing is fine. Just know that you're trading flexibility and cost control for developer velocity.
The Verdict
For most solo developers and small teams in 2026, Cloudflare Workers is the winner. The combination of near-zero cold starts, a free tier you can actually build on, CPU-time billing that doesn't punish database calls, and R2's zero egress fees is hard to beat. It's not the most flexible platform — Lambda still wins there — but for the workloads most people are actually building (APIs, webhooks, edge middleware, lightweight backends), Workers delivers the best performance-to-cost ratio.
That said, "best overall" isn't "best for you." If you're running a Next.js app and value your time over your hosting bill, Vercel's integration is worth the premium. If you need a 10-minute video transcode or a native Python ML library, Lambda is the only option on this list. Match the tool to the workload, not the hype.
FAQ
Is Cloudflare Workers really free?
The free tier gives you 100,000 requests per day with 10ms of CPU time per request. That's enough for a surprising number of production apps — roughly 3 million requests per month. You only hit the $5/month paid plan when you outgrow that, and the paid plan includes 10 million requests.
Do AWS Lambda cold starts still matter in 2026?
They've improved, especially for Node.js and Python, but they haven't disappeared. Expect 200–400ms for a typical cold Node function. If you're running latency-sensitive endpoints, Provisioned Concurrency eliminates them — but you pay for idle capacity. SnapStart helps for Java.
Can I run Node.js on Cloudflare Workers?
Partially. Workers supports a growing subset of Node.js APIs through compatibility flags, but it's not a full Node runtime. Packages that rely on native binaries or the full fs module won't work. If you need real Node.js, use Lambda or Vercel's serverless functions.
Which platform is cheapest at scale?
It depends on your workload shape. For request-heavy, I/O-bound apps, Workers is usually cheapest because you're billed on CPU time, not wall-clock duration. For compute-heavy jobs, Lambda's per-GB-second model can win. Vercel is typically the most expensive per invocation at high volume, but you're paying for the deployment experience.
Can I use these together?
Yes, and
🔍 Want the best deal? Check current prices and availability.
Compare Prices →