Edge Functions vs Serverless: Real Performance Comparison

// monitoring/performance-tracker.ts
interface PerformanceMetrics {
  provider: string;
  functionType: 'edge' | 'serverless';
  region: string;
  coldStart: boolean;
  latency: number;
  executionTime: number;
  memoryUsed: number;
  cost: number;
}
 
class PerformanceMonitor {
  private metrics: PerformanceMetrics[] = [];
  
  async measureFunction(
    fn: () => Promise<any>,
    metadata: Partial<PerformanceMetrics>
  ) {
    const startMemory = process.memoryUsage().heapUsed;
    const startTime = performance.now();
    const isColdStart = this.detectColdStart();
    
    try {
      const result = await fn();
      
      const metric: PerformanceMetrics = {
        ...metadata,
        coldStart: isColdStart,
        latency: performance.now() - startTime,
        executionTime: this.getExecutionTime(),
        memoryUsed: (process.memoryUsage().heapUsed - startMemory) / 1048576,
        cost: this.calculateCost(metadata.provider, executionTime, memoryUsed)
      };
      
      this.metrics.push(metric);
      await this.sendToAnalytics(metric);
      
      return result;
    } catch (error) {
      await this.logError(error, metadata);
      throw error;
    }
  }
  
  private detectColdStart(): boolean {
    // Check if this is the first invocation
    const isFirstRun = !global.__initialized;
    global.__initialized = true;
    return isFirstRun;
  }
}

const coldStartMetrics = {
  'Cloudflare Workers': {
    p50: 8,    // ms
    p95: 15,
    p99: 28,
    max: 45
  },
  'Vercel Edge': {
    p50: 12,
    p95: 22,
    p99: 38,
    max: 67
  },
  'AWS Lambda@Edge': {
    p50: 45,
    p95: 89,
    p99: 145,
    max: 234
  },
  'AWS Lambda (Node.js)': {
    p50: 156,
    p95: 289,
    p99: 478,
    max: 892
  },
  'AWS Lambda (Python)': {
    p50: 134,
    p95: 245,
    p99: 398,
    max: 756
  },
  'Netlify Functions': {
    p50: 178,
    p95: 312,
    p99: 523,
    max: 945
  }
};

// Results for a simple API endpoint returning user data
const latencyByRegion = {
  'us-east-1': {
    edge: { avg: 18, p95: 32 },
    serverless: { avg: 45, p95: 78 }
  },
  'eu-west-1': {
    edge: { avg: 22, p95: 38 },
    serverless: { avg: 125, p95: 189 } // Server in us-east-1
  },
  'ap-southeast-1': {
    edge: { avg: 24, p95: 41 },
    serverless: { avg: 198, p95: 312 } // Server in us-east-1
  },
  'ap-northeast-1': {
    edge: { avg: 19, p95: 35 },
    serverless: { avg: 167, p95: 245 } // Server in us-east-1
  },
  'sa-east-1': {
    edge: { avg: 28, p95: 48 },
    serverless: { avg: 234, p95: 389 } // Server in us-east-1
  }
};

// edge/auth-validator.ts
export default {
  async fetch(request: Request): Promise<Response> {
    const startTime = Date.now();
    
    try {
      const token = request.headers.get('Authorization')?.replace('Bearer ', '');
      
      if (!token) {
        return new Response('Unauthorized', { status: 401 });
      }
      
      // Verify JWT using Web Crypto API
      const isValid = await verifyJWT(token);
      
      if (!isValid) {
        return new Response('Invalid token', { status: 401 });
      }
      
      // Check session in KV store (edge-native storage)
      const session = await env.SESSIONS.get(token);
      
      if (!session) {
        return new Response('Session expired', { status: 401 });
      }
      
      const executionTime = Date.now() - startTime;
      
      return new Response(JSON.stringify({
        valid: true,
        session: JSON.parse(session),
        executionTime,
        location: request.cf?.colo // Cloudflare edge location
      }), {
        headers: { 
          'Content-Type': 'application/json',
          'X-Execution-Time': executionTime.toString()
        }
      });
      
    } catch (error) {
      return new Response('Internal error', { status: 500 });
    }
  }
};
 
