Leveraging Edge Computing with Claude Code

What Is Edge Computing?

Edge computing runs code on servers geographically close to users. It dramatically reduces latency and delivers fast responses. Let’s use Claude Code to build edge-ready applications.

Cloudflare Workers

// src/index.ts
export default {
  async fetch(
    request: Request,
    env: Env,
    ctx: ExecutionContext
  ): Promise<Response> {
    const url = new URL(request.url);

    // Routing
    switch (url.pathname) {
      case "/api/geo":
        return handleGeo(request);
      case "/api/cache":
        return handleCachedData(request, env, ctx);
      default:
        return new Response("Not Found", { status: 404 });
    }
  },
};

function handleGeo(request: Request): Response {
  // Headers automatically added by Cloudflare
  const country = request.headers.get("cf-ipcountry") || "unknown";
  const city = request.cf?.city || "unknown";

  return Response.json({
    country,
    city,
    message: `Hello! You're accessing from ${city}.`,
  });
}

async function handleCachedData(
  request: Request,
  env: Env,
  ctx: ExecutionContext
): Promise<Response> {
  const cacheKey = new URL(request.url).pathname;

  // Get cached data from KV store
  const cached = await env.MY_KV.get(cacheKey);
  if (cached) {
    return Response.json(JSON.parse(cached), {
      headers: { "X-Cache": "HIT" },
    });
  }

  // Fetch from origin
  const data = await fetch("https://api.example.com/data").then(
    (r) => r.json()
  );

  // Cache in KV (TTL: 5 minutes)
  ctx.waitUntil(
    env.MY_KV.put(cacheKey, JSON.stringify(data), {
      expirationTtl: 300,
    })
  );

  return Response.json(data, {
    headers: { "X-Cache": "MISS" },
  });
}

Vercel Edge Functions

// app/api/personalize/route.ts
import { NextRequest } from "next/server";

export const runtime = "edge";

export async function GET(request: NextRequest) {
  const country = request.geo?.country || "US";
  const region = request.geo?.region || "unknown";

  // Region-specific content
  const content = await getLocalizedContent(country);

  // Edge cache configuration
  return Response.json(
    {
      content,
      servedFrom: region,
      timestamp: Date.now(),
    },
    {
      headers: {
        "Cache-Control": "public, s-maxage=60, stale-while-revalidate=300",
      },
    }
  );
}

async function getLocalizedContent(country: string) {
  const priceMultiplier: Record<string, number> = {
    US: 1,
    JP: 150,
    EU: 0.9,
  };

  return {
    currency: country === "JP" ? "JPY" : country === "US" ? "USD" : "EUR",
    multiplier: priceMultiplier[country] || 1,
  };
}

Edge Authentication

// middleware.ts (Vercel Edge Middleware)
import { NextRequest, NextResponse } from "next/server";
import { jwtVerify } from "jose";

const secret = new TextEncoder().encode(process.env.JWT_SECRET!);

export async function middleware(request: NextRequest) {
  // Skip public paths
  const publicPaths = ["/", "/login", "/api/auth"];
  if (publicPaths.some((p) => request.nextUrl.pathname.startsWith(p))) {
    return NextResponse.next();
  }

  const token = request.cookies.get("token")?.value;
  if (!token) {
    return NextResponse.redirect(new URL("/login", request.url));
  }

  try {
    const { payload } = await jwtVerify(token, secret);

    // Pass user info as headers
    const response = NextResponse.next();
    response.headers.set("x-user-id", payload.sub as string);
    response.headers.set("x-user-role", payload.role as string);
    return response;
  } catch {
    return NextResponse.redirect(new URL("/login", request.url));
  }
}

export const config = {
  matcher: ["/dashboard/:path*", "/api/protected/:path*"],
};

A/B Testing at the Edge

export const runtime = "edge";

export async function middleware(request: NextRequest) {
  // Check the existing variant assignment
  const variant = request.cookies.get("ab-variant")?.value;

  if (!variant) {
    // Randomly assign to new users
    const newVariant = Math.random() < 0.5 ? "A" : "B";
    const response = NextResponse.next();
    response.cookies.set("ab-variant", newVariant, {
      maxAge: 60 * 60 * 24 * 30,
    });

    // Rewrite to the variant page
    if (newVariant === "B") {
      return NextResponse.rewrite(
        new URL("/variants/b" + request.nextUrl.pathname, request.url)
      );
    }
    return response;
  }

  if (variant === "B") {
    return NextResponse.rewrite(
      new URL("/variants/b" + request.nextUrl.pathname, request.url)
    );
  }

  return NextResponse.next();
}

Using It With Claude Code

An example prompt for asking Claude Code to implement edge functions. For performance optimization, see the SSR vs SSG comparison, and for caching strategies, see Redis caching design.

Build an API with Vercel Edge Functions.
- Region-based content variation
- JWT verification at the edge
- Caching in a KV store
- A/B testing middleware

For more on Cloudflare Workers, see the official Cloudflare Workers documentation. For Claude Code usage, check the official documentation.

Summary

Edge computing delivers both low latency and scalability. With Claude Code, you can efficiently write edge-ready code with an understanding of each platform’s APIs and best practices.