AWS quietly rewrote the rules of serverless computing on October 12, 2026, when it shipped AWS Lambda Web Functions, a new execution model that runs ordinary Node.js HTTP servers, Express, Hono, Fastify, Next.js, all unmodified, directly on Lambda without an adapter layer. AWS renamed the classic Lambda model Lambda Event Functions to make room for it. Nine days later, the launch has forced a fresh round of comparisons against the two platforms that already owned the “run my web app without managing servers” pitch: Cloudflare Workers and Vercel Functions (the platform formerly branded Vercel Edge Functions, a name Vercel’s own documentation now marks as deprecated).
This comparison is not a rehash of the decade-old “Lambda vs. Workers” cold-start debate. AWS Lambda Web Functions changes the billing model (active-CPU time instead of flat duration), the concurrency model (up to 128 concurrent requests per warm environment instead of one request per instance), and the developer experience (deploy a standard HTTP server, not a handler function). Cloudflare Workers, meanwhile, spent the back half of 2026 absorbing the Deno team, shipping post-quantum cryptography, and widening its request and WebSocket limits. Vercel spent the same stretch quietly retiring “Edge Functions” as a brand and replacing it with a broader “Vercel Functions” umbrella that now includes Bring Your Own Cloud (BYOC) deployment inside a customer’s own AWS account.
Below is a full breakdown of specs, pricing, benchmarks, real-world use cases, and a migration guide for teams deciding where their next HTTP workload should run, as the three platforms looked on October 21, 2026, within the broader cloud computing landscape.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
What Is AWS Lambda Web Functions? Inside the October 12 Launch
AWS Lambda Web Functions is best understood as a second Lambda function type that sits alongside the classic model, which AWS renamed Lambda Event Functions the same day Web Functions went live. Instead of writing a handler that receives an event object, developers point Lambda at a standard HTTP server that listens on a port. AWS’s own announcement described the function as being “available today” on October 12, 2026, with Node.js support at launch and documentation expanding daily through October 20.
At launch, Web Functions ran on Node.js 24 on Arm64 and were available in five AWS regions: US East (N. Virginia), US East (Ohio), US West (Oregon), Asia Pacific (Tokyo), and Europe (Ireland). AWS said the model supports Express, Hono, Fastify, and Next.js without modification, a direct pitch at teams who found adapting existing servers to Lambda’s traditional handler signature tedious. On October 19, AWS clarified a detail that matters for anyone estimating cost and capacity: a single warm execution environment can handle up to 128 concurrent requests, a sharp departure from classic Lambda’s one-request-per-instance isolation model.
The billing model is the other headline change. According to Stackmaven’s analysis of the launch, Web Functions introduce active-CPU billing: AWS charges for CPU time only while code is actively computing, not while it waits on a database call or a downstream API response, and that active time is metered in 1-millisecond increments. Memory, by contrast, is billed for the full lifetime of the execution environment, whether or not the CPU is busy. AWS’s current pricing page lists the request charge at $0.30 per million requests, a jump from an initial $0.20 figure that circulated in some launch-adjacent coverage before AWS’s official page settled on the higher number. AWS’s own pricing material also lists per-second compute charges of roughly $0.0000276944 per active vCPU-second and $0.0000036667 per GB-second of memory, on top of standard AWS data-transfer charges.
Deployment happens through the same tooling teams already use for Lambda: the Lambda API, AWS console, CLI, CloudFormation, SAM, CDK, SDKs, and the newer Agent Toolkit. Web Functions also support native HTTP streaming, VPC connectivity, and multi-Region routing, and they expose a public HTTPS endpoint without requiring a separate load balancer or adapter layer. For teams already running workloads on Lambda’s longer-duration managed instances option, which extends timeouts well past the default limit, Web Functions offers a second path for workloads shaped more like a persistent web server than a short-lived event handler.
Cloudflare Workers in 2026: The Established Edge Leader
Cloudflare Workers remains Cloudflare’s core edge-compute platform, and as of October 21, 2026 it is still built on V8 isolates rather than containers or microVMs, the architectural choice that has always given Workers near-instant cold starts compared with container- or VM-based serverless platforms. Cloudflare describes Workers as running on “systems powering 20% of the Internet,” according to its own marketing copy, and the platform bundles Workers, Pages Functions, Workers KV, Hyperdrive, and Durable Objects under a single Workers Paid plan priced at $5 per month per account.
The free Workers plan includes 100,000 requests per day and 10 milliseconds of CPU time per invocation. The Paid plan’s Standard usage tier includes 10 million requests per month, then charges $0.30 per additional million requests, plus 30 million CPU milliseconds per month, then $0.02 per additional million CPU milliseconds. Maximum CPU time per invocation is capped at 5 minutes, with a 30-second default, though Cron Triggers and Queue Consumers can run up to 15 minutes. Enterprise customers fall under Workers for Enterprise, billed according to a custom contract rather than a published rate card.
Cloudflare has been busy in the last 90 days. On October 2, 2026, it raised several platform limits: Worker startup time increased to 1 second from 400 milliseconds, maximum WebSocket message size grew to 32 MiB from 1 MiB, maximum subrequests jumped to 1 million from 1,000, and the uncompressed Worker size ceiling rose to 64 MiB from 10 MB. During its annual Birthday Week on October 5, Cloudflare added opt-in native Web Crypto support for post-quantum primitives ML-KEM and ML-DSA. On October 9, Cloudflare announced that the Deno team was joining the company, with Ryan Dahl and Bert Belder reportedly leading an effort to make self-hosted workerd a supported Workers deployment model. On October 14, Cloudflare added on-demand CPU and memory profiling with flamegraphs for Workers and Durable Objects, and a Gateway-to-Workers integration entered public beta on October 15.
Workers AI, Cloudflare’s edge-inference layer, is included on both Free and Paid Workers plans and is priced at $0.011 per 1,000 Neurons, with 10,000 Neurons free per day. Cloudflare’s changelog shows it shipped two new internally trained models, Clef and Clef-flash, on October 1, and a typed-extraction model called Clairic entered preview on October 19. For teams weighing Workers against the storage layer underneath it, the broader object storage comparison between Cloudflare R2, Amazon S3, and Backblaze B2 is a useful companion read, since Workers’ zero-egress pitch depends heavily on R2’s pricing.
Vercel Functions: What Happened to “Edge Functions”
Anyone researching this comparison by searching “Vercel Edge Functions” will run into Vercel’s own documentation, which now labels that page Edge Functions (Deprecated). The current, accurate product name is Vercel Functions, a broader runtime umbrella that includes Node.js and Python execution, Bun support, and an Edge Runtime option measured in Execution Units rather than raw wall-clock time. Vercel made a related naming change on September 30, 2026, renaming the “Edge Requests” usage metric to “CDN Requests”, a naming-only change, according to Vercel, with pricing and measurement left unchanged.
Inside Vercel Functions, the Edge Runtime option still measures CPU time in 50-millisecond Execution Units, and idle time spent waiting on network responses doesn’t count toward that budget. Vercel’s own pricing page lists Edge Runtime usage at $2.00 per 1,000,000 Execution Units and $0.60 per 1,000,000 Invocations. Routing Middleware, a related capability, is capped at 50 milliseconds of average net CPU time, excluding time spent waiting for data fetching.
The more consequential change, Vercel says, is that Bring Your Own Cloud (BYOC) on AWS became generally available for Enterprise customers. BYOC lets Vercel Functions written in Node.js and Python execute inside the customer’s own AWS account, while Vercel continues to handle deployment, environments, routing, and static assets, a direct answer to enterprise compliance teams who didn’t want application logic leaving their own cloud boundary. Vercel Daemons reportedly also entered public beta, adding support for long-running background processes that don’t fit the conventional request/response edge-function model.
Other changes in the last three months: Node.js 20 began deprecating on Vercel on October 1, 2026, following its upstream end-of-life in April. Bun-runtime Functions reportedly gained support for package sizes up to 5 GB and maximum durations up to 30 minutes. Python Functions reportedly also gained WebSocket support. And existing Pro teams began paying for Deployment Storage and Functions Storage starting October 9, with new Pro teams defaulting to a 30-day deployment-retention window. Readers comparing Vercel against adjacent static-and-hybrid hosting options should also see the comparison of Vercel against Netlify and Cloudflare Pages, which covers the deployment side this article doesn’t.
Specs at a Glance: 12-Row Comparison Table
The table below lines up the core specs for all three platforms as they stood on October 21, 2026.
| Spec | AWS Lambda Web Functions | Cloudflare Workers | Vercel Functions |
|---|---|---|---|
| Current status (Oct 21, 2026) | GA since October 12, 2026 | Active, core edge platform | Active; “Edge Functions” brand retired |
| Runtime at launch/today | Node.js 24 on Arm64 | V8 isolates (JS/Wasm) plus Workers Builds runtimes | Node.js, Python, Bun, Edge Runtime |
| Max concurrent requests per instance | Up to 128 per warm environment | Isolate-level concurrency, no fixed per-instance cap cited | Varies by runtime; Edge Runtime billed in Execution Units |
| Max CPU/execution time | Active CPU billed per ms, no flat ceiling cited | 5 minutes per invocation (30s default); Cron/Queue up to 15 min | Routing Middleware capped at 50ms average CPU |
| Launch/current regions | 5 AWS regions at launch | Global edge network | Global network plus BYOC on AWS regions |
| Entry-level pricing model | Pay-per-use, no account minimum cited | $5/month minimum (Workers Paid) | Bundled into Pro/Enterprise plans |
| Free tier | Standard Lambda free tier applies | 100,000 requests/day, 10ms CPU/invocation | Plan-based; no dedicated Functions free unit cited |
| Idle-time billing | Idle DB/API wait excluded from active CPU | CPU billed only while isolate computes | Edge Runtime excludes idle wait from CPU units |
| Edge/managed AI inference | Not native; standard Bedrock applies separately | Workers AI, $0.011 per 1,000 Neurons | AI Gateway Token Pass add-on |
| Enterprise/self-hosting option | VPC connectivity, multi-Region routing | Workers for Enterprise (custom contract) | Bring Your Own Cloud on AWS (GA Oct 15, 2026) |
| Deployment tooling | Lambda API, console, CLI, CloudFormation, SAM, CDK, SDKs, Agent Toolkit | Wrangler CLI, dashboard, Workers Builds CI | Vercel CLI, Git integration, dashboard |
| Framework compatibility at launch | Express, Hono, Fastify, Next.js, unmodified | Any JS/Wasm framework via adapters | Native Next.js plus broad framework support |
Pricing Breakdown: Requests, CPU Time, and Monthly Minimums
Pricing is where the three platforms diverge the most, because each one bills a different unit as its primary cost driver: requests for AWS, a request-plus-CPU-millisecond bundle for Cloudflare, and Execution Units for Vercel’s Edge Runtime.
| Cost component | AWS Lambda Web Functions | Cloudflare Workers (Paid) | Vercel Functions |
|---|---|---|---|
| Monthly account minimum | $0, pure pay-per-use | $5/month | Bundled into Pro/Enterprise plan fee |
| Per-request/invocation charge | $0.30 per million requests | 10M requests/month included, then $0.30 per additional million | $0.60 per million invocations (Edge Runtime) |
| Compute/CPU charge | Active vCPU-second plus GB-second memory, billed per ms | 30M CPU-ms/month included, then $0.02 per additional million CPU-ms | $2.00 per million Execution Units (50ms each) |
| AI inference add-on | Not bundled; standard Bedrock pricing applies | $0.011 per 1,000 Neurons, 10,000 free/day | AI Gateway Token Pass, $30/team/month, $80 monthly credit |
| Enterprise/custom compute | Not listed | Workers for Enterprise, custom contract, no public rate | Bring Your Own Cloud on AWS, Enterprise only, GA Oct 15, 2026 |
| Storage/state cost | Standard S3/DynamoDB rates apply separately | Workers KV/Durable Objects usage-based, bundled into plan tiers | Usage-based Deployment/Functions Storage billing, introduced Oct 9, 2026 |
Two things fall out of this table. First, AWS Lambda Web Functions has no account-level minimum: a team processing a handful of requests a month pays close to nothing, whereas Cloudflare’s $5 Workers Paid floor applies regardless of usage. Second, the active-CPU billing model on both AWS and Vercel’s Edge Runtime rewards workloads with long idle periods, a function that spends most of its time waiting on a database response costs less under either model than under a flat-duration billing scheme, because neither platform charges for that wait.
Cloudflare’s Workers Builds pipeline, which handles CI for Worker deployments, includes 3,000 free build minutes per month on the Free plan and 6,000 on Paid, with additional minutes billed at $0.005 each, according to Cloudflare’s own build-limits documentation. Workers VPC, a networking feature that lets Workers reach private resources, remains in open beta and is free during that beta window.
Benchmarks: Cold Starts, Concurrency, and Latency
Direct head-to-head benchmarks for the brand-new AWS Lambda Web Functions don’t exist yet, the product is nine days old at the time of writing, so the fairest way to frame performance is through the architectural choices each platform has already made, backed by what AWS, Cloudflare, and independent analysts have published.
Cloudflare’s V8-isolate model has long been the industry’s benchmark for cold-start avoidance, since isolates start in milliseconds rather than the hundreds of milliseconds to multiple seconds a container or microVM can take to initialize. Tech Insider’s own earlier cold-start benchmarking of Cloudflare Workers against classic AWS Lambda found a wide gap favoring Workers’ isolate model over Lambda’s container-based cold starts, the exact dynamic AWS Lambda Web Functions is designed to change, by keeping warm execution environments alive across up to 128 concurrent requests instead of spinning up a new container per request.
That 128-concurrent-request ceiling, confirmed by AWS on October 19, 2026, is the single most important capacity number in this comparison. It means a Web Functions environment behaves more like a small, warm application server than a single-purpose event handler, which should reduce the cold-start tax that has historically made classic Lambda a poor fit for latency-sensitive HTTP APIs. Independent analysis from Enkompass’s business-case review of the launch frames the active-CPU billing model as the more consequential change for cost-sensitive teams, since it removes the penalty workloads previously paid for time spent blocked on I/O, a cost structure Cloudflare Workers and Vercel’s Edge Runtime already use.
Vercel’s Edge Runtime, billed in 50-millisecond Execution Units, imposes a tighter per-invocation CPU budget than either Workers’ 5-minute ceiling or Lambda Web Functions’ uncapped active-CPU model, which makes it best suited to short request-handling logic like middleware, redirects, and personalization rather than long-running compute. AWS’s own October 19 weekly roundup, covered by the developer community recap on Dev.to, reiterated that Web Functions are positioned for HTTP applications, APIs, server-side rendering, streaming endpoints, and microservices, the same workload category Workers and Vercel Functions have competed over for several years.
Architecture Deep Dive: Three Different Execution Models
The three platforms solve the same problem, run application code without managing servers, with meaningfully different execution models, and understanding those differences matters more than any single benchmark number.
AWS Lambda Web Functions keeps Lambda’s underlying microVM isolation (Firecracker) but changes what runs inside it: instead of invoking a handler once per event, AWS starts a standard HTTP server process and routes up to 128 concurrent requests to it before spinning up another environment. This is a hybrid between classic Lambda’s strict per-invocation isolation and a traditional always-on web server, and it’s why AWS can support unmodified Express or Next.js servers without an adapter. VPC connectivity and multi-Region routing round out the model for teams that need Web Functions to reach private databases or route traffic across regions.
Cloudflare Workers runs code inside V8 isolates, the same sandboxing technology Chrome uses to separate browser tabs, rather than full containers or VMs. Isolates share a process and start in single-digit milliseconds, which is the architectural root of Workers’ cold-start advantage, but it also constrains what a Worker can do: no arbitrary native binaries, and historically a narrower set of supported languages than a general-purpose compute platform. Durable Objects extend this model with stateful, single-instance coordination for things like WebSocket rooms or counters, and Workers KV and Hyperdrive round out the data layer.
Vercel Functions sit closer to a traditional PaaS model layered with an edge option. Node.js and Python Functions run in more conventional sandboxes with broader runtime compatibility (including Bun, which now supports package sizes up to 5 GB), while the Edge Runtime option trades some of that flexibility for V8-isolate-style speed, similar in spirit to Cloudflare’s approach. BYOC, which Vercel says became generally available for Enterprise customers on October 15, 2026, breaks from both models by letting Vercel Functions execute inside the customer’s own AWS account, architecturally closer to a managed deployment layer on top of AWS than to Vercel’s own multi-tenant infrastructure. Teams evaluating this trade-off against purpose-built carrier and telco edge options should also look at the comparison of carrier-grade edge zones like AWS Wavelength against Azure Edge Zones and Google Distributed Cloud Edge, which covers a different flavor of “edge” than any of these three platforms.
Developer Experience and Deployment Workflow
For a developer who already has a working Express or Next.js app, AWS Lambda Web Functions is designed to require the least amount of rewriting: point the deployment tooling at the existing server entry point and AWS handles the HTTPS endpoint, revisions, and rollback. A minimal example looks like an ordinary Node server:
const express = require('express');
const app = express();
app.get('/', (req, res) => {
res.send('Hello from Lambda Web Functions');
});
app.listen(process.env.PORT || 8080);Cloudflare Workers code, by contrast, is written against a fetch event handler rather than a listening HTTP server, which means existing Express-style servers typically need an adapter layer before they’ll run on Workers. Vercel’s deployment workflow leans heavily on Git integration: pushing to a connected repository triggers a build and preview deployment automatically, and the choice between Node.js, Python, Bun, or Edge Runtime is largely a per-function configuration decision rather than a different deployment pipeline. Readers building an API from scratch on classic Lambda, rather than migrating one, may find the step-by-step guide to building an AWS Lambda API useful background before comparing it against the newer Web Functions model.
Five Real-World Use Cases Across the Three Platforms
AWS Lambda Web Functions is too new to have published customer case studies of its own, but the broader Lambda ecosystem it extends already has a track record at scale, and Cloudflare’s and Vercel’s recent feature launches point to concrete patterns for each platform.
- Connected-vehicle telemetry at global scale: Scania uses AWS Lambda to scale its connected-vehicle platform, processing telemetry from trucks across a global hybrid network with 80% lower latency, according to AWS’s own customer case study. That kind of persistent-ingestion workload, constant streams of small requests from distributed devices, is exactly the shape Web Functions’ 128-concurrent-request model targets.
- Mobile gaming backends: ZigZa scaled its flagship mobile games to 4 million concurrent players using AWS Lambda, achieving 70% lower infrastructure costs while handling 44% year-over-year growth, per AWS’s published case study, a workload profile where active-CPU billing on Web Functions could compound those savings further by not charging for time spent waiting on matchmaking or leaderboard database calls.
- ML-driven risk modeling: CyberGRX reduced its machine-learning-based cyber risk modeling runtime from 8 days to 1 hour using AWS Step Functions and Lambda together, while cutting compute costs by 90%, according to AWS. Pipelines like this, built from many short-lived Lambda invocations, are a natural fit for the classic Event Functions model AWS kept alongside Web Functions.
- Sub-50ms global APIs on Cloudflare Workers: Teams building latency-sensitive public APIs, think feature flags, geolocation lookups, or personalization endpoints, lean on Workers’ V8-isolate cold-start advantage and its $0.011-per-1,000-Neuron Workers AI pricing to run lightweight inference at the edge without standing up a separate GPU fleet.
Teams running a serverless backend for a game leaderboard or matchmaking service specifically should also look at the existing tutorial for building a serverless leaderboard on Lambda and DynamoDB, since the request pattern it describes maps closely onto the ZigZa-style use case above.
Security, Compliance, and What Changed in the Last 90 Days
Security and compliance posture varies by platform maturity as much as by architecture. AWS Lambda Web Functions inherits the IAM, VPC, and compliance certifications of the broader Lambda product, since it is positioned as a new function type rather than a separate service, meaning existing AWS compliance programs should extend to it without a separate certification cycle, though as a nine-day-old launch it hasn’t yet accumulated the audit history classic Lambda has.
Cloudflare’s most notable security move of the last 90 days came during Birthday Week, when, according to its own wrap-up post, it announced opt-in native Web Crypto support for the post-quantum primitives ML-KEM and ML-DSA directly inside Workers. Cloudflare also expanded its Gateway-to-Workers integration into public beta on October 15, available on all Zero Trust plans, giving security teams a way to route traffic through Cloudflare’s secure web gateway before it reaches a Worker. Teams evaluating Cloudflare’s broader network-security posture, including its CDN and DDoS layer that sits in front of Workers traffic, should see the dedicated comparison of Cloudflare against AWS CloudFront for the delivery-layer side of that picture.
Vercel’s most consequential governance change is BYOC itself: by letting Functions run inside a customer’s own AWS account, Vercel effectively lets enterprise security teams apply their existing AWS-native controls, VPC boundaries, IAM policies, logging pipelines, to workloads that would otherwise run exclusively on Vercel’s own multi-tenant infrastructure. Separately, Vercel’s AI Gateway now supports a team-wide zero-data-retention (ZDR) setting, though turning it on adds a $0.10-per-1,000-request fee on Token Pass requests, according to Vercel’s own documentation.
One ecosystem change worth flagging for anyone standardizing on Cloudflare Workers long-term: on October 9, 2026, Cloudflare announced that the Deno team was joining the company, with reports that Deno Deploy, the Deno team’s own hosting platform, has a defined wind-down timeline while the open-source Deno runtime continues receiving fixes for longer. That shift doesn’t change Workers’ own roadmap directly, but it does suggest Cloudflare is absorbing Deno’s engineering talent to deepen Workers’ own JavaScript runtime rather than to prop up a competing hosting product.
Migration Guide: Moving Workloads Between Platforms
Migrating between these three platforms is rarely a drop-in swap, because each one assumes a different request-handling contract. The following approach applies regardless of direction.
- Audit the request-handling contract first. A Cloudflare Worker’s
fetchhandler, a Vercel Edge Function’s Web-standard Request/Response signature, and a Lambda Web Functions listening HTTP server are three different entry points. Moving from Workers to Lambda Web Functions is usually the easiest direction, since Web Functions accepts a standard server directly; moving the other way typically requires wrapping the server in an adapter. - Re-model the cost estimate before committing. Because AWS bills active CPU per millisecond, Cloudflare bills a blend of requests and CPU milliseconds with a monthly included allowance, and Vercel’s Edge Runtime bills 50ms Execution Units, the same workload can produce meaningfully different bills on each platform. Run the numbers using each platform’s own calculator before assuming a migration saves money.
- Check regional coverage against your user base. Lambda Web Functions launched in just five AWS regions, narrower than Cloudflare’s global edge network or Vercel’s network plus BYOC regions, so teams with a global user base should confirm latency from underserved regions before migrating latency-sensitive workloads to Web Functions.
- Validate stateful dependencies separately. Durable Objects, Workers KV, and Hyperdrive don’t have a one-to-one Lambda or Vercel equivalent; a migration plan needs a separate decision for where session state, counters, or cached connections live post-migration.
- Stage the cutover with a canary. Route a small percentage of production traffic to the new platform first, watch for cold-start regressions and billing anomalies for at least a full traffic cycle (including peak hours), and keep the rollback path to the original platform ready until the new one has proven itself under real load.
- Re-test concurrency assumptions. A team moving from classic one-request-per-instance Lambda Event Functions to Web Functions’ 128-concurrent-requests-per-environment model needs to confirm their application code is actually safe to run concurrently within a single process, global mutable state that worked fine under strict isolation can become a race condition under the new model.
Pros and Cons Compared
AWS Lambda Web Functions
- Pros: Runs unmodified Express, Hono, Fastify, and Next.js servers; active-CPU billing skips charges for idle I/O wait; no account-level monthly minimum; up to 128 concurrent requests per warm environment; integrates with existing Lambda tooling and IAM.
- Cons: Only five launch regions versus a global edge network; Node.js-only at launch; no managed AI-inference layer bundled in; nine days old, so it lacks the operational track record of Workers or Vercel Functions.
Cloudflare Workers
- Pros: V8-isolate architecture gives near-instant cold starts; global edge network from day one; bundled Workers AI at $0.011 per 1,000 Neurons; integrated KV, Durable Objects, and Hyperdrive; native post-quantum cryptography support added October 2026.
- Cons: $5/month account minimum even for near-zero usage; 5-minute hard CPU ceiling per invocation; isolate model constrains some native-binary and long-running workloads; Deno-team acquisition adds some roadmap uncertainty for teams relying on Deno-adjacent tooling.
Vercel Functions
- Pros: Broadest runtime support (Node.js, Python, Bun, Edge Runtime); BYOC on AWS gives enterprises a compliance-friendly deployment option; Vercel Daemons beta adds long-running background processing; deep Git-based deployment workflow.
- Cons: Confusing recent rebrand from Edge Functions to Functions can trip up anyone following older documentation; Edge Runtime’s 50ms-per-unit model is tighter than Workers’ CPU ceiling; new usage-based storage billing adds cost unpredictability for existing Pro teams; BYOC is Enterprise-only.
Which Platform Fits Your Use Case?
The table below maps common workload patterns to the platform best suited for them, based on the architecture and pricing differences covered above.
| Use case | Best fit | Why |
|---|---|---|
| Lift-and-shift Node.js/Express APIs without rewrites | AWS Lambda Web Functions | Runs unmodified HTTP servers with no adapter layer |
| Sub-50ms global API responses | Cloudflare Workers | V8-isolate model avoids container cold starts; global edge network |
| Lightweight AI/ML inference at the edge | Cloudflare Workers AI | Priced per Neuron with no separate GPU fleet to manage |
| Enterprise apps needing compute inside a customer’s own AWS account | Vercel Functions (BYOC) | GA October 15, 2026; keeps workloads inside the customer’s compliance boundary |
| Workloads with long idle/wait periods (DB calls, downstream APIs) | AWS Lambda Web Functions | Active-CPU billing skips charges for idle wait time |
| Persistent background jobs outside the request/response model | Vercel Daemons (public beta) | Entered beta October 15, 2026, for long-running processes |
The Verdict: What the Data Actually Shows
There is no single winner here, because the three platforms are converging on overlapping capabilities from three different starting points. Cloudflare Workers remains the fastest-starting, most globally distributed option for latency-sensitive public APIs, and its $5/month floor is a rounding error for any team running real production traffic. Vercel Functions, having shed the confusing Edge Functions branding, is now the strongest option for teams already standardized on Vercel’s Git-based deployment workflow who also need an enterprise-grade, compliance-friendly BYOC path onto their own AWS account.
Pricing-wise, the honest takeaway is that no single number crowns a winner, because the three platforms meter different things. A team running a spiky, low-volume API with long database waits will likely see the smallest bill from AWS Lambda Web Functions, since it has no account minimum and doesn’t charge for idle CPU time. A team running steady, moderate traffic that stays within Cloudflare’s included 10 million monthly requests and 30 million CPU milliseconds will often find the flat $5 Workers Paid plan cheaper than metering every request individually. And a team whose workload is dominated by short, bursty edge logic, redirects, A/B test routing, geolocation lookups, will find Vercel’s per-Execution-Unit model predictable, if slightly more expensive per unit of compute than Cloudflare’s bundled CPU-millisecond allowance.
Regional footprint is the other variable that should weigh as heavily as price in this decision. Cloudflare’s global edge network and Vercel’s combination of its own network plus AWS-region BYOC both outrun Lambda Web Functions’ five-region launch list today. For a team serving mostly North American or European traffic from one of those five AWS regions, that gap barely matters; for a team with meaningful Asia-Pacific traffic outside Tokyo, or users in Latin America, Africa, or Oceania, it’s a real latency cost that no amount of active-CPU billing cleverness offsets. That geographic constraint, more than any pricing or concurrency number, is the practical reason most teams with already-global traffic should treat Lambda Web Functions as a platform to pilot on a subset of workloads rather than a wholesale replacement for Workers or Vercel Functions on day nine of its existence.
AWS Lambda Web Functions is the one to watch. Its combination of active-CPU billing, 128-concurrent-request warm environments, and zero-friction support for unmodified Express and Next.js servers directly targets the single biggest complaint teams have had about classic Lambda for HTTP workloads: that adapting an existing server to Lambda’s handler contract was unnecessary friction. The catch is regional coverage, five launch regions is a real constraint next to Cloudflare’s global network, and nine days of production history is not enough to validate performance claims at the scale AWS’s existing Lambda customers, like Scania and ZigZa, already operate at. Teams building net-new HTTP services on AWS with database-heavy, I/O-bound logic have the clearest reason to try it first; teams with latency-critical global traffic or workloads already running well on Workers have little reason to migrate yet.
Frequently Asked Questions
Is AWS Lambda Web Functions the same as AWS Lambda?
No. Web Functions is a new function type that runs alongside classic Lambda, which AWS renamed Lambda Event Functions when Web Functions launched. Both run on the same underlying Lambda service, but they use different execution and billing models.
What happened to Vercel Edge Functions?
Vercel’s own documentation now marks the Edge Functions page as deprecated. The current product name is Vercel Functions, a broader umbrella that includes Node.js, Python, Bun, and an Edge Runtime option that preserves the old 50-millisecond Execution Unit billing model under a new name.
How much does AWS Lambda Web Functions cost?
AWS’s current pricing lists $0.30 per million requests, plus active-CPU charges billed per vCPU-second (in 1 ms increments) and memory charges billed per GB-second, with standard AWS data-transfer charges on top. There is no separate account-level monthly minimum.
Can Cloudflare Workers run a full Node.js server like Lambda Web Functions?
Not natively in the same way. Workers are built around a fetch event handler rather than a listening HTTP server process, so an existing Express-style server typically needs an adapter layer to run on Workers, whereas Lambda Web Functions accepts that same server unmodified.
What is the maximum concurrency for AWS Lambda Web Functions?
AWS confirmed on October 19, 2026 that a single warm execution environment can handle up to 128 concurrent requests before a new environment is started.
Is Cloudflare Workers cheaper than AWS Lambda Web Functions?
It depends on volume. Workers’ $5/month Paid plan includes 10 million requests and 30 million CPU milliseconds, which can make it cheaper at moderate, predictable volume. Lambda Web Functions has no monthly minimum, which can make it cheaper for very low or highly spiky traffic, since teams only pay for what they use.
What is Vercel BYOC and who can use it?
Bring Your Own Cloud lets Vercel Functions written in Node.js and Python execute inside a customer’s own AWS account while Vercel still manages deployment, environments, routing, and static assets. It became generally available on October 15, 2026, and is limited to Enterprise customers.
Should I migrate from Cloudflare Workers to AWS Lambda Web Functions?
Only if your workload is I/O-heavy, already lives on AWS, and would benefit from running an unmodified Node.js server rather than an adapted Workers handler. Teams with globally distributed, latency-critical traffic have little reason to leave Workers’ edge network for a five-region launch footprint this early in Web Functions’ rollout.