async function verifyJWT(token: string): Promise<boolean> {
  const encoder = new TextEncoder();
  const data = encoder.encode(token.split('.').slice(0, 2).join('.'));
  const signature = token.split('.')[2];
  
  const key = await crypto.subtle.importKey(
    'raw',
    encoder.encode(env.JWT_SECRET),
    { name: 'HMAC', hash: 'SHA-256' },
    false,
    ['verify']
  );
  
  return crypto.subtle.verify(
    'HMAC',
    key,
    base64ToArrayBuffer(signature),
    data
  );
}

// serverless/auth-validator.ts
import jwt from 'jsonwebtoken';
import { DynamoDB } from 'aws-sdk';
 
const dynamodb = new DynamoDB.DocumentClient();
 
export const handler = async (event: APIGatewayEvent) => {
  const startTime = Date.now();
  
  try {
    const token = event.headers.Authorization?.replace('Bearer ', '');
    
    if (!token) {
      return {
        statusCode: 401,
        body: JSON.stringify({ error: 'Unauthorized' })
      };
    }
    
    // Verify JWT
    const decoded = jwt.verify(token, process.env.JWT_SECRET!);
    
    // Check session in DynamoDB
    const session = await dynamodb.get({
      TableName: 'sessions',
      Key: { token }
    }).promise();
    
    if (!session.Item) {
      return {
        statusCode: 401,
        body: JSON.stringify({ error: 'Session expired' })
      };
    }
    
    const executionTime = Date.now() - startTime;
    
    return {
      statusCode: 200,
      body: JSON.stringify({
        valid: true,
        session: session.Item,
        executionTime,
        region: process.env.AWS_REGION
      }),
      headers: {
        'X-Execution-Time': executionTime.toString()
      }
    };
    
  } catch (error) {
    return {
      statusCode: 500,
      body: JSON.stringify({ error: 'Internal error' })
    };
  }
};

const authValidationMetrics = {
  edge: {
    avgExecutionTime: 12, // ms
    p95ExecutionTime: 23,
    avgTotalLatency: 28,
    p95TotalLatency: 45,
    costPer1M: 0.50 // USD
  },
  serverless: {
    avgExecutionTime: 34, // ms
    p95ExecutionTime: 67,
    avgTotalLatency: 89,
    p95TotalLatency: 156,
    costPer1M: 0.80 // USD
  }
};

// edge/geo-recommendations.ts
interface Product {
  id: string;
  name: string;
  price: number;
  currency: string;
  availability: string[];
}
 
export default {
  async fetch(request: Request): Promise<Response> {
    const country = request.cf?.country || 'US';
    const city = request.cf?.city || 'Unknown';
    const continent = request.cf?.continent || 'NA';
    
    // Get region-specific products from KV
    const cacheKey = `products:${country}:${continent}`;
    let products = await env.PRODUCTS.get(cacheKey, 'json');
    
    if (!products) {
      // Fallback to continental products
      products = await env.PRODUCTS.get(`products:${continent}`, 'json');
    }
    
    // Apply local pricing and availability
    const localizedProducts = products.map(product => ({
      ...product,
      price: convertCurrency(product.price, country),
      currency: getCurrency(country),
      available: product.availability.includes(country),
      shippingDays: calculateShipping(country, city)
    }));
    
    // Sort by relevance for the region
    const recommendations = sortByRegionalPreference(
      localizedProducts, 
      country
    );
    
    return new Response(JSON.stringify({
      recommendations: recommendations.slice(0, 10),
      location: { country, city, continent },
      cached: !!products
    }), {
      headers: {
        'Content-Type': 'application/json',
        'Cache-Control': 'public, max-age=300',
        'Vary': 'CF-IPCountry'
      }
    });
  }
};
 
function convertCurrency(price: number, country: string): number {
  const rates = {
    'US': 1,
    'GB': 0.79,
    'EU': 0.92,
    'JP': 149.5,
    'IN': 83.12
  };
  
  return price * (rates[country] || 1);
}
 
function calculateShipping(country: string, city: string): number {
  // Calculate shipping days based on warehouse locations
  const warehouses = {
    'US': ['New York', 'Los Angeles', 'Chicago'],
    'EU': ['London', 'Frankfurt', 'Paris'],
    'ASIA': ['Singapore', 'Tokyo', 'Mumbai']
  };
  
  // Simplified calculation
  if (warehouses[country]?.includes(city)) return 1;
  if (warehouses[country]) return 2;
  return 5;
}

