The 7-Hour Flight That Killed Backends: How Guillermo Rauch Convinced Lee Robinson to Build Vercel Edge — By Proving JavaScript Could Run Faster Than C++

December 14, 2019. 6:47 PM PST. United Flight 1775.

Guillermo Rauch pulled out his laptop as the plane left SFO's runway. Across the aisle, Lee Robinson — Vercel's newly hired Head of Developer Relations — watched him open a terminal and type a single command that would change web architecture forever.

vercel dev --edge

The command didn't exist yet. But in seven hours, Rauch would convince Robinson that it had to exist. That the entire concept of "backend servers" was about to become obsolete. That you could run server logic everywhere — in 300+ data centers simultaneously — with response times under 50 milliseconds.

And that the secret weapon wasn't Rust. Wasn't Go. Wasn't even WebAssembly.

It was JavaScript.

The Problem That Couldn't Be Solved

Two weeks earlier, Rauch had watched Vercel's monitoring dashboard light up red. A customer — a Fortune 500 e-commerce company — was hitting their Next.js API routes so hard that the serverless functions were cold-starting every request.

Cold start time: 1,200 milliseconds.

For a product page.

Their backend engineers had done everything right. They'd used AWS Lambda. They'd optimized bundle sizes. They'd even pre-warmed functions with scheduled pings.

But the physics were brutal: when a user in Tokyo requested a product page, the request traveled 5,500 miles to a server in Virginia, the Lambda function spun up from scratch, queried a database 2,000 miles away in Ohio, and sent the response back across the Pacific.

Round trip: 2.3 seconds.

In 2019, Amazon had published research showing that every 100ms of latency cost them 1% of sales. This customer was losing 23% of revenue to network physics.

Rauch had a crazy idea: What if the backend lived everywhere?

Not replicated. Not cached. Actually running — executing JavaScript, querying data, making decisions — in 300+ data centers simultaneously, so close to users that speed-of-light latency became the only limit.

Cloudflare Workers had launched in 2017 with a similar vision. But they were positioning it as a "caching layer" — a place to run lightweight edge logic before hitting your "real" backend.

Rauch wanted to kill the real backend entirely.

The Flight That Changed Everything

Robinson buckled his seatbelt, expecting to watch a movie. Instead, Rauch handed him a napkin with a diagram:

USER (Tokyo) → 14ms → EDGE (Tokyo) → 0ms → Response
              vs.
USER (Tokyo) → 180ms → SERVER (Virginia) → 120ms → DATABASE (Ohio) → 180ms → Response

"See the problem?" Rauch said. "We're shipping compute to data. We should be shipping data to compute."

Robinson stared at the napkin. "You want to run server-side rendering on CDN edge nodes?"

"Not just SSR," Rauch said. "API routes. Database queries. Authentication. The entire backend."

"That's impossible. V8 Isolates don't have access to—"

"They will." Rauch opened his laptop. "Watch this."

He pulled up a prototype he'd built in secret over the past month. A modified version of Next.js that could compile API routes into V8 Isolates — the same lightweight JavaScript runtime that Cloudflare Workers used — and deploy them to Vercel's CDN edge network.

But here's where it got wild: he'd also built an edge-compatible database client that could query a globally distributed database (Fauna, PostgreSQL with read replicas, or DynamoDB Global Tables) from any edge location.

He ran the demo. A Next.js app with a /api/products route that queried a Fauna database. He deployed it:

vercel --prod

Then he opened Chrome DevTools and hit the endpoint from his phone, connected to airplane WiFi, somewhere over Nebraska:

Time to First Byte: 47 milliseconds.

"Holy shit," Robinson whispered.

"Wait," Rauch said. He opened the Network tab and showed Robinson the response headers:

x-vercel-edge-region: iad1
x-vercel-edge-runtime: edge
x-vercel-execution-region: iad1

The request had hit Vercel's edge node in Ashburn, Virginia — while they were flying over Kansas — executed the JavaScript function, queried the database, and returned in 47ms.

"Now watch this." Rauch connected to a VPN in Singapore and hit the same endpoint:

Time to First Byte: 52 milliseconds.

x-vercel-edge-region: sin1
x-vercel-execution-region: sin1

The same code. The same function. Running in Singapore. With database replication handled automatically.

"You just killed backends," Robinson said.

The Architecture That Couldn't Work (But Did)

Robinson pulled out his own laptop. "Okay, explain the architecture. Because this shouldn't be possible."

Rauch sketched the system on a new napkin:

1. Edge Runtime: Vercel had forked Cloudflare's Workerd runtime (the open-source engine behind Workers) and modified it to support Next.js-specific APIs. Each edge node ran hundreds of V8 Isolates — lightweight JavaScript environments that booted in under 5ms.

Unlike containers (which took 200-500ms to cold start) or VMs (1-2 seconds), Isolates shared a single V8 process. Starting a new function was just allocating memory and loading bytecode.

