Cloudflare Workers vs AWS Lambda vs Vercel Edge Functions

Traditional serverless (AWS Lambda, Google Cloud Functions) runs your code in a specific region. If your Lambda is in us-east-1 and your user is in Tokyo, every request travels 12,000 km round trip. That adds 150 to 200ms of latency before your code even executes.

Edge computing runs your code at the network edge, close to the user. Cloudflare has 300+ data centers globally. Vercel Edge runs on Cloudflare's network. AWS Lambda@Edge runs at CloudFront's 450+ edge locations. Your code executes within 50ms of the user, regardless of where they are.

The practical difference: a Tokyo user hitting a US-based Lambda API sees 250 to 400ms response times. The same user hitting a Cloudflare Worker sees 20 to 80ms. For dynamic content (personalization, A/B tests, authentication checks, geo-routing), this latency reduction is significant.

Not everything belongs at the edge. Database queries still need to reach your database (which lives in a specific region). Heavy computation needs more CPU time than edge platforms allow. Long-running tasks need traditional serverless. The art is knowing which parts of your stack benefit from edge deployment and which do not.

Cloudflare Workers run on V8 isolates (the same engine that powers Chrome) at 300+ locations worldwide. They start in under 5ms (no cold starts), use a Web Standards API, and have a generous free tier.

Strengths

• Zero cold starts. V8 isolates spin up in under 5ms. No cold start problem, ever. This alone makes Workers superior for latency-sensitive APIs.
• Global by default. Every deployment runs at all 300+ edge locations simultaneously. No region selection needed.
• Integrated ecosystem. Workers KV (key-value storage), R2 (S3-compatible object storage), D1 (SQLite at the edge), Durable Objects (stateful edge computing), and Queues are all edge-native. You can build complete applications without leaving Cloudflare.
• Pricing. Free tier: 100K requests/day. Paid plan: $5/month for 10M requests, then $0.50 per additional million. Dramatically cheaper than Lambda for high-request, low-compute workloads.

Limitations

• CPU time limit: 10ms on free, 30s on paid. Compute-heavy tasks (image processing, complex data transformations) may exceed this.
• No Node.js API. Workers use Web Standards APIs (fetch, Request, Response, crypto). Most Node.js packages that use node: built-ins do not work. Cloudflare has added Node.js compatibility flags, but support is incomplete.
• Memory limit: 128MB. Not suitable for in-memory data processing of large datasets.
• No native file system. You cannot read or write files. Use R2 for object storage or KV for key-value data.

AWS Lambda is the most mature serverless platform. It runs any Node.js code, supports custom runtimes, and integrates with 200+ AWS services. Lambda@Edge and CloudFront Functions bring Lambda closer to the edge.

Strengths

• Full Node.js support. Any npm package works. Native addons compile and run. No compatibility concerns.
• Generous limits. 15-minute execution time, 10GB memory, 50MB deployment package (250MB unzipped). You can run serious workloads on Lambda.
• AWS ecosystem. Direct integration with S3, DynamoDB, SQS, SNS, EventBridge, API Gateway, and every other AWS service. Event-driven architectures are Lambda's sweet spot.
• Provisioned concurrency. Pre-warm Lambda instances to eliminate cold starts for latency-sensitive workloads. Costs more but guarantees consistent response times.

Limitations

• Cold starts: 200ms to 2s depending on runtime, package size, and VPC configuration. Java and .NET cold starts can exceed 5s. Node.js cold starts are 200 to 500ms without provisioned concurrency.
• Regional deployment. Lambda runs in one region unless you explicitly use Lambda@Edge (limited to 5s execution) or CloudFront Functions (limited to 2ms execution, very restricted API).
• Pricing complexity. $0.20 per 1M requests plus $0.0000166667 per GB-second. Cheap for low-traffic, but costs add up for high-request workloads. A function handling 100M requests/month at 128MB and 100ms average execution costs approximately $200/month.
• Vendor lock-in. Deep AWS integration makes migration expensive. If your Lambda uses DynamoDB Streams, SQS triggers, and Step Functions, you are deeply coupled to AWS.

For cost optimization on AWS, check our guide on reducing your cloud bill.

Vercel Edge Functions run on Cloudflare's network but are tightly integrated with Next.js and Vercel's deployment platform. They are the easiest way to add edge computing to a Next.js application.

Strengths

• Next.js integration. Mark any API route or middleware as edge with export const runtime = "edge". Zero configuration. The framework handles everything.
• Zero cold starts. Same V8 isolate technology as Cloudflare Workers. Sub-5ms startup.
• Middleware. Run code before every request (authentication, redirects, A/B testing, geo-routing) at the edge. This is the killer feature for Next.js apps.
• Streaming. Edge Functions support streaming responses, which is ideal for AI applications that stream LLM outputs to the client.