// serverless/geo-recommendations.ts
import { S3, DynamoDB } from 'aws-sdk';
import geoip from 'geoip-lite';
 
const s3 = new S3();
const dynamodb = new DynamoDB.DocumentClient();
 
export const handler = async (event: APIGatewayEvent) => {
  const ip = event.requestContext.identity.sourceIp;
  const geo = geoip.lookup(ip);
  
  const country = geo?.country || 'US';
  const city = geo?.city || 'Unknown';
  const region = geo?.region || 'Unknown';
  
  try {
    // Get products from DynamoDB
    const products = await dynamodb.query({
      TableName: 'products',
      IndexName: 'country-index',
      KeyConditionExpression: 'country = :country',
      ExpressionAttributeValues: {
        ':country': country
      }
    }).promise();
    
    // If no country-specific products, get regional
    let items = products.Items;
    if (!items || items.length === 0) {
      const regionalProducts = await s3.getObject({
        Bucket: 'product-data',
        Key: `regions/${getRegion(country)}/products.json`
      }).promise();
      
      items = JSON.parse(regionalProducts.Body.toString());
    }
    
    // Process and return recommendations
    const recommendations = processRecommendations(items, country, city);
    
    return {
      statusCode: 200,
      body: JSON.stringify({
        recommendations,
        location: { country, city, region }
      }),
      headers: {
        'Cache-Control': 'public, max-age=300'
      }
    };
    
  } catch (error) {
    console.error('Error:', error);
    return {
      statusCode: 500,
      body: JSON.stringify({ error: 'Failed to get recommendations' })
    };
  }
};

const geoRecommendationMetrics = {
  'user-in-us-server-in-us': {
    edge: 15, // ms
    serverless: 45 // ms
  },
  'user-in-eu-server-in-us': {
    edge: 18, // ms - consistent globally
    serverless: 145 // ms - cross-Atlantic latency
  },
  'user-in-asia-server-in-us': {
    edge: 22, // ms - still fast
    serverless: 234 // ms - significant delay
  },
  'user-in-australia-server-in-us': {
    edge: 25, // ms
    serverless: 289 // ms - worst case
  }
};

// edge/image-optimizer.ts - FAILED APPROACH
export default {
  async fetch(request: Request): Promise<Response> {
    const url = new URL(request.url);
    const imageUrl = url.searchParams.get('url');
    const width = parseInt(url.searchParams.get('width') || '800');
    const quality = parseInt(url.searchParams.get('quality') || '85');
    
    try {
      // Fetch original image
      const imageResponse = await fetch(imageUrl);
      const imageBuffer = await imageResponse.arrayBuffer();
      
      // This is where Edge Functions hit their limits
      // Most edge platforms don't support heavy image processing libraries
      // Memory constraints (128-512MB) are too restrictive
      // CPU time limits (50-500ms) are insufficient
      
      return new Response('Image processing not supported on edge', {
        status: 501
      });
      
    } catch (error) {
      return new Response('Failed to process image', { status: 500 });
    }
  }
};

// serverless/image-optimizer.ts
import sharp from 'sharp';
import { S3 } from 'aws-sdk';
 
const s3 = new S3();
 
