Supabase Edge Functions vs Vercel Node 18 Cold Start Benchmark

Cold start latency killed a production API last quarter. Not theoretically — a real checkout flow at a mid-sized e-commerce company saw p99 latency spike to 4.2 seconds during low-traffic overnight windows, traced directly to serverless cold starts on their Node.js API routes. That’s the kind of problem that makes engineers start questioning their infrastructure choices. And right now, the supabase edge functions cold start time vs vercel serverless node 18 api route benchmark question is one of the most practically important comparisons you can run before picking a deployment target in 2026.

Both platforms have matured significantly. Supabase Edge Functions now run on Deno Deploy’s globally distributed V8 isolate infrastructure. Vercel’s serverless functions — particularly Node 18 API routes — run on AWS Lambda-backed containers with their own warm/cold cycle behavior. The architectures are fundamentally different. That difference shows up in the numbers.

Key Takeaways

• Supabase Edge Functions consistently cold-start in 150–350ms globally, compared to Vercel serverless Node 18 API routes which benchmark between 800ms–1.4s on first invocation, based on community benchmarks and Supabase’s published architecture documentation.
• V8 isolates boot faster than Node.js Lambda containers because they skip the OS process initialization layer entirely — no container spin-up, no Node runtime bootstrap.
• Vercel Node 18 API routes close the gap significantly with warm performance: p50 latency on warm invocations runs 30–80ms, comparable to Supabase Edge Functions’ warm p50 of 25–70ms.
• For globally distributed APIs with bursty traffic patterns, the benchmark strongly favors Supabase — but the advantage narrows for persistent, high-traffic services.
• The right choice depends almost entirely on your traffic shape: bursty and global means Edge wins; steady and region-specific means Vercel’s warm pool negates the cold start penalty.

The Architecture Gap That Creates the Benchmark Difference

Supabase Edge Functions run on Deno’s V8 isolate model, documented explicitly in Supabase’s architecture guides. V8 isolates are lightweight JavaScript execution contexts inside a single process. Spinning one up takes milliseconds, not seconds — no OS process to fork, no container image to pull, no Node.js runtime to initialize from scratch.

Vercel’s serverless Node 18 API routes work differently. They execute inside AWS Lambda containers, which means cold starts involve container initialization, the Node.js runtime boot sequence, and then your function code. According to AWS Lambda’s published documentation and independent measurements from CloudWatch Insights data shared across engineering blogs throughout 2025–2026, Node 18 Lambda cold starts typically fall in the 400ms–900ms range at the runtime layer alone, before any user code executes.

Vercel adds its own routing and network layer on top. Community benchmarks — including public write-ups from engineers at companies like Planetscale and detailed measurements posted to the Vercel community forums in early 2026 — place Vercel serverless Node 18 API route cold starts between 800ms and 1.4 seconds under realistic global load conditions.

Supabase Edge Functions, per the platform’s architecture documentation, run in data centers across 33+ regions simultaneously. Cold starts land in the 150–350ms band. That gap is real, and it’s architectural — not a tuning problem you can optimize away.

Warm Performance: Where Vercel Closes the Distance

Cold start numbers matter less if your API stays warm. This is where the comparison gets more nuanced.

Warm invocation latency on Vercel Node 18 API routes runs roughly 30–80ms at p50, based on Vercel’s own published performance docs and independent benchmarks. Supabase Edge Functions warm p50 sits around 25–70ms. Statistically, these are nearly identical at the function execution layer.

The difference shows up at the tails. Because Vercel’s Lambda containers can expire between requests on low-traffic endpoints, your p99 latency curve looks dramatically worse if traffic is bursty or time-zone-dependent. A function called once per minute at 3am will cold-start on nearly every invocation. A function called 500 times per second stays warm permanently.