Limitations

• Vercel lock-in. Edge Functions are a Vercel feature, not a portable standard. Migrating away from Vercel means rewriting edge logic.
• Same runtime restrictions as Workers. Web Standards APIs only, limited Node.js compatibility, memory limits. Many npm packages do not work in the edge runtime.
• Cost at scale. Vercel's Pro plan includes 500K Edge Function invocations. Beyond that, pricing is based on your plan tier and can get expensive for high-traffic applications. Enterprise pricing is opaque.
• Framework coupling. Edge Functions are designed for Next.js. Using them with SvelteKit, Remix, or other frameworks is possible but less polished.

Here are real-world performance numbers from our benchmarks and production experience:

Cold Start Latency

• Cloudflare Workers: 0 to 5ms (V8 isolates, no cold start)
• Vercel Edge Functions: 0 to 5ms (same V8 isolate tech)
• AWS Lambda (Node.js): 200 to 500ms (without provisioned concurrency)
• AWS Lambda (Provisioned): 0ms (pre-warmed, but costs $0.000004646 per GB-second of provisioned time)

Execution Latency (Simple JSON API)

• Cloudflare Workers: 2 to 5ms execution + network latency to user
• Vercel Edge: 2 to 5ms execution + network latency to user
• AWS Lambda: 5 to 15ms execution + network latency to region

Global P95 Response Time (User in Tokyo, API returning personalized content)

• Cloudflare Workers: 30 to 60ms
• Vercel Edge: 30 to 60ms
• AWS Lambda (us-east-1): 250 to 400ms
• AWS Lambda (ap-northeast-1): 50 to 100ms (but only fast for Tokyo users)

The edge platforms (Workers, Vercel Edge) provide consistently low latency globally. Lambda provides low latency only in the deployed region. For applications serving a global audience, edge deployment is a significant UX improvement.

Cost varies dramatically based on usage patterns. Here are three scenarios:

Scenario 1: Low Traffic API (100K requests/month)

• Cloudflare Workers: Free (100K/day free tier)
• Vercel Edge: Included in Pro plan ($20/month)
• AWS Lambda: ~$0.20/month (effectively free tier)

Scenario 2: Medium Traffic (10M requests/month, 50ms avg execution)

• Cloudflare Workers: $5/month (paid plan includes 10M requests)
• Vercel Edge: $20/month Pro plan (may need Enterprise for this volume)
• AWS Lambda: ~$8/month (128MB, 50ms avg)

Scenario 3: High Traffic (100M requests/month, 100ms avg execution)

• Cloudflare Workers: $50/month ($5 base + $45 for 90M extra requests)
• Vercel Edge: Enterprise pricing (typically $400+/month)
• AWS Lambda: ~$200/month (128MB, 100ms avg, plus API Gateway costs)

Cloudflare Workers are the cheapest option at every traffic level for request-heavy workloads. Lambda is cheaper for compute-heavy workloads (long execution times, high memory). Vercel Edge is the most expensive at scale but the most convenient for Next.js teams. For a broader hosting comparison, see our Vercel vs AWS vs Railway analysis.

Here is when to use each platform:

Choose Cloudflare Workers when: You need global low latency with zero cold starts. You are building APIs, middleware, or lightweight services. You want the lowest cost at scale. You are willing to work within Web Standards API constraints. Your data layer uses Cloudflare D1, KV, or external databases with global read replicas.

Choose AWS Lambda when: You need full Node.js compatibility (native addons, any npm package). Your workloads are compute-heavy or long-running (over 30 seconds). You are already invested in the AWS ecosystem (DynamoDB, SQS, S3 triggers). You need event-driven processing (file uploads, queue processing, scheduled tasks). Regional deployment is acceptable for your users.

Choose Vercel Edge Functions when: You are building a Next.js application and want the simplest deployment experience. You need edge middleware for authentication, personalization, or A/B testing. Your team prioritizes developer experience over infrastructure control. You are willing to pay Vercel's pricing for the convenience.

The hybrid approach: Many production architectures use multiple platforms. Edge functions handle routing, authentication, and personalization. Regional serverless (Lambda) handles business logic and database operations. Background processing uses Lambda or dedicated workers. This lets each workload run on the platform best suited for it.

Edge computing is becoming table stakes for user-facing applications. If you need help designing your serverless and edge architecture, book a free strategy call with our team. For a broader comparison of serverless vs containers, see our Kubernetes vs serverless guide.