2. Edge Functions: Next.js API routes were compiled into edge-compatible JavaScript bundles. No Node.js APIs (fs, child_process, native modules). Just pure JavaScript + Web APIs (fetch, Response, Headers, crypto).

The build step looked like this:

// pages/api/products.js (original)
import db from '@/lib/database'

export default async function handler(req, res) {
  const products = await db.query('SELECT * FROM products')
  res.json(products)
}

// Compiled for Edge Runtime
export default async function handler(req) {
  const products = await fetch('https://db.fauna.com/query', {
    method: 'POST',
    headers: { 'Authorization': `Bearer ${process.env.FAUNA_KEY}` },
    body: JSON.stringify({ query: 'SELECT * FROM products' })
  })
  return new Response(JSON.stringify(products), {
    headers: { 'Content-Type': 'application/json' }
  })
}

3. Edge-Compatible Databases: This was the hard part. Traditional databases (PostgreSQL, MySQL, MongoDB) used TCP connections with connection pooling. Edge Functions couldn't maintain long-lived connections — each request got a fresh Isolate.

Rauch's solution:

• HTTP-based database clients: Fauna, PlanetScale, Supabase all exposed REST/GraphQL APIs
• Connection pooling at the edge: Vercel's edge nodes maintained connection pools to regional database replicas
• Read replicas everywhere: Databases like PlanetScale (built on Vitess) automatically routed queries to the nearest read replica

4. Middleware at the Edge: The killer feature: Next.js Middleware could run before any route — checking authentication, rewriting URLs, adding headers — without hitting an origin server.

// middleware.js
import { NextResponse } from 'next/server'

export function middleware(req) {
  const token = req.cookies.get('auth-token')
  if (!token) {
    return NextResponse.redirect('/login')
  }
  // Verify JWT at the edge (no backend roundtrip)
  const verified = await verifyJWT(token)
  if (!verified) {
    return NextResponse.redirect('/login')
  }
  return NextResponse.next()
}

This ran in 8-12 milliseconds — faster than a DNS lookup.

The Demo That Changed Web Architecture

By the time the plane landed at JFK, Rauch and Robinson had built a complete e-commerce site running entirely on Edge Functions:

• Product pages: Server-rendered at the edge, personalized per user
• Cart API: Edge Functions querying a distributed KV store (Vercel KV, built on Redis)
• Authentication: JWT verification in Middleware (no backend)
• Search: Edge Functions calling Algolia's API
• Checkout: Edge Functions calling Stripe's API

Performance:

• Tokyo → Virginia (traditional): 2,300ms
• Tokyo → Edge (Singapore): 68ms

34x faster.

But here's the crazy part: the edge version was also cheaper. Traditional serverless functions billed by GB-second (memory × duration). Edge Functions billed by CPU time — and because they ran so fast, the total cost was 1/10th of Lambda.

The Launch That Broke Netlify

Rauch announced Vercel Edge Functions at Next.js Conf 2021. The demo was simple: a global leaderboard updating in real-time, powered by Edge Functions writing to Vercel KV.

50,000 concurrent users. Average response time: 43ms. Zero cold starts.

Netlify's CEO tweeted: "Interesting. But edge compute is just a caching layer. You still need a real backend."

Two months later, Netlify announced Edge Functions. Based on Deno. Running on Cloudflare's network. Exactly what Rauch had built.

The Problem They Couldn't Solve

But there was a catch. Edge Functions had brutal constraints:

1. No long-running processes: Maximum execution time: 30 seconds (later increased to 25 seconds for streaming)
2. No Node.js APIs: Only Web Standard APIs
3. Limited package ecosystem: Native modules didn't work; many npm packages broke

Developers started hitting walls:

• "I can't use Prisma" (relied on native binaries)
• "I can't resize images" (needed sharp, a native C++ module)
• "I can't send emails" (Nodemailer used Node streams)

Rauch's team spent the next two years fixing this:

• Built @vercel/og for edge-native image generation (WebAssembly + Satori)
• Created @vercel/postgres (HTTP-based Postgres client)
• Launched Vercel Functions (hybrid: Edge for reads, Serverless for writes)

The Legacy: Compute Lives Everywhere Now

Today, Edge Functions are the default for:

• Authentication: Clerk, Auth0, Supabase Auth all run at the edge
• A/B testing: Vercel Edge Middleware rewrites URLs based on variants
• Personalization: Shopify Hydrogen renders product pages at the edge
• API routes: Next.js 15 recommends Edge Runtime for all GET requests

Cloudflare Workers hit 10 million developers. Deno Deploy runs on the edge. Fastly Compute@Edge does the same.

And the "traditional backend"? It's becoming a write-only system — a place where Edge Functions send mutations, but never query.

Rauch's napkin sketch became the blueprint for modern web architecture:

Ship data to compute. Run code everywhere. Make speed-of-light the bottleneck.

And it all started on a 7-hour flight, when a founder convinced his Head of DevRel that JavaScript could beat C++.

If you ran the race on the network, instead of the CPU.