Here's the conversation I have with at least one team every quarter: "Our serverless bill tripled and traffic only went up 20%." Nine times out of ten, the culprit isn't traffic. It's that somebody shipped a function with an unnecessary await, a synchronous JSON.parse on a 4MB payload, or a cold dependency tree that adds 40ms to every cold start — and the platform they picked bills by CPU time, not wall-clock time, not request count, not anything intuitive. You can serve the exact same response and pay 5x more depending on how efficiently your code runs, and most teams have no idea this is true until the invoice arrives.

That's the actual state of serverless and edge compute in 2026: the platforms have converged on similar primitives (V8 isolates or microVMs, request-scoped billing, global points of presence), but they have not converged on how they charge you for using them. Cloudflare bills CPU milliseconds. AWS bills GB-seconds. Vercel bills "Active CPU" which pauses during I/O wait (genuinely good) but adds provisioned memory as a second, separate meter (less good). Netlify quietly rebuilt its entire pricing model into an opaque credit system in the last year. Fastly still prices like the CDN company it used to be. None of this is disclosed clearly at signup, and all of it compounds at scale.

I evaluated six platforms teams actually put in production in 2026, not vaporware. Here's what's under the hood, what it actually costs, and where each one will bite you.

Cloudflare Workers

The Core Engine: V8 isolates — not containers, not microVMs. Cloudflare runs your JavaScript/TypeScript/WASM/Rust (via wasm-bindgen) inside the same isolate technology Chrome uses to sandbox tabs, which is why cold starts are sub-millisecond: there's no OS boot, no container runtime, just a new V8 context. Runs on Cloudflare's network across 300+ cities. Storage primitives (KV, D1 SQLite, Durable Objects, R2, Queues, Vectorize) are first-party and bind directly into the Worker without extra network hops.

Hard Specs & Pricing:

  • Free: 100,000 requests/day, 10ms CPU time per invocation, 100K KV reads/day, 1K KV writes/day, 5GB D1 storage.
  • Paid ($5/month minimum): 10 million requests included/month, then $0.30 per additional million. 30 million CPU-milliseconds included/month, then $0.02 per additional million CPU-ms. Max CPU time per invocation is 5 minutes (configurable down). No egress/bandwidth charges at all — this is the single biggest structural advantage over AWS and Vercel.
  • Worked example straight from Cloudflare's own docs: a Worker serving 15M requests/month at 7ms average CPU comes out to $8.00/month total. The same Worker at 100M requests/month is $45.40.
  • Durable Objects (stateful, single-threaded actors) bill separately: 1M requests/month included, then $0.15/million; 400,000 GB-seconds included, then $12.50/million GB-seconds.

The Good:

  • Zero egress fees, full stop. This alone can be a 4-5x savings over AWS for bandwidth-heavy workloads.
  • CPU-time billing means I/O-bound code (waiting on a database, calling an API) costs almost nothing — you're not billed for wall-clock time, only active execution.
  • The bundled storage layer (D1, KV, R2, Queues, Durable Objects) means you can build a genuinely complete backend without leaving the platform or paying separate vendors.

Evaluator Considerations:

  • The free tier's 10ms CPU limit per invocation is brutal for anything beyond trivial logic — a single unoptimized JSON transform or a synchronous crypto operation can blow through it.
  • Vendor lock-in is real. Durable Objects, D1's row-based billing model, and the Workers runtime APIs don't port cleanly to any other platform. You're writing to Cloudflare's abstractions, not standard Node.js.
  • The CPU-time billing model, while fair in principle, requires you to actually understand your code's execution profile to forecast costs — most teams don't, and get surprised the first time a slow regex or an unindexed D1 query triples their CPU-ms line item.

AWS Lambda

The Core Engine: Firecracker microVMs — lightweight, KVM-based virtual machines purpose-built by AWS for exactly this workload. Unlike Workers' isolates, each Lambda invocation gets a genuine, isolated VM boundary (better multi-tenant security guarantees, worse cold-start latency). Supports essentially every language via runtimes or custom containers, which is Lambda's real differentiator: it's not a JavaScript-first platform, it's a run-anything platform.

Hard Specs & Pricing:

  • Always-free tier (never expires, unlike most AWS free tiers): 1 million requests/month and 400,000 GB-seconds of compute/month, shared across x86 and Arm.
  • Paid: $0.20 per million requests, plus $0.0000166667 per GB-second on x86 (about 20% cheaper on Arm/Graviton2, roughly $0.0000133 per GB-second). GB-seconds = memory allocated (in GB) × execution duration (in seconds) × invocation count.
  • The trap: memory allocation controls CPU speed, not just RAM ceiling. A 2,048MB function runs roughly twice as fast as a 1,024MB one — but costs four times as much per second of wall-clock time if you don't actually need the extra throughput. Teams routinely over-provision memory "to be safe" and quietly triple their bill.
  • Provisioned Concurrency (to eliminate cold starts) is billed in addition to standard invocation costs and does not draw from the free tier — it's a flat idle tax whether or not traffic arrives.