export const handler = async (event: APIGatewayEvent) => {
  const { url, width = '800', quality = '85', format = 'webp' } = 
    event.queryStringParameters || {};
  
  const cacheKey = `${url}-${width}-${quality}-${format}`;
  
  try {
    // Check cache first
    try {
      const cached = await s3.getObject({
        Bucket: 'image-cache',
        Key: cacheKey
      }).promise();
      
      return {
        statusCode: 200,
        body: cached.Body.toString('base64'),
        isBase64Encoded: true,
        headers: {
          'Content-Type': `image/${format}`,
          'Cache-Control': 'public, max-age=31536000',
          'X-Cache': 'HIT'
        }
      };
    } catch (e) {
      // Not in cache, continue processing
    }
    
    // Fetch original image
    const response = await fetch(url);
    const buffer = Buffer.from(await response.arrayBuffer());
    
    // Process with Sharp
    const processed = await sharp(buffer)
      .resize(parseInt(width), null, {
        withoutEnlargement: true,
        fit: 'inside'
      })
      .toFormat(format, {
        quality: parseInt(quality)
      })
      .toBuffer();
    
    // Cache the result
    await s3.putObject({
      Bucket: 'image-cache',
      Key: cacheKey,
      Body: processed,
      ContentType: `image/${format}`
    }).promise();
    
    return {
      statusCode: 200,
      body: processed.toString('base64'),
      isBase64Encoded: true,
      headers: {
        'Content-Type': `image/${format}`,
        'Cache-Control': 'public, max-age=31536000',
        'X-Cache': 'MISS'
      }
    };
    
  } catch (error) {
    console.error('Image processing error:', error);
    return {
      statusCode: 500,
      body: JSON.stringify({ error: 'Failed to process image' })
    };
  }
};

// Monthly costs for 10 million requests
const costAnalysis = {
  'Cloudflare Workers': {
    compute: 50.00,
    kvStorage: 5.00,
    bandwidth: 0, // Included
    total: 55.00
  },
  'Vercel Edge': {
    compute: 80.00,
    edgeStorage: 10.00,
    bandwidth: 20.00,
    total: 110.00
  },
  'AWS Lambda': {
    compute: 45.00,
    apiGateway: 35.00,
    dynamoDB: 25.00,
    dataTransfer: 30.00,
    total: 135.00
  },
  'AWS Lambda@Edge': {
    compute: 120.00,
    cloudFront: 40.00,
    dataTransfer: 45.00,
    total: 205.00
  }
};
 
// Cost per request type
const costPerRequestType = {
  simpleApi: {
    edge: 0.0000050, // $0.05 per 10k requests
    serverless: 0.0000080 // $0.08 per 10k requests
  },
  dataProcessing: {
    edge: 0.0000120, // Limited by constraints
    serverless: 0.0000095 // More efficient for heavy compute
  },
  realtimePersonalization: {
    edge: 0.0000045, // Optimal use case
    serverless: 0.0000150 // Higher due to latency requirements
  }
};

// infrastructure/routing-strategy.ts
export class RequestRouter {
  static async route(request: Request): Promise<Response> {
    const path = new URL(request.url).pathname;
    
    // Route to Edge Functions
    if (this.shouldUseEdge(path)) {
      return this.routeToEdge(request);
    }
    
    // Route to Serverless
    return this.routeToServerless(request);
  }
  
  private static shouldUseEdge(path: string): boolean {
    const edgeOptimalPaths = [
      '/api/auth/verify',      // Low latency critical
      '/api/geo/*',            // Location-based
      '/api/redirect/*',       // Simple redirects
      '/api/ab-test/*',        // A/B testing
      '/api/rate-limit/*',     // Rate limiting
      '/api/cache-proxy/*'     // Cache layer
    ];
    
    return edgeOptimalPaths.some(pattern => 
      this.matchPath(path, pattern)
    );
  }
  
  private static async routeToEdge(request: Request): Promise<Response> {
    // Add edge-specific headers
    const edgeRequest = new Request(request, {
      headers: {
        ...request.headers,
        'X-Route-Type': 'edge',
        'X-Timestamp': Date.now().toString()
      }
    });
    
    return fetch(process.env.EDGE_FUNCTION_URL, edgeRequest);
  }
  
  private static async routeToServerless(request: Request): Promise<Response> {
    // Route to appropriate Lambda based on workload
    const endpoint = this.getServerlessEndpoint(request);
    
    return fetch(endpoint, {
      method: request.method,
      headers: {
        ...request.headers,
        'X-Route-Type': 'serverless'
      },
      body: await request.text()
    });
  }
}

// migration/edge-migration-analyzer.ts
export class EdgeMigrationAnalyzer {
  async analyzeEndpoint(endpoint: string): Promise<MigrationReport> {
    const metrics = await this.gatherMetrics(endpoint);
    
    return {
      endpoint,
      currentPlatform: metrics.platform,
      recommendation: this.getRecommendation(metrics),
      estimatedSavings: this.calculateSavings(metrics),
      migrationComplexity: this.assessComplexity(metrics),
      blockers: this.identifyBlockers(metrics)
    };
  }
  
