Edge Computing: Cloudflare Workers, Deno Deploy, and When to Use Edge Functions

Edge computing moves computation from centralized servers to locations physically close to users. A user in Singapore hitting an edge function gets a response from a nearby datacenter in < 20ms, rather than a round trip to a US East data center at 200ms.

The edge runtime is constrained — no Node.js APIs, limited execution time, no filesystem — but for the right use cases, it eliminates latency that no amount of backend optimization can match.

---

Edge vs Serverless vs Traditional Server

---

Cloudflare Workers

Workers run JavaScript/TypeScript on V8 isolates at 300+ Cloudflare edge locations. They start in microseconds because they use V8 isolates (like browser tabs) rather than OS processes.

Basic Worker:

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

    // Route based on pathname
    if (url.pathname.startsWith('/api/')) {
      return handleAPI(request, env);
    }

    // Serve static content from R2
    if (url.pathname.startsWith('/assets/')) {
      return serveAsset(url.pathname, env);
    }

    return new Response('Not Found', { status: 404 });
  },
};

async function handleAPI(request: Request, env: Env): Promise<Response> {
  const authHeader = request.headers.get('Authorization');
  if (!authHeader?.startsWith('Bearer ')) {
    return new Response(JSON.stringify({ error: 'Unauthorized' }), {
      status: 401,
      headers: { 'Content-Type': 'application/json' },
    });
  }

  // Verify JWT using Web Crypto API (available in Workers)
  const token = authHeader.slice(7);
  const isValid = await verifyJWT(token, env.JWT_SECRET);
  if (!isValid) {
    return new Response(JSON.stringify({ error: 'Invalid token' }), {
      status: 401,
      headers: { 'Content-Type': 'application/json' },
    });
  }

  // Forward to origin with verified user context
  const origin = new URL(request.url);
  origin.hostname = env.ORIGIN_HOSTNAME;
  return fetch(new Request(origin.toString(), request));
}

async function verifyJWT(token: string, secret: string): Promise<boolean> {
  try {
    const [headerB64, payloadB64, sigB64] = token.split('.');
    const key = await crypto.subtle.importKey(
      'raw',
      new TextEncoder().encode(secret),
      { name: 'HMAC', hash: 'SHA-256' },
      false,
      ['verify'],
    );
    const data = new TextEncoder().encode(`${headerB64}.${payloadB64}`);
    const sig = Uint8Array.from(atob(sigB64.replace(/-/g, '+').replace(/_/g, '/')), c => c.charCodeAt(0));
    const valid = await crypto.subtle.verify('HMAC', key, sig, data);
    if (!valid) return false;
    const payload = JSON.parse(atob(payloadB64));
    return payload.exp > Date.now() / 1000;
  } catch {
    return false;
  }
}

wrangler.toml — Worker config:

name = "api-gateway"
main = "src/index.ts"
compatibility_date = "2026-01-01"
compatibility_flags = ["nodejs_compat"]

[vars]
ORIGIN_HOSTNAME = "api.yourproduct.com"

[[kv_namespaces]]
binding = "CACHE"
id = "your-kv-namespace-id"

[[r2_buckets]]
binding = "ASSETS"
bucket_name = "your-assets-bucket"

[triggers]
crons = ["0 * * * *"]  # Hourly cron job

Cloudflare KV for edge caching:

// Cache API responses at the edge for 60 seconds
async function withEdgeCache(
  request: Request,
  env: Env,
  handler: (req: Request) => Promise<Response>,
): Promise<Response> {
  const cacheKey = request.url;
  const cached = await env.CACHE.get(cacheKey, 'arrayBuffer');

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

  const response = await handler(request);
  const body = await response.arrayBuffer();

  // Store in KV with 60-second TTL
  await env.CACHE.put(cacheKey, body, { expirationTtl: 60 });

  return new Response(body, {
    headers: { ...Object.fromEntries(response.headers), 'X-Cache': 'MISS' },
  });
}