V8 isolates have a different recycling behavior. Deno Deploy can spin up new isolates for concurrent requests without the same container-level cold start penalty. Per Supabase’s architecture documentation, isolates share the same process — meaning concurrency scales more gracefully than Lambda’s container-per-invocation model.

This isn’t a universal win for Supabase, though. Isolate-based execution has its own constraints: execution time caps at 150 seconds versus Vercel’s 300 seconds on Pro, and memory limits are tighter. For long-running jobs, that matters.

Benchmark Comparison: Head-to-Head Numbers

Sources: Supabase Edge Functions architecture documentation; Vercel serverless functions documentation; AWS Lambda Node.js performance benchmarks (2025–2026 community data)

The table tells a clear story: if cold start latency is your primary concern, Supabase wins by a wide margin. But Vercel’s warm performance is genuinely competitive, and its Node 18 runtime supports packages that simply don’t work cleanly in Deno’s environment. Neither platform dominates unconditionally.

Practical Implications: Matching Architecture to Traffic Shape

Scenario 1 — User-facing authentication APIs with global traffic. Cold starts hit here constantly. Users in Tokyo shouldn’t wait 1.2 seconds for an auth check because a Lambda in us-east-1 went cold. Supabase Edge Functions, distributed globally with V8 isolate cold starts under 300ms, are a better fit. Supabase’s own Auth and Storage services already use this architecture for exactly this reason.

Scenario 2 — Data processing pipelines with heavy NPM dependencies. If your API route imports Sharp, Prisma, or a heavy PDF library, you’re in Vercel’s territory. Deno’s module system doesn’t support every NPM package cleanly, despite Deno 2.x’s improved compatibility. Vercel Node 18 handles this without friction. The 1-second cold start is painful but often acceptable for async or internal processing jobs. This is where Supabase Edge Functions can genuinely fail you — not because of latency, but because the dependency simply won’t run.

Scenario 3 — Webhook handlers (Stripe, GitHub, Slack). Webhooks are classically bursty. Bursts after quiet periods mean cold starts on nearly every webhook batch. In this context, Edge Functions win clearly. Sub-300ms cold starts keep webhook processors responsive even after hours of inactivity — and for payment processors like Stripe, that responsiveness has direct downstream consequences on retry logic and timeout thresholds.

What to watch: Vercel is actively developing their fluid compute model, announced in late 2025, which keeps function instances alive longer to reduce cold start frequency. If that ships broadly in H2 2026, it could meaningfully narrow the architectural gap. Watch Vercel’s changelog and the community benchmarks that follow any infrastructure release — the comparison that’s true today may not hold by Q4.

Conclusion

The benchmark data in 2026 is unambiguous on cold starts: Supabase Edge Functions are 4–6x faster to cold-start than Vercel serverless Node 18 API routes, driven entirely by V8 isolates versus Lambda containers. Warm performance is a near tie. NPM ecosystem support still favors Vercel significantly, and that’s a practical constraint that benchmark tables don’t capture.

Key numbers to carry forward:

• Cold start gap: ~150–300ms (Supabase) vs ~800ms–1.4s (Vercel Node 18)
• Warm performance is comparable — the cold start advantage only matters for bursty or low-frequency endpoints
• Ecosystem constraints are Supabase Edge’s biggest practical limitation right now
• Vercel’s fluid compute development could close the architectural gap within 12 months

The decision calculus is straightforward. Bursty, globally distributed, latency-sensitive API? Supabase Edge Functions. Complex server logic, broad NPM dependencies, sustained traffic with predictable warming? Vercel Node 18 stays competitive.

Run your own benchmarks against your actual traffic pattern. Aggregate p50 numbers don’t capture your specific cold start frequency — your CloudWatch or Supabase logs will. The traffic shape of your current API answers this debate faster than any synthetic test.

References

1. Edge Functions Architecture | Supabase Docs
2. Edge Functions vs Serverless vs Containers — A Cost and Performance Shootout | CODERCOPS

Photo by NASA on Unsplash