AT A GLANCE
| Platform | Runtime model | Free tier | Paid entry pricing |
|---|---|---|---|
| Cloudflare Workers | V8 isolates (JavaScript/TypeScript/Wasm), no per-request container boot | 100,000 requests/day, 10ms CPU time/invocation | $5/month minimum — includes 10M requests + 30M CPU-ms, then $0.30/million requests and $0.02/million CPU-ms |
| Fastly Compute | WebAssembly sandbox (JS, Rust, Go, C++ all compiled to Wasm) | First 10M requests and first 100M vCPU-ms free, per month | Pay-as-you-go from $0.50/million requests (10M–500M tier) and $0.05/million vCPU-ms, or a $500/month Starter package |
| Vercel Functions (Fluid Compute) | Node.js (recommended) or legacy V8-isolate Edge runtime; Vercel is actively steering apps toward Node.js on Fluid Compute | Hobby: 1M invocations, 4 CPU-hours, 360 GB-hrs memory/month | Pro: on-demand Active CPU + Provisioned Memory, billed per region (e.g. $0.128/CPU-hour and $0.0106/GB-hr in US regions) |
Short Verdict
“Edge compute” no longer means one thing. Cloudflare Workers is the most mature V8-isolate platform and the cheapest entry point for high-request, low-per-request-CPU workloads (API proxies, auth checks, A/B routing). Fastly Compute is the WebAssembly-native option, letting you ship Rust, Go, or C++ to the edge, not just JavaScript, with a generous free tier and usage-based pricing that rewards low CPU time per request. Vercel is the odd one out in 2026: its own documentation now recommends migrating away from the Edge runtime toward Node.js on “Fluid Compute,” which is not a classic isolate-at-every-PoP model but a CPU/memory-metered compute layer — meaning Vercel is less a pure edge-isolate competitor to Cloudflare/Fastly today and more a full-stack hosting platform with edge routing on top.
What Each Platform Actually Runs
Cloudflare Workers executes code in V8 isolates — the same lightweight JavaScript sandboxing engine Chrome uses for browser tabs — rather than spinning up a container or VM per request. Because an isolate doesn’t need to boot an OS or runtime process, Workers avoids the classic serverless cold-start penalty; Cloudflare’s pricing page confirms requests are billed on CPU time actually used, not wall-clock duration, and the free tier caps CPU time per invocation at 10ms, with paid plans defaulting to a 30-second CPU cap (configurable up to 5 minutes per invocation, 15 minutes for Cron Triggers/Queue consumers).
Fastly Compute takes a different technical route: everything compiles to WebAssembly and runs in Fastly’s Wasmtime-based sandbox, regardless of source language. Fastly markets this explicitly as a memory-safety advantage (“pioneering WebAssembly” to guard against classes of memory-safety bugs) and supports JavaScript, Rust, Go, and C++ as first-class source languages, compiled ahead of time to Wasm rather than interpreted per request. Fastly’s own FAQ claims the model “eliminates cold starts, allowing code to execute in microseconds” — a vendor claim with no published methodology, so treat the magnitude skeptically even though the direction (fast, AOT-compiled Wasm startup) is architecturally plausible.
Vercel’s position has shifted meaningfully. Its Edge Runtime (V8-isolate based, similar in spirit to Workers) still exists, but Vercel’s own documentation as of 2026 explicitly says: “We recommend migrating from edge to Node.js for improved performance and reliability,” and as of Next.js 16.3, setting runtime = 'edge' in a Next.js app is no longer even honored — routes run on Node.js regardless. The replacement is Fluid Compute, a pricing and execution model that bills “Active CPU” (only while your code is actually executing, pausing during I/O wait) plus “Provisioned Memory” (billed for the full instance lifetime). This is architecturally closer to a smart, auto-scaled container/function model than to a stateless isolate running at every edge PoP simultaneously.
Comparison: Limits, Languages, and Pricing Mechanics
| Dimension | Cloudflare Workers | Fastly Compute | Vercel Functions |
|---|---|---|---|
| Primary languages | JavaScript/TypeScript, plus Wasm-compiled languages | JavaScript, Rust, Go, C++ (all → Wasm) | Node.js (recommended), legacy Edge runtime (V8 subset), Bun supported |
| Max execution window | Up to 5 min CPU/invocation (paid), 15 min for scheduled/queue triggers | Not published in the pages reviewed here | Edge runtime: must start responding within 25s, can stream up to 300s |
| Filesystem / Node API access | No filesystem; Node.js compatibility layer (nodejs_compat) covers a growing subset | No native filesystem; language-specific Wasm SDKs | Full Node.js APIs on the Node.js runtime; Edge runtime explicitly blocks filesystem access and most Node APIs |
| Billing unit | Requests + CPU-ms | Requests + vCPU-ms | Invocations + Active CPU (per-hour) + Provisioned Memory (GB-hr), varies by region |
| Code size limit | Not covered in the pages reviewed here | Not covered in the pages reviewed here | Edge runtime: 1MB (Hobby) / 2MB (Pro) / 4MB (Enterprise), gzip-compressed |
Trade-offs
- Cloudflare Workers pros: largest, most mature edge network; cheapest at high request volume with low per-request CPU; simple mental model (one isolate, one request).
- Cloudflare Workers cons: JavaScript/Wasm-first — not a natural fit if your team wants to ship Go or Rust services without a JS entry point; Node.js compatibility is a shim, not full parity.
- Fastly Compute pros: genuine multi-language support (Rust/Go/C++ compiled directly, not transpiled); strong free tier (10M requests + 100M vCPU-ms/month); Wasm sandboxing is a real security property, not just marketing.
- Fastly Compute cons: smaller ecosystem and community than Cloudflare’s; the $500/month Starter package is a bigger jump than Cloudflare’s $5/month entry if you outgrow the free tier but aren’t ready for enterprise contact-sales pricing.
- Vercel pros: best-in-class developer experience for Next.js and frontend-framework deployments; Fluid Compute’s “pause CPU billing during I/O wait” model is genuinely good for API-call-heavy, I/O-bound functions; full Node.js API access removes the edge-runtime limitation entirely.
- Vercel cons: no longer positioned as a pure edge-isolate platform — if the reason you wanted “edge compute” was running the exact same stateless isolate at every PoP with no regional pinning, Vercel’s own guidance is steering you toward regional Node.js functions instead.
Who Should Use Which
Choose Cloudflare Workers for latency-sensitive, high-volume, low-compute-per-request logic: auth/JWT validation at the edge, API gateways, bot mitigation, header rewriting, and anything where you want the same JS/TS logic running identically at hundreds of PoPs with minimal per-request cost. Choose Fastly Compute when you specifically need a non-JavaScript language at the edge (Rust or Go teams in particular), or when Wasm’s sandboxing model matters for your security posture, and your traffic profile fits comfortably inside or just above the free tier. Choose Vercel when your priority is shipping a full Next.js/React application with server-side rendering, API routes, and a polished CI/preview workflow — and treat its edge capabilities as a routing/CDN layer on top of a primarily Node.js compute model, not as a drop-in Workers/Compute replacement. Teams that need true multi-region active-active isolate execution with no single compute “home region” should look at Cloudflare or Fastly first.
Bottom Line
The three platforms have diverged more than they’ve converged since the “edge functions” category first took shape. Cloudflare and Fastly are still competing head-to-head as isolate/Wasm-based edge runtimes with genuinely comparable pricing mechanics (both bill requests + compute-time, both offer meaningful free tiers). Vercel has moved toward a different architecture entirely — Node.js-first, CPU/memory-metered, I/O-aware billing — and now explicitly discourages its own Edge runtime in favor of that model. Match the decision to what you’re actually building, not to which vendor says “edge” the loudest.
FAQ
Is Vercel still an “edge computing platform” in 2026? It still offers an Edge runtime and edge routing/CDN, but Vercel’s own docs now recommend Node.js on Fluid Compute over the Edge runtime for most workloads, and Next.js 16.3+ no longer honors runtime: 'edge' at all — so its center of gravity has moved toward regional compute rather than universal edge isolates.
Can I run a database connection from an edge function? All three platforms restrict or complicate persistent TCP connections from isolate/Wasm runtimes; the common pattern is an HTTP-based or connection-pooling-aware database driver rather than a raw long-lived socket, regardless of platform.
Which is cheapest at low volume? Both Cloudflare Workers and Fastly Compute have usable free tiers (100K requests/day and 10M requests/month respectively) before any payment is required; Vercel’s Hobby plan is also free but intended for personal/non-commercial use per its terms.
Do these platforms support WebAssembly the same way? No — Fastly’s Compute is Wasm-native for every supported language, while Cloudflare Workers runs JS/TS natively in V8 and supports Wasm as a module you call into, not as the universal compilation target. For a deeper look at server-side Wasm runtimes themselves (Wasmtime, Fermyon Spin) rather than the hosted edge platforms built on them, see our related piece linked below.
Sources
- Cloudflare Workers: Pricing (developers.cloudflare.com)
- Fastly Compute: Product Page
- Fastly Pricing
- Vercel Documentation: Edge Runtime
- Vercel Documentation: Fluid Compute Pricing
Related reading on this site: WebAssembly on the Server in 2026: Wasmtime, Fermyon Spin, and the Edge-Native Runtime Race.
Discover more from Software Online Review
Subscribe to get the latest posts sent to your email.