---

A/B Testing at the Edge

Edge functions are ideal for A/B testing because the variant can be assigned before the page loads — no flicker, no client-side delay:

// A/B test assignment at the edge — no layout shift
export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const url = new URL(request.url);

    // Only run A/B test on the pricing page
    if (url.pathname !== '/pricing') {
      return fetch(request);
    }

    // Get or create stable variant assignment from cookie
    const cookies = parseCookies(request.headers.get('Cookie') ?? '');
    let variant = cookies['ab_pricing'];

    if (!variant) {
      // Assign deterministically based on a random ID
      variant = Math.random() < 0.5 ? 'control' : 'treatment';
    }

    // Rewrite URL to serve the correct variant
    const variantUrl = new URL(request.url);
    variantUrl.pathname = variant === 'treatment'
      ? '/pricing-v2'     // Treatment: new pricing page
      : '/pricing';       // Control: original

    const response = await fetch(new Request(variantUrl.toString(), request));

    // Set cookie for stable assignment across requests
    const newResponse = new Response(response.body, response);
    if (!cookies['ab_pricing']) {
      newResponse.headers.append(
        'Set-Cookie',
        `ab_pricing=${variant}; Path=/; Max-Age=2592000; SameSite=Lax`,
      );
    }

    return newResponse;
  },
};

---

Geolocation and Personalization

Workers receive Cloudflare's geolocation data on every request:

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const { country, city, timezone } = request.cf ?? {};

    // Redirect European users to EU-region API
    if (['DE', 'FR', 'GB', 'NL', 'PL', 'ES', 'IT'].includes(country ?? '')) {
      const euUrl = new URL(request.url);
      euUrl.hostname = 'api-eu.yourproduct.com';
      return Response.redirect(euUrl.toString(), 302);
    }

    // Add geo context headers for origin
    const newRequest = new Request(request, {
      headers: {
        ...Object.fromEntries(request.headers),
        'X-User-Country': country ?? 'unknown',
        'X-User-City': city ?? 'unknown',
        'X-User-Timezone': timezone ?? 'UTC',
      },
    });

    return fetch(newRequest);
  },
};

---

Deno Deploy

Deno Deploy is Cloudflare Workers' competitor — same edge concept, built on the Deno runtime (TypeScript-first, no node_modules):

// main.ts — Deno Deploy
import { serve } from "https://deno.land/std@0.224.0/http/server.ts";

serve(async (request: Request): Promise<Response> => {
  const url = new URL(request.url);

  if (url.pathname === '/api/status') {
    return Response.json({
      status: 'ok',
      region: Deno.env.get('DENO_REGION') ?? 'local',
      timestamp: new Date().toISOString(),
    });
  }

  return new Response('Not Found', { status: 404 });
});

Deno Deploy is simpler to get started with (no Wrangler config, deploy directly from GitHub), but Cloudflare Workers has more production features: R2, D1, Queues, Durable Objects.

---

What Edge Functions Are Bad At

Edge is not a universal replacement for Lambda or traditional servers:

Best use cases for edge:

• Auth and JWT validation before proxying to origin
• A/B testing and feature flags
• Geo-based routing and redirects
• Response caching (KV as cache)
• Bot detection and WAF rules
• Lightweight personalization
• API rate limiting

---

Working With Viprasol

We architect and implement edge computing solutions — Cloudflare Workers for auth, A/B testing, geolocation routing, and API gateways; edge-first architectures for global low-latency products; Deno Deploy for simple edge APIs.

→ Talk to our team about edge architecture and global performance.

---

See Also

• API Gateway Comparison — gateway options including Cloudflare Workers
• Serverless Cost Optimization — Lambda vs edge cost analysis
• CDN and Web Performance — caching at the edge vs origin
• Feature Flags — edge-based feature flag evaluation
• Cloud Solutions — edge and global infrastructure