  private getRecommendation(metrics: EndpointMetrics): string {
    // Strong candidates for Edge
    if (metrics.avgExecutionTime < 50 && 
        metrics.memoryUsage < 128 && 
        metrics.hasGlobalUsers &&
        !metrics.usesHeavyLibraries) {
      return 'MIGRATE_TO_EDGE';
    }
    
    // Stay on Serverless
    if (metrics.avgExecutionTime > 500 ||
        metrics.memoryUsage > 512 ||
        metrics.requiresFileSystem ||
        metrics.usesNativeModules) {
      return 'KEEP_SERVERLESS';
    }
    
    // Consider hybrid
    return 'HYBRID_APPROACH';
  }
  
  private identifyBlockers(metrics: EndpointMetrics): string[] {
    const blockers = [];
    
    if (metrics.usesNativeModules) {
      blockers.push('Native Node.js modules not supported on edge');
    }
    
    if (metrics.executionTime > 500) {
      blockers.push('Execution exceeds edge timeout limits');
    }
    
    if (metrics.memoryUsage > 128) {
      blockers.push('Memory requirements exceed edge limits');
    }
    
    if (metrics.requiresFileSystem) {
      blockers.push('File system access not available on edge');
    }
    
    return blockers;
  }
}

// monitoring/edge-debugger.ts
export class EdgeDebugger {
  static async trace(request: Request, env: any): Promise<void> {
    const traceId = crypto.randomUUID();
    const startTime = Date.now();
    
    // Log to edge-native storage (KV, Durable Objects, etc.)
    await env.TRACES.put(traceId, JSON.stringify({
      timestamp: startTime,
      url: request.url,
      method: request.method,
      headers: Object.fromEntries(request.headers),
      cf: request.cf, // Cloudflare-specific geo data
    }));
    
    // Since console.log may not be available or visible
    // We send traces to an external service
    fetch('https://trace-collector.example.com/edge', {
      method: 'POST',
      body: JSON.stringify({
        traceId,
        timestamp: startTime,
        location: request.cf?.colo,
        executionTime: Date.now() - startTime
      })
    }).catch(() => {}); // Fire and forget
  }
  
  static async captureError(error: Error, context: any): Promise<void> {
    // Edge functions have limited error reporting
    const errorData = {
      message: error.message,
      stack: error.stack,
      timestamp: Date.now(),
      context
    };
    
    // Store in KV for later analysis
    const errorId = crypto.randomUUID();
    await context.env.ERRORS.put(
      `error:${errorId}`,
      JSON.stringify(errorData),
      { expirationTtl: 86400 } // 24 hours
    );
  }
}

// decision-framework.ts
export function shouldUseEdgeFunction(requirements: Requirements): Decision {
  const score = {
    edge: 0,
    serverless: 0
  };
  
  // Latency requirements
  if (requirements.maxLatency < 50) score.edge += 3;
  else if (requirements.maxLatency < 100) score.edge += 1;
  else score.serverless += 2;
  
  // Geographic distribution
  if (requirements.globalUsers) score.edge += 3;
  else score.serverless += 1;
  
  // Execution time
  if (requirements.avgExecutionTime < 50) score.edge += 2;
  else if (requirements.avgExecutionTime > 500) score.serverless += 3;
  
  // Memory requirements
  if (requirements.memoryMB < 128) score.edge += 2;
  else if (requirements.memoryMB > 512) score.serverless += 3;
  
  // Dependencies
  if (requirements.usesNativeModules) score.serverless += 5;
  if (requirements.needsFileSystem) score.serverless += 5;
  
  // Cost sensitivity
  if (requirements.costPriority === 'high') {
    // Edge is generally cheaper for high-volume, simple operations
    if (requirements.requestsPerMonth > 1000000) score.edge += 2;
  }
  
  return {
    recommendation: score.edge > score.serverless ? 'EDGE' : 'SERVERLESS',
    confidence: Math.abs(score.edge - score.serverless) / 
                Math.max(score.edge, score.serverless),
    reasoning: generateReasoning(score, requirements)
  };
}