The evolution of the backend has moved from physical on-premise servers (bare metal) to virtual machines (EC2), to containerized microservices (Docker/K8s), to Serverless (AWS Lambda). The final evolution of this chain is "Edge Computing". In this masterclass, we will teach you how to deploy logic directly into Content Delivery Network (CDN) nodes spread across hundreds of cities globally, reducing your API latency to near zero.

Module 1: The Cold Start Problem & V8 Isolates

Traditional Serverless functions (like AWS Lambda) run inside Docker containers. When a request comes in, AWS must allocate a server, start the Docker container, load the Node.js runtime, and run your code. This process can take 500ms to 2 seconds. This is the infamous 'Cold Start'.

Edge platforms (like Cloudflare Workers or Vercel Edge) solve this by abandoning containers. Instead, they use V8 Isolates. An isolate is a lightweight sandbox created by the Chrome V8 JavaScript engine. They spin up in under 5 milliseconds.

Trade-offs of Edge Environments

  • Pros: Zero cold starts (<5ms), global distribution by default, incredibly cheap (pennies per million requests).
  • Cons: No Node.js standard library. You cannot use fs (file system), child_process, or net. You must use standard Web APIs like fetch, crypto, and Streams.
  • Cons: Strict execution limits. A standard Cloudflare Worker is killed if it uses more than 50ms of CPU time.

Module 2: Scaffolding a Cloudflare Worker

We will use Cloudflare Workers via their CLI, Wrangler. You write code in TypeScript, and Wrangler compiles it down to a single V8-compatible bundle.

Terminalbash
npm install -g wrangler

# Scaffold a new project
wrangler init global-edge-api
cd global-edge-api

# Start a local development server that perfectly mimics the Edge environment
npm run start

Module 3: Writing an Edge API Router

Edge functions trigger on a fetch event. You intercept the request and return a standard Response object.

src/index.tstypescript
export interface Env {
  // Environment variables are strongly typed
  API_SECRET: string;
}

export default {
  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
    const url = new URL(request.url);
    
    // 1. Handle CORS preflight requests
    if (request.method === 'OPTIONS') {
      return new Response(null, {
        headers: {
          'Access-Control-Allow-Origin': '*',
          'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
        }
      });
    }

    // 2. Health Check Route
    if (url.pathname === '/api/health') {
      // request.cf contains Cloudflare-specific data about the user
      const region = request.cf?.colo || 'UNKNOWN';
      
      return new Response(JSON.stringify({ status: "OK", region }), {
        headers: { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' },
      });
    }

    // 3. Authenticated Route
    if (url.pathname.startsWith('/api/secure')) {
      const authHeader = request.headers.get('Authorization');
      if (!authHeader || authHeader !== `Bearer ${env.API_SECRET}`) {
        return new Response('Unauthorized', { status: 401 });
      }
      return new Response('Super secret data inside!');
    }
    
    return new Response('Not Found', { status: 404 });
  },
};

Module 4: Managing Distributed State

Running code globally is easy. Storing data globally is insanely hard. If a user in Tokyo modifies data, and a user in New York requests it 10 milliseconds later, what happens? This is dictated by the CAP Theorem.

Edge Storage Architectures

  • Edge KV (Key-Value): An eventually consistent cache. Read speeds are <10ms globally, but it takes ~60 seconds for a write in Tokyo to propagate to New York. Perfect for configurations, session tokens, or cached HTML.
  • Durable Objects: Strongly consistent, single-region instances. If you build a Chat Room, all users connect to the exact same Durable Object (e.g., in Frankfurt), ensuring message order is preserved.
  • D1 / Distributed SQL: SQLite databases replicated globally. Reads are local (fast), but writes are forwarded to a primary database before replicating out.

Module 5: Implementing Edge Caching (Stale-While-Revalidate)

Let's use Edge KV to cache a slow backend database. We will use the ctx.waitUntil method. This allows the worker to return a fast response to the user immediately, while keeping the V8 Isolate alive for a few more milliseconds to do background tasks (like updating the cache).

src/index.ts (KV Example)typescript
export default {
  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
    const url = new URL(request.url);
    const cacheKey = `user_data_${url.searchParams.get('id')}`;

    // 1. Check the Edge KV Cache
    const cachedData = await env.USER_DATA_KV.get(cacheKey);
    if (cachedData) {
      // Serve instantly from Tokyo if user is in Tokyo
      return new Response(cachedData, { 
        headers: { 'Content-Type': 'application/json', 'X-Cache': 'HIT' } 
      });
    }

    // 2. Cache Miss: Fetch from the slow central database in US-East
    const originResponse = await fetch(`https://slow-db.com/api/user/${url.searchParams.get('id')}`);
    const data = await originResponse.text();

    // 3. Store the result in KV for future requests.
    // ctx.waitUntil ensures this Promise finishes even AFTER the response is sent to the user.
    ctx.waitUntil(env.USER_DATA_KV.put(cacheKey, data, { expirationTtl: 3600 }));

    return new Response(data, { 
      headers: { 'Content-Type': 'application/json', 'X-Cache': 'MISS' } 
    });
  }
};

Module 6: Deployment & CI/CD Integration

To push this API to hundreds of data centers worldwide, we use a GitHub Action. The deployment takes less than 5 seconds.

.github/workflows/deploy.ymlyaml
name: Deploy Global API

on:
  push:
    branches: [ main ]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Deploy to Cloudflare
        uses: cloudflare/wrangler-action@2.0.0
        with:
          apiToken: ${{ secrets.CF_API_TOKEN }}
          command: deploy