Originally published as an authoritative engineering dispatch at Lumeir Systems Lab. For complete interactive vector schematics and FinOps telemetry, examine the original audit on Lumeir.
Cloudflare Workers, AWS Lambda, and Fastly Compute represent three incompatible answers to the same architectural question: how do you isolate untrusted tenant code on a shared edge substrate without paying a cold start penalty that destroys latency budgets. The divergence starts at the isolation primitive. Cloudflare multiplexes V8 isolates inside a single process. AWS Lambda boots a dedicated Firecracker microVM per execution environment. Fastly Compute compiles WebAssembly modules ahead of time and runs them inside Wasmtime linear memory sandboxes. Those three choices produce different cold start profiles, tail latencies, resource costs, and failure domains.
Cloudflare Workers favor density and start speed. AWS Lambda favors hardware isolation at the cost of a slower first invocation. Fastly Compute favors deterministic native execution with a very small runtime. The rest of this audit measures what those tradeoffs mean at the edge.
1. Core Architectural Internals & Runtime Execution Models
Cloudflare Workers: V8 Isolate Multi-Tenancy
Cloudflare Workers run inside V8 isolates. An isolate is V8’s unit of execution: it owns a separate heap, a separate garbage collector, and a separate compilation cache. The Workers runtime creates many isolates inside a single host process. Each isolate is multi-tenant on the host, but no isolate can directly reference another isolate’s JavaScript objects. Cross-isolate access is controlled through serialized bindings and worker-to-worker service bindings.
The memory boundary is not a hardware page table. V8 enforces isolation in software. Modern V8 deployments use the V8 sandbox, which reserves a large virtual address region and keeps object pointers inside a compressed cage. That design prevents many memory corruption paths from forging raw host pointers. It is software fault isolation, not a hypervisor boundary. An exploit that escapes the V8 sandbox can in theory reach the host process. Cloudflare mitigates this with process isolation across customer cohorts, reduced privilege, and aggressive patching of V8.
Cold starts do not require kernel boot. The host process is already running. A cold start means creating an isolate, initializing standard globals, loading the worker script, and executing top-level module code. JavaScript executes first through V8’s Interpreter. Hot functions are later compiled by Maglev or TurboFan. The result is short cold starts but some JIT warm-up variance. Warm invocations can become faster after JIT compilation, but deoptimizations and recompilation can occasionally disturb P99.
AWS Lambda: Firecracker KVM MicroVMs
AWS Lambda uses Firecracker, a Rust virtual machine monitor built on Linux KVM. Each Lambda execution environment is a separate microVM with a minimal guest kernel. The microVM receives its own virtual CPU, its own memory, and a reduced set of virtio devices. Firecracker does not emulate a full PC. It strips away BIOS, VGA, and most legacy devices. That keeps boot overhead much lower than QEMU, but it still boots an actual guest kernel.
The isolation boundary is hardware virtualization. The guest kernel runs in its own address space. KVM page tables separate the microVM from the host and from other microVMs. A kernel exploit inside a Lambda function does not directly expose the host. That is the strongest isolation model in this comparison.
Cold starts are structurally heavier. Lambda must acquire capacity, boot the Firecracker microVM, start the language runtime, load the handler, and then execute the invocation. The microVM boot and runtime initialization dominate. For Node.js or Python functions, a cold start can range from roughly 130 milliseconds to several hundred milliseconds. Larger deployment artifacts extend that further because code must be read, extracted, and parsed inside the guest.
Warm invocations still involve guest kernel scheduling, loopback networking for the Lambda Runtime API, and occasional KVM exits. Those costs are small, but they are not zero. Each invocation crosses the guest kernel and the virtualized device path. Compared to in-process isolate dispatch, per-invocation overhead is higher.
Fastly Compute: Ahead-of-Time WebAssembly in Wasmtime
Fastly Compute runs compiled WebAssembly modules. The original Lucet runtime and its successor, Wasmtime with Cranelift, compile WebAssembly ahead of time to native machine code. There is no JIT compiler in the request path. A compiled module is cached at the edge and loaded as native code. Cold start is dominated by module instantiation: mapping read-only code pages, allocating linear memory, copying data segments, initializing globals, and calling the module start function.
WebAssembly linear memory is a contiguous byte array with enforced bounds. The compiler inserts bounds checks or uses guard regions to trap out-of-bounds accesses. Each instance gets its own linear memory and its own stack. The sandbox is not a guest kernel and not a separate process. It is a native code sandbox with compiler-inserted checks and runtime-managed memory. That makes Fastly Compute much faster to start than a microVM and more deterministic than JIT execution.
There is no JIT warm-up. The code path at the first invocation is the same code path as the ten-thousandth invocation. That produces very stable P50 and P99 numbers. The limitation is ecosystem shape: WebAssembly has no direct access to arbitrary Node.js libraries and runs primarily through WASI and Fastly’s edge APIs.
📊 [Visual Blueprint: Figure 1: P50 vs P99 Tail Latency & Concurrency Throughput Audit across evaluated production runtimes.](High-DPI interactive SVG architecture schematics are available in the original dispatch on Lumeir).
2. Empirical Cold Start & Tail Latency Benchmarks (P50, P90, P99, P99.9)
The Lumeir audit measured each runtime from 30 global synthetic probes during a seven-day window. The probe set included 12,000 cold start samples per runtime and 100,000 warm invocations per runtime. Empty payload means a 2 KB handler with no external dependencies. The 15 MB dependency test used a tree-shaken build containing a serialization library, an SDK, and generated protocol code. Global edge ingress latency is the network round trip from probe to nearest edge plus first-byte response overhead, with no origin fetch. Memory footprint is observed idle allocation from runtime telemetry and Firecracker counters.
| Metric | Cloudflare Workers | AWS Lambda | Fastly Compute |
|---|---|---|---|
| Cold start, empty payload P50 | 4.8 ms | 142 ms | 0.9 ms |
| Cold start, empty payload P90 | 7.2 ms | 220 ms | 1.6 ms |
| Cold start, empty payload P99 | 9.4 ms | 335 ms | 2.5 ms |
| Cold start, empty payload P99.9 | 14.0 ms | 520 ms | 4.3 ms |
| Cold start, 15MB dependencies P50 | 56 ms | 640 ms | 11.9 ms |
| Cold start, 15MB dependencies P90 | 84 ms | 910 ms | 18.4 ms |
| Cold start, 15MB dependencies P99 | 112 ms | 1230 ms | 27.3 ms |
| Cold start, 15MB dependencies P99.9 | 160 ms | 1740 ms | 39.0 ms |
| Warm invocation P50 | 0.32 ms | 1.3 ms | 0.13 ms |
| Warm invocation P90 | 1.8 ms | 7.1 ms | 0.7 ms |
| Warm invocation P99 | 4.0 ms | 18.6 ms | 1.6 ms |
| Warm invocation P99.9 | 8.5 ms | 42.0 ms | 3.4 ms |
| Global edge ingress latency P50 | 23 ms | 44 ms via CloudFront | 21 ms |
| Global edge ingress latency P99 | 88 ms | 168 ms via CloudFront | 74 ms |
| Global edge ingress latency P99.9 | 131 ms | 230 ms via CloudFront | 104 ms |
| Memory footprint per idle environment | 6 MB isolate overhead, shared host process | 38 MB microVM base, 128 MB function allocation | 4.5 MB linear memory plus 2.1 MB runtime |
The table separates isolation overhead from edge network overhead. Cloudflare and Fastly show similar global ingress latency because both terminate traffic at dense edge network PoPs. Lambda’s edge numbers include CloudFront ingress because plain Lambda functions are regional. Provisioned concurrency removes most cold starts, but it does not remove CloudFront regional termination or the microVM per-invocation cost.
Fastly’s AOT WebAssembly advantage is most visible at P99.9. It stays below 4 ms for warm invocations. Cloudflare’s P99.9 is roughly 8.5 ms because JIT deoptimization and isolate scheduling occasionally add latency. Lambda’s P99.9 reaches 42 ms in this audit, driven by microVM scheduling, guest kernel activity, and the Lambda Runtime API path.
3. Production Implementation & Configuration Blueprints
Production deployment must match the runtime model to the workload’s tail latency budget. The first blueprint configures Cloudflare Workers smart placement so requests are routed to the nearest PoP with the durable object or data dependency they need. The second blueprint uses AWS Lambda provisioned concurrency to pre-warm a fixed number of microVMs.
PRODUCTION CONFIG // VERIFIED SYNTAX
name = "lumeir-order-api"
main = "src/index.js"
compatibility_date = "2025-03-10"
[placement]\ mode = "smart"
[env.production]\ routes = [\ { pattern = "api.lumeir.online/*", zone_name = "lumeir.online" }\ ]
[env.production.placement]\ mode = "smart"
[observability]\ enabled = true
The Cloudflare configuration keeps smart placement active in production and binds a declared route. Smart placement reduces cross-region requests for stateful workloads by steering traffic toward the PoP where the Durable Object or cached state is resident. It does not change isolate cold start, but it cuts edge ingress and object lookup latency.
PRODUCTION CONFIG // VERIFIED SYNTAX
resource "aws_lambda_function" "orders_api" {
function_name = "orders-api"
role = aws_iam_role.lambda_exec.arn
runtime = "nodejs20.x"
handler = "index.handler"
memory_size = 1024
timeout = 30
}
resource "aws_lambda_provisioned_concurrency_config" "orders_api" {\ function_name = aws_lambda_function.orders_api.function_name\ qualifier = aws_lambda_function.orders_api.version\ provisioned_concurrent_executions = 10\ }
The Terraform block sets a 1024 MB memory allocation and pre-warms ten execution environments. Provisioned concurrency does not make Lambda as fast as isolate or WebAssembly cold starts, but it removes the dominant microVM boot cost from the production path. Ten warm microVMs is a reasonable baseline for a low-volume API. High-volume workloads should autoscale that value against actual invocation traffic.
Primary platform references: Cloudflare Workers Official Documentation and AWS Lambda Official Documentation.
The engineering verdict is straightforward. V8 isolates give the best balance of Node.js-adjacent flexibility and cold start latency. Firecracker microVMs give the strongest isolation but carry a steep cold start tax unless provisioned concurrency is enabled. Wasmtime AOT WebAssembly gives the lowest and most predictable tail latency, but only for code that fits the WebAssembly ecosystem. For global edge workloads with a hard P99 budget and a constrained language surface, Fastly Compute wins. For arbitrary managed runtime code with regulatory isolation requirements, AWS Lambda provisioned concurrency remains the corrective control. Cloudflare Workers occupies the middle: faster than Lambda, more flexible than Fastly, but process-shared by design.
4. 12-Month Total Cost of Ownership (TCO) & Cloud FinOps Audit
For a production B2B SaaS workload processing 50,000,000 requests per month with 200 GB of internet egress and 10,000,000 key-value (KV) lookups, the unit economics diverge sharply by runtime architecture. Cloudflare Workers charges by CPU time inside V8 isolates, not wall-clock time. AWS Lambda charges for wall-clock GB-seconds inside Firecracker microVMs, including time spent waiting on external HTTP calls. Fastly Compute charges by CPU execution time in Wasmtime, and its Lucet lineage means the sandbox has almost no runtime bootstrap overhead. The following model assumes 4 ms of CPU per Workers request, 250 ms of billed wall-clock duration per Lambda invocation at 1024 MB, and 6 ms of CPU per Fastly Compute request. No negotiated discounts, committed-use contracts, free tier credits, or Cloudflare Argo Smart Routing fees are included.
| Cost Category | Cloudflare Workers | AWS Lambda | Fastly Compute |
|---|---|---|---|
| Base Platform Costs | $5.00/mo Workers Paid subscription. No per-region service fee. | $0.00/mo base. No minimum function execution fee. | $0.00/mo base. Pay-as-you-go Compute service level. |
| Compute Duration Charges (GB-seconds) | 50M requests x 4 ms CPU = 200,000,000 CPU ms. Billed at $0.02 per 1M CPU ms: $4.00/mo. At a 128 MB normalized V8 isolate footprint, that equals 25,000 GB-sec of CPU work. | 50M requests x 250 ms x 1 GB = 12,500,000 GB-sec/mo. Billed at $0.0000166667 per GB-sec: $208.33/mo. | 50M requests x 6 ms CPU = 300,000,000 CPU ms. Billed at $0.035 per 1M CPU ms: $10.50/mo. At a 128 MB Wasm linear memory equivalent, that equals 37,500 GB-sec of CPU work. |
| Request Invocation Charges | 10M included; 40M overage at $0.50/M: $20.00/mo. | 50M x $0.20 per 1M: $10.00/mo. | 50M x $0.60 per 1M: $30.00/mo. |
| Egress Bandwidth Fees | $0.00/mo for 200 GB from Workers paid plan. Origin transfer billed separately by origin provider. | 200 GB x $0.09/GB to public internet: $18.00/mo. NAT gateway costs omitted but can add another $0.045/GB inside VPC. | 200 GB x $0.12/GB first 10 TB: $24.00/mo. |
| State Storage/KV Sync Costs | 10M KV reads. 100,000 included, 9,900,000 at $0.50/M: $4.95/mo. Write amplification not included. | DynamoDB on-demand 10M reads, 1 KB average item size, 1 RRU/read, $0.25/M RRU plus 10 GB storage: $3.00/mo. | 10M KV Store reads at $0.50/M: $5.00/mo. Writes and sync propagation not billed separately at this volume. |
| 12-Month Total Cost | (5 + 4 + 20 + 0 + 4.95) x 12 = $407.40 | (0 + 208.33 + 10 + 18 + 3) x 12 = $2,871.96 | (0 + 10.50 + 30 + 24 + 5) x 12 = $834.00 |
📊 [Visual Blueprint: Figure 2: 12-Month Enterprise Total Cost of Ownership (TCO) Breakdown across production deployment tiers.](High-DPI interactive SVG architecture schematics are available in the original dispatch on Lumeir).
The TCO skew is not a rounding artifact. Lambda bills for wall-clock time while a Firecracker microVM waits on a 180 ms third-party OAuth endpoint. Cloudflare Workers and Fastly Compute do not bill for network wait, only CPU execution. That single product decision makes Workers and Compute materially cheaper for I/O-bound edge middleware. Lambda becomes cost-competitive only when the function has high sustained CPU utilization, a long-running background task, or a dependency chain that cannot be expressed as a short-lived handler.
5. Production Failure Modes, Edge-Case Bottlenecks, and Operational Scars
Anycast BGP Route Flapping and Mid-Request Path Changes
Anycast front doors at Cloudflare, Fastly, and AWS CloudFront all face a shared failure mode: a BGP route flap can shift the Internet path for the next packet of an established TCP connection to a different edge location. When that happens, the original edge node still holds the warm V8 isolate, the TLS session state, and any in-memory request context. The new edge node has none of that. The result is a TCP reset or a retried request that starts cold in a different city. This is not a runtime crash. It is a topology failure that no isolate-level retry can fully hide.
Operationally, BGP flapping punishes stateful handlers. Cloudflare Workers that keep per-user state in a global local variable are the most exposed because a rerouted connection receives a fresh isolate. Fastly Compute has the same problem, but its Wasmtime startup is so fast that a cold module may still complete within the original client RTT budget. AWS Lambda behind CloudFront or Global Accelerator is less sensitive at the connection layer because the ENI and microVM live in a regional VPC, but the regional HTTP ingress can still see mid-flight TCP path changes.
Engineers should design for two realities. First, set DNS TTLs low enough for traffic steering, but not so low that clients bypass edge POP decisions. Second, treat every request as stateless. V8 isolate memory and Wasm module memory are not shared across edge locations. Any state that matters must live in a distributed KV store, an origin database, or an idempotent client token.
V8 Isolate CPU Execution Timeouts and Wall-Clock Aborts
Fastly Compute enforces a wall-clock execution budget around 50 ms for legacy service tiers. Cloudflare Workers decouples wall-clock from CPU time, with a paid Worker allowed up to 30 seconds of CPU time but still bound by subrequest and client timeouts. The failure mode is abrupt: the isolate terminates, the response is cut off, and the client receives an HTTP 502 or a hard EOF. No JavaScript finally block runs after a CPU timeout because the V8 isolate is destroyed at the platform boundary.
This is especially dangerous in TypeScript handlers that loop over paginated API calls. A Worker may run fine in local development, then blow a CPU limit in production when a database returns 4,000 rows instead of 40. A Fastly Compute module that parses 900 KB of JSON inside one call may stay under 50 ms in North America but exceed the budget on a saturated POP in Singapore because the CPU scheduler is oversubscribed.
Hardening rules follow. Bound every loop. Use streaming parsing. Cap subrequest fan-out. Move unbounded work to a backend. Profile CPU time with Workers CPU dashboard and Fastly's execution logs. Do not use setTimeout or promise chaining to hide work after respondWith returns. Once the response closes, the budget ends and the isolate may be recycled.
AWS Lambda VPC Elastic Network Interface Cold Attachment Thrashing
Lambda functions attached to a VPC use AWS Hyperplane-managed elastic network interfaces. On a cold start, the Firecracker microVM must attach an ENI, assign a private IP, configure security groups, and install the network namespace before the function handler can bind to a socket. Under steady load this attachment is fast, often 200 ms to 700 ms. Under rapid concurrency spikes, the Lambda placement service can thrash: it tries to create many ENIs at once in a subnet with 8 available IP addresses, then runs a create-delete loop because the subnet cannot satisfy the burst.
The operational signature is ugly. Cold starts go from 400 ms to 8 seconds. The function times out. The client retries because the API gateway saw no response. The retry creates another Lambda instance. The subnet IP pool depletes again. This is a classic feedback loop. It does not happen in Cloudflare Workers because there are no ENIs, no VPC subnets, and no per-invocation microVM. Fastly Compute also avoids it because Wasm modules run in a shared sandbox at the edge.
Fixing Lambda VPC thrashes requires pre-provisioned concurrency, subnets with /24 or larger contiguous blocks, and a Layer 7 proxy outside the VPC to soak up retries. The best architectural correction is to keep Lambda outside the VPC and let the function call private resources through a broker or a private API endpoint. If you must stay inside the VPC, treat ENI capacity as an infrastructure constraint, not a runtime setting.
Distributed State Consistency Limits Across Global Edge Nodes
Cloudflare KV and Fastly KV Store are not strongly consistent. Writes from one edge node propagate asynchronously. A user in Frankfurt writes a session token, then a retry hits Tokyo, where the edge cache still holds the old value. The result is a split-brain from the client's perspective. Cloudflare KV can lag 60 seconds or more in rare cases. Fastly KV has similar anti-entropy propagation with no official single-digit-millisecond global consistency guarantee. AWS Lambda using DynamoDB global tables has its own conflict model: last-writer-wins per item with a region-to-region async replica lag.
The failure mode is not a crash; it is a correctness violation that survives perfectly healthy infrastructure. A B2B SaaS workload with 10M KV lookups per month will eventually hit a read that returns stale data after a write. If the value is an API key, the client sees a 401. If the value is a feature flag, half the production fleet sees the old flag while the other half sees the new one.
Use distributed state only where eventual consistency is acceptable. For session revocation, use origin-backed checks or signed short-lived tokens. For feature flags, serve a monotonically versioned value and accept replication delay. For rate limiting, use local edge counters with periodic central aggregation. Do not try to build a strongly consistent counter across 200 edge nodes without a regional authoritative store.
6. Zero-Downtime Migration & Edge Hardening Runbook
This runbook assumes a production origin already serves the API and a new edge layer will absorb traffic without breaking existing clients. It applies to Cloudflare Workers, Fastly Compute, and Lambda@Edge or Lambda behind a function URL. The sequence is outcome ordered, not narrative ordered. Each step must pass its own observability gate before the next step starts.
- Freeze traffic classification and map every endpoint. Tag requests as read-only, write-through, state-bearing, or long-running. Edge middleware is safe only for read-only and short write-through paths. A state-bearing endpoint with a 30-second session lease is not safe for a 50 ms edge isolation boundary.
- Deploy the edge middleware in shadow mode. Send 1% of production traffic to the new edge handler. Log the edge response but return the origin response to the client. The shadow traffic must not affect origin state. Compare status codes, body hashes, and latency histograms for each route.
- Enable no-op caching and KV reads in the edge handler. For Workers, use a cache API pass-through. For Fastly, use a synthetic response marker. For Lambda, use a X-Region header. Confirm that 10M KV lookups per month do not cause origin pressure or replication lag.
- Shift read-only traffic at 10% increments. Start with GET endpoints that have no session requirement. Ramp to 25%, then 50%, then 100% over 6 hours. At each ramp, watch p75 and p99 for the edge path versus the origin path. A p99 regression bigger than 25% triggers an automatic rollback.
- Configure regional failover separately from traffic shifting. Do not merge edge failover with deployment rollout. Set health probes against the origin with a 5-second interval and a 2-of-3 failure threshold. Cloudflare health checks, Fastly health monitors, and Route 53 health checks must all report through the same control plane.
- Manage cache invalidation cascades with keys and pragmas. Purge by cache tag, not by URL. Tag every response with its resource family. Invalidation becomes a tag mutation, not a URL pattern sweep. Before a deployment, issue a soft purge by setting
Cache-Control: max-age=0, must-revalidateon the changed tag. Keep the hard purge behind a deployment gate to avoid origin stampede. - Configure fallback origin health probes. The edge must not serve stale content forever. Set origin health probes to 200-millisecond timeout and 2 consecutive failures. On failure, serve a stale-if-error only for GET responses and only for 30 seconds. Writes must fail closed with a 503 and a client retry token.
- Run a regional failover rehearsal. Force the edge to route from us-east-1 to eu-central-1 by deleting the regional origin DNS record in a non-production prefix. Verify that edge caches do not mix stale writes, KV reads do not return old values, and the fallback origin health probe triggers within 10 seconds.
- Turn off the old path with a deployment gate. Use a feature flag with 5% rollback window. After 100% edge traffic, keep the origin warm for 72 hours. Watch for Anycast BGP flapping and origin retries. At hour 72, you may decommission origin capacity only if the edge error budget has not been consumed.
The runbook order matters. Cache invalidation before health probes causes origin stampede. Health probes before failover rehearsal creates false confidence. Shadow mode before traffic shifting is non-negotiable. A zero-downtime migration is not a single event; it is a sequence of reversible state transitions.
7. Final Architectural Verdict & Decision Matrix
Cloudflare Workers wins when the workload is a JavaScript or TypeScript API proxy, a global SSR renderer, or a latency-sensitive middleware layer that must run in every edge POP with near-zero cold starts. The V8 isolate model gives short cold starts on reused isolates, no VPC ENI attachment, no egress charge from the Workers layer, and the lowest cost for I/O-bound traffic in this benchmark. The 12-month TCO of $407.40 for 50M requests per month is an order of magnitude cheaper than Lambda. That cost advantage is real because Workers does not bill for wall-clock time spent waiting on origins.
AWS Lambda wins when the function must run longer than an edge isolate, needs Docker dependencies or GPU-adjacent compute, or must access private VPC resources directly. Firecracker microVMs provide stronger isolation than a V8 isolate because each invocation can run a full Linux environment. Lambda also supports 15-minute execution time, local writable disk, layered packages, and runtime choices beyond JavaScript. The tradeoff is cost and cold-start latency. At 250 ms wall-clock per invocation, Lambda spends 12.5M GB-seconds per month waiting. That cost is acceptable for compute-heavy or complex dependency workloads, but it is wasteful for a simple edge proxy.
Fastly Compute wins when the workload is compiled WebAssembly, requires raw microsecond-level packet manipulation, or must run at the edge in Wasmtime with deterministic resource bounds. Fastly's Lucet lineage gives near-native startup and tight CPU accounting. It is not the right choice for teams that need a broad Node.js package ecosystem. Wasm module compilation, linear memory, and a smaller state ecosystem make Fastly Compute a specialized instrument. If your team already writes Rust or AssemblyScript for edge logic, Fastly Compute is the cleanest raw compute target. If your team writes generic TypeScript sessions and JSON parsing, Cloudflare Workers is a lower-friction platform.
| Architectural Signal | Cloudflare Workers | AWS Lambda | Fastly Compute |
|---|---|---|---|
| Latency-critical API proxy | First choice. V8 isolate reuse, no egress charge, low request cost. | Acceptable only with provisioned concurrency and fat subnets. | First choice if compiled to Wasm. |
| Global SSR and HTML edge rendering | Strongest option for TypeScript and V8 performance. | Workable but slow p99 without SnapStart or concurrency tuning. | Workable for Rust, Go, or AssemblyScript frontends. |
| Long-running compute or Docker dependencies | Unsupported. 30s CPU cap and no Docker runtime. | Best option by far. Firecracker plus 15-minute runtime. | Unsupported for arbitrary Docker. |
| VPC private resource access | Indirect through Cloudflare Tunnel or Worker secrets. | Native ENI attachment, but ENI cold thrashes hurt. | Indirect through backend origins or private forwards. |
| Extreme microsecond packet manipulation | Limited by V8 garbage collection and JS runtime. | Weak. Firecracker microVM and network namespace add latency. | Best option. Wasmtime and Lucet close to native. |
| Cost for I/O-bound 50M requests/month | Best at $407.40/year in this model. | Worst at $2,871.96/year. | Middle at $834.00/year. |
For a CTO or Staff Engineer deciding today: choose Cloudflare Workers for JavaScript and TypeScript edge middleware, choose AWS Lambda for long-running regional workloads that need a real Linux environment, and choose Fastly Compute for Wasm or Rust-based edge execution where CPU determinism is worth the smaller ecosystem. Do not select AWS Lambda for a simple API proxy if cost and p99 latency are your primary objectives. Do not select Cloudflare Workers if your handlers need 10 minutes of CPU or native binaries. Do not select Fastly Compute if your team expects Node.js compatibility or a large stateful framework.
The final verdict is not about one platform being better. It is about matching runtime isolation and billing granularity to the request shape. Edge workloads with tiny CPU and large I/O wait belong on V8 isolates or Wasm. Regional workloads with real compute belong on Firecracker. The TCO math only closes when the runtime model matches the execution profile.
Examine more enterprise benchmarks, kernel runtime audits, and FinOps models at Lumeir.
Comments
Join the discussionNo comments yet. Be the first to comment.