The Good:

  • The free tier is genuinely permanent and genuinely generous for light workloads — a function at 128MB/200ms duration can serve roughly 15.6 million invocations/month for $0.
  • Runs literally any language via custom runtimes or container images up to 10GB — no lock-in to a JS-first execution model.
  • Deepest integration with the rest of AWS (EventBridge, S3 triggers, SQS, Step Functions) if you're already AWS-native.

Evaluator Considerations:

  • No CPU-time billing pause for I/O wait — you pay for the full GB-second duration of the invocation regardless of whether the function is computing or blocked on a network call. This is the opposite of Cloudflare's and Vercel's model and it matters enormously for anything that calls a database or an external API.
  • Data egress is billed separately at standard AWS rates (not included in the Lambda price sheet) — a genuinely hidden cost most Lambda pricing guides don't even mention until you hit it.
  • CloudWatch Logs, by default, logs everything and bills separately per GB ingested and stored — an unfiltered DEBUG-level Lambda function can rack up a logging bill larger than the compute bill itself.

Vercel Functions (Fluid Compute)

The Core Engine: Vercel's newer "Fluid Compute" model runs functions on a shared execution substrate that keeps instances warm across requests where possible, reducing cold starts versus classic one-request-per-instance serverless. Billing follows: Active CPU (only the milliseconds your code is genuinely executing — I/O wait doesn't count) plus Provisioned Memory (GB-hours the instance is loaded, whether active or waiting).

Hard Specs & Pricing:

  • Hobby (free, non-commercial only): 100GB bandwidth, 1M function invocations, 4 hours Active CPU, 360 GB-hours provisioned memory, 1M edge requests/month. Hard caps — hit one and the project stops serving until next month or you upgrade. No overage billing on Hobby.
  • Pro ($20/seat/month, includes $20 usage credit): 1TB bandwidth, 10M edge requests included then $2/million, function invocations $0.60/million, Active CPU $0.128/hour, provisioned memory $0.0106/GB-hour, bandwidth overage $0.15/GB.
  • The billing surface has grown to roughly eight separate metered dimensions (bandwidth, edge requests, invocations, CPU, memory, image optimization, builds, and now AI Gateway tokens) — more granular than any competitor here, which cuts both ways.

The Good:

  • Active CPU billing that genuinely pauses during I/O wait is a real, verifiable cost advantage for API-heavy or database-heavy functions — you're not paying AWS-style full-duration GB-seconds for a function that's 90% waiting on Postgres.
  • Best-in-class DX for Next.js specifically — if your stack is Next.js, the deployment and preview-environment tooling here has no real peer.
  • The Pro plan's $20 usage credit genuinely absorbs modest usage growth without a separate bill showing up.

Evaluator Considerations:

  • Hobby plan explicitly forbids commercial use and Vercel enforces this — you cannot legitimately run a revenue-generating side project on the free tier, unlike Cloudflare, Deno, or Netlify's free tiers.
  • Eight metered dimensions means the "$20/month" headline is almost never what you actually pay once real traffic arrives — teams have reported burning through 1,000+ GB-hours in under two weeks on AI-adjacent workloads (streaming responses, long-running agent calls) that weren't scoped for Fluid Compute's memory-time billing.
  • Regional price differentials exist and aren't obvious upfront — Vercel Sandbox compute in Paris or San Francisco runs roughly 38% more than in Cleveland or Washington D.C., a detail buried in changelogs, not the pricing page.

Deno Deploy

The Core Engine: V8 isolates, same underlying primitive family as Cloudflare Workers, but running on Deno's own runtime rather than a custom-built one — meaning full Node.js/npm compatibility (via Deno's compat layer) alongside web-standard fetch/Request/Response APIs. Deno KV is the built-in key-value store, and the platform recently absorbed Deno Sandbox (isolated microVM execution for untrusted/AI-generated code) under the same billing umbrella.

