Workers, Compute, EdgeWorkers, CloudFront's two-tier code, the Deno-based value entrants and the frontend clouds — the edge compute field organized by runtime, pricing shape and gravity.
Winner depends on your workload.
Winner depends on: what pulls you. Cloudflare Workers has the deepest platform gravity (state, storage, queues around the runtime); Fastly Compute the strongest performance story for compiled languages via WASM; CloudFront's Functions/Lambda@Edge split the cheapest light tier inside AWS; Akamai EdgeWorkers belongs where the delivery contract already lives; Bunny's Deno-based Edge Scripting is the value tier growing real capability.
Four runtimes, one promise
Every platform here makes the same promise — your code runs in hundreds of cities, milliseconds from users — on four different machines. V8 isolates (Cloudflare Workers, and CloudFront Functions' restricted JS at the lightest end) start in microseconds and share nothing. WebAssembly (Fastly Compute) compiles Rust, Go or JS ahead of time into sandboxes with near-native cold starts. Managed JavaScript runtimes (Akamai EdgeWorkers; Bunny's Deno-based Edge Scripting) trade some ceiling for operational simplicity. And container-lineage functions (Lambda@Edge) bring the fullest Node/Python capability with the heaviest cold starts and prices to match — the in-family split we measured in CloudFront Functions vs Lambda@Edge.
| Platform | Runtime & price shape | Gravity |
|---|---|---|
| Cloudflare Workers | V8 isolates; $5/mo base with millions of requests included, then per-request + CPU-time metering | The ecosystem: KV, R2, Durable Objects, Queues, D1 — the runtime is the door to a platform |
| Fastly Compute | WASM, compiled languages first-class; usage-priced | Delivery-engineering estates that already think in VCL and want real code with real performance |
| CloudFront Functions / Lambda@Edge | $0.10/M invocations (Functions) vs $0.60/M + GB-seconds (Lambda@Edge) | AWS: IAM, the media stack, and every origin you already run there |
| Akamai EdgeWorkers | JS runtime attached to delivery properties; contract-priced | The Akamai estate itself — code where the config already lives, per our EdgeWorkers comparison |
| Bunny Edge Scripting | Deno-based serverless with usage billing and instant deploys | Value-tier estates adding logic without changing vendors |
| Frontend clouds (Vercel, Netlify) / Deno Deploy | Edge functions bundled into app platforms | The framework: you buy the deploy workflow, edge compute comes with it |
Gravity beats benchmarks
Cold-start charts sell platforms; ecosystems keep them. The durable pattern across estates we audit: teams choose the edge platform adjacent to what they already operate — Workers because their DNS and proxy are Cloudflare, Lambda@Edge because the origin is AWS, EdgeWorkers because the Akamai contract exists — and the choice compounds, because edge code quickly grows dependencies on the platform's storage and state primitives. That is not a mistake to avoid; it is a decision to make deliberately. The moment your function needs a coordination primitive or a key-value read, you have chosen a platform, not a runtime — the seam we scored head-to-head in Fastly Compute vs Cloudflare Workers.
Pricing shapes, not price points
Three shapes cover the field. Base-plus-metering (Workers) is predictable until CPU-time metering meets a hot loop. Pure per-invocation (CloudFront Functions at a dime per million) makes light request manipulation nearly free and heavier work impossible by design — the constraint is the price. And duration-billed (Lambda@Edge's GB-seconds) means your bill is your code's efficiency, which cuts both ways. Whichever shape you buy, meter the edge like the production compute it is: an accidental loop in a function invoked on every request is the fastest-compounding bill in the industry.
Choosing without regret
Sort your edge logic into three piles: request manipulation (headers, redirects, tokens — any platform, cheapest wins), stateful coordination (rooms, counters, sessions — Workers' Durable Objects lead today), and origin-replacing compute (rendering, personalization — the WASM and Lambda tiers earn their keep). If pile one is all you have, revisit whether a rules engine covers it for less — the border we drew in the rules engines roundup. Facts verified against provider documentation, July 2026.
Sorting your edge logic into rules, functions and platform bets — and pricing each pile? The assessment does exactly that.