Hard Specs & Pricing: (Deno rebuilt this pricing model in 2026 — it's now metered, not flat-rate)

  • Free: 1M requests/month, 20GiB egress bandwidth, 5 custom domains, 10 hours Active CPU/month, 150 GiB-hours memory time, 10GB revision storage, 10 concurrent apps, 3 team members.
  • Pro ($20/month): 5M requests included (+$2/million), 200GiB egress (+$0.20/GiB), 100 custom domains, 50 hours Active CPU (+$0.10/hour), 750 GiB-hours memory (+$0.025/GiB-hour), 10 team members, sandboxes enabled.
  • Active CPU billing here mirrors Vercel's philosophy — you're not billed while your app waits on I/O, only while it's genuinely computing.

The Good:

  • Free tier commercial use is explicitly allowed (no Vercel-style non-commercial restriction), and 1M requests/month free is competitive with Cloudflare's daily-reset model but on a monthly basis, which is friendlier for bursty traffic.
  • First-class TypeScript with zero build-step friction — genuinely faster iteration loop than most competitors for TS-heavy teams.
  • Full Node/npm compatibility means less porting effort than Cloudflare Workers, which still has real gaps in Node API coverage.

Evaluator Considerations:

  • Deno Deploy overhauled its entire pricing model in 2026 (moving from a simpler flat-rate structure to the metered CPU/memory/egress system described above) — if you evaluated this platform even a year ago, everything you remember about its pricing is now wrong.
  • Smaller edge footprint and ecosystem than Cloudflare or AWS — fewer third-party integrations, smaller community, fewer battle-tested examples for edge cases.
  • 512MB max memory allocation per application is a real ceiling for anything memory-intensive; you'll hit it before you hit Cloudflare's or AWS's equivalents.

Netlify Edge Functions

The Core Engine: Deno-based edge runtime (yes, built on Deno, distinct from Netlify Functions which run on AWS Lambda under the hood) deployed across Netlify's CDN points of presence, positioned for personalization, A/B testing, and auth-at-the-edge use cases layered on top of Netlify's core static-hosting product.

Hard Specs & Pricing: (This is the section to read carefully — Netlify replaced its old metered model with a credit system in the last year, and it's the least transparent pricing structure in this roundup)

  • Free: 300 credits/month, shared across all usage. Bandwidth costs 20 credits/GB (~15GB total before exhaustion), a production deploy costs 15 credits (~20 deploys/month), function compute costs 10 credits/GB-hour with a 10-second execution timeout. Edge Functions get a separate allocation of 1,000,000 invocations/month, not drawn from the shared credit pool.
  • Personal ($9/month): 1,000 credits. Pro ($20/member/month): 3,000 credits, unlimited members, higher tiers purchasable up to 20,000 credits/month.
  • The trap, documented repeatedly in cost-tracking blogs and user complaints: credits run out and the free plan does not auto-recharge — the site simply stops serving until the next billing cycle or you upgrade. Multiple public reports describe surprise bandwidth bills in the $700–$100,000+ range when the credit-consumption warning system failed to fire before a traffic spike.

The Good:

  • Edge Functions' separate 1M-invocation allocation (not drawn from the shared credit pool) is genuinely generous and hard to exhaust for most workloads.
  • Deploy previews for every pull request cost 0 credits — genuinely free, unlike production deploys.
  • If your team is already deep in the Netlify ecosystem (Forms, Identity, Build plugins), the platform coherence is real.

Evaluator Considerations:

  • The credit system consolidates 15+ previously separate metrics into one opaque number, which makes it materially harder to predict your bill from usage patterns alone — you have to convert every action into "credits" mentally, and the conversion rates aren't intuitive (why is a deploy 15 credits and a GB of bandwidth 20?).
  • The site-suspension-on-credit-exhaustion behavior, combined with reports of usage-warning notifications not firing reliably, is the single riskiest characteristic of any platform in this article for a team that can't tolerate unannounced downtime.
  • Edge Functions specifically (as opposed to standard Functions) require rewriting Node-targeted code against Deno's APIs — not a drop-in migration if your existing serverless code assumes a Node runtime.

Fastly Compute

The Core Engine: WebAssembly-first, built on Wasmtime, running Rust, JavaScript/TypeScript (via a Wasm compile step), Go, and any other WASI-compatible language. This is architecturally the most different platform in the roundup — everything else here treats WASM as an optional target; Fastly Compute treats it as the only target, which buys genuinely fast, consistent cold starts (component-model composition improved instantiation time roughly 40% in Fastly's own 2026 benchmarking) at the cost of a JavaScript deploy pipeline that has to compile through Wasm rather than ship interpreted code directly.

Hard Specs & Pricing:

  • Free tier: 10 million Compute requests/month free, 100 million Compute vCPU-milliseconds/month free. Beyond that: requests bill at $0.50 per million; vCPU time is metered in 10ms increments after the first 20ms of each request (which is free), at roughly $0.000045 per vCPU-second, plus a separate compute-duration charge around $0.000035 per GB-second.
  • No permanent free CDN tier the way Cloudflare has one — Fastly's broader CDN products run on straight usage-based billing with an approximate $50/month floor once you're past evaluation-scale trial credits.

The Good:

  • The ability to read and mutate cached objects from inside the same Wasm invocation, without a separate API round-trip, is a genuine architectural advantage none of the JS-isolate platforms replicate the same way.
  • KV Store latency (roughly 1.1ms same-POP reads as of 2026 benchmarks) is excellent, and the Rust-first developer experience — live-reload local dev against a local Wasm runtime — is the tightest feedback loop of any platform here for Rust teams specifically.
  • Genuinely strong for teams that need WebAssembly portability across runtimes (not locked to one vendor's JS dialect the way Workers or Deno Deploy functions effectively are).

Evaluator Considerations:

  • The ecosystem is thinner than Cloudflare's — Fastly's KV Store and Config Store are simple primitives without D1's relational-query capability or R2's S3-compatible object storage depth. If your workload needs anything beyond key-value lookups at the edge, you're building it yourself.
  • Rust compilation for production deploys takes 15–45 seconds depending on crate complexity, a materially slower iteration loop than the near-instant deploys on Workers or Deno Deploy.
  • No durable, permanent free tier for the broader Fastly CDN product line the way competitors offer — the generous Compute allocation sits on top of a company that otherwise prices like an enterprise vendor, and that posture shows up the moment you need anything beyond the core compute product.

Comparative Table

Tool Core Architecture Entry Pricing / Model Free Tier Allowance Best For
Cloudflare Workers V8 isolates, global edge network, first-party storage (D1, KV, R2, Durable Objects) $0 free / $5/mo min. paid; CPU-time metered, zero egress fees 100K req/day, 10ms CPU/invocation Teams wanting a full backend (compute + storage) with no bandwidth tax
AWS Lambda Firecracker microVMs, run-anything language support Pay-per-use: $0.20/1M req + $0.0000167/GB-s 1M requests + 400,000 GB-s/month, permanent Polyglot workloads already inside the AWS ecosystem
Vercel Functions Fluid Compute, shared warm-instance substrate $0 (non-commercial) / $20/seat/mo Pro; Active CPU + provisioned memory metered 1M invocations, 4 hrs Active CPU, 100GB bandwidth Next.js-first teams who value DX over billing simplicity
Deno Deploy V8 isolates on Deno runtime, Node/npm compatible $0 free (commercial OK) / $20/mo Pro; Active CPU + egress metered 1M req/mo, 10 hrs Active CPU, 20GiB egress TypeScript-first teams wanting Node compatibility without Vercel's restrictions
Netlify Edge Functions Deno-based edge runtime layered on static hosting $0 free / $9–$20/mo; opaque shared-credit system 300 credits/mo + separate 1M edge-function invocations Teams already on Netlify for static/Jamstack hosting
Fastly Compute WebAssembly (Wasmtime), Rust/Go/JS via Wasm compile $0 free / ~$50/mo floor beyond trial credits; per-request + vCPU-time metered 10M requests + 100M vCPU-ms/month Rust/WASM-native teams needing cache-aware edge logic

Final Architectural Verdict

Small teams and solo builders shipping commercial products: Deno Deploy is the most underrated pick here specifically because its free tier permits commercial use where Vercel's doesn't, and its Active-CPU billing model protects you from AWS-style full-duration charges on I/O-bound code. Cloudflare Workers is the close second if you want the deepest bundled storage layer and are willing to write against Cloudflare-specific APIs.

Teams that need to run genuinely polyglot workloads (Python, Java, Go, .NET, not just JS/WASM) or are already AWS-native: Lambda remains the only serious choice. The permanent free tier is real, and the ecosystem depth (EventBridge, Step Functions, container image support) has no real substitute. Just model your GB-seconds honestly — right-size memory instead of over-provisioning "to be safe," and budget CloudWatch Logs and egress as separate line items from day one.

Next.js-committed teams who can absorb Vercel's eight-dimension billing surface: Vercel is still the best DX in the category, full stop. But go in with eyes open about the non-commercial Hobby restriction and model your bill against Fluid Compute's memory-time meter before you scale traffic, not after.

Compliance-sensitive teams, or anyone who has been burned by a surprise bill once already: Avoid Netlify's Edge Functions for anything revenue-critical until the credit-exhaustion behavior and warning reliability improve — the documented pattern of sites going dark on credit exhaustion, combined with reported five- and six-figure bandwidth surprises, is a real operational risk, not a theoretical one.

Rust-first teams building cache-aware edge logic, or anyone who genuinely needs WebAssembly portability across runtimes: Fastly Compute is architecturally the most interesting platform in this list and the best fit if that's your actual workload — but understand you're buying into an enterprise-CDN pricing posture the moment you need anything beyond the generously-free compute tier.

No platform here is free of a real, structural trade-off. The honest takeaway: pick based on your billing model's fit to your actual traffic shape (I/O-bound vs. CPU-bound, bursty vs. steady, bandwidth-heavy vs. compute-heavy), not on the headline free-tier number, because every platform in this article has at least one meter that will surprise a team that didn't read this far.