Vercel Billing Demystified: Edge Requests, Function Duration, and ISR Costs

// Pro plan included (2026 rates, verify current):
// - Function Duration: 1000 GB-hours
// - Function Invocations: 1M requests
// - Edge Requests: 10M requests
// - Fast Data Transfer: 1TB
// - Fast Origin Transfer: 100GB
// - ISR Reads: 10M units
// - ISR Writes: 2M units
// - Image Optimization: 5000 source images

// One request can trigger multiple charges:
// 1. Edge Request (CDN processed it)
// 2. Fast Data Transfer (response sent to user)
// 3. Fast Origin Transfer (if cache miss → function)
// 4. Function Invocation (function ran)
// 5. Function Duration (time × memory)
// 6. ISR Read/Write (if page uses ISR)

// A typical page load:
// - GET /                    → 1 Edge Request
// - GET /styles.css          → 1 Edge Request  
// - GET /script.js           → 1 Edge Request
// - GET /logo.png            → 1 Edge Request
// - GET /api/user            → 1 Edge Request
// - GET /fonts/Inter.woff2   → 1 Edge Request
// Total: 6 Edge Requests per page view

// 100k monthly visitors × 5 pages × 6 requests = 3M Edge Requests
// Still under 10M included, but growing fast

// A function that runs 50ms with 1GB memory:
// Duration: 50ms = 0.05 seconds
// GB-seconds: 1GB × 0.05s = 0.05 GB-seconds
// 1000 invocations = 50 GB-seconds = 0.0139 GB-hours

// Sounds tiny, but...

// API route that calls external service (500ms avg):
// 100k requests/month × 0.5s × 1GB = 50,000 GB-seconds
// = 13.9 GB-hours per month for ONE endpoint

// Multiply by endpoints and you approach limits fast

// ISR page with revalidate: 60 (every minute)
// 1440 revalidations/day × 30 days = 43,200 writes/month

// BUT: If content unchanged, no write charged
// ✓ Vercel compares hashes before writing

// What DOES cause writes:
// - `new Date()` in component → always "changed"
// - `Math.random()` → always "changed"  
// - API response with timestamps → always "changed"
// - Build IDs in output → changes every deploy

// Debug unexpected writes:
// 1. Check for non-deterministic content
// 2. Remove timestamps from rendered output
// 3. Use stable cache keys

// Serverless Function (Node.js runtime):
// - Charged by GB-hours of execution
// - Memory: 128MB to 3008MB configurable
// - Cold starts: ~250-500ms
// - Can use full Node.js APIs

// Edge Function (Edge Runtime):
// - Charged by Edge Request CPU Duration
// - First 10ms CPU time: free per request
// - Metered in 10ms increments after
// - Faster cold starts (~50ms)
// - Limited APIs (no TCP, fs, etc.)

// Cost comparison for simple API:
// Serverless: 100ms × 1GB = charged
// Edge: 5ms CPU time = free (under 10ms threshold)

// Fast Data Transfer (FDT):
// - Browser ↔ Vercel CDN
// - Charged on response size to users
// - 1TB included, then ~$0.15/GB

// Fast Origin Transfer (FOT):
// - Vercel CDN ↔ Your Functions
// - Cache MISS triggers this
// - 100GB included, then ~$0.06/GB

// A 500KB API response, cache MISS:
// FDT: 500KB (response to browser)
// FOT: 500KB (function to CDN)
// Total: 1MB bandwidth charged

// A 500KB API response, cache HIT:
// FDT: 500KB (response to browser)
// FOT: 0 (served from CDN cache)
// Total: 500KB bandwidth charged

// Charged per source image, not per request
// 5000 images included on Pro

// What counts as a "source image":
// - Each unique image URL
// - NOT each size variant
// - NOT each format conversion

// One image optimized to 10 sizes = 1 source image
// 10 different images × 1 size each = 10 source images

// External images count against your quota!
<Image src="https://cdn.example.com/photo.jpg" ... />
// ↑ This external URL counts as 1 source image

// Example regional multipliers (approximate):
// US (iad1, sfo1): 1.0x
// Europe (fra1, lhr1): 1.2x
// Asia (sin1, hnd1): 1.5x
// South America (gru1): 1.8x
// Australia (syd1): 1.4x

// 1GB of data transfer:
// US: $0.15
// São Paulo: $0.27 (1.8x)

// Function running in Singapore costs 1.5x US rates

// Site: Medium blog, 50k monthly visitors
// Stack: Next.js App Router, ISR pages, Neon database

// Edge Requests: 50k × 8 assets avg = 400k (under 10M ✓)
// Fast Data Transfer: 50k × 500KB avg = 25GB (under 1TB ✓)
// Function Invocations: 50k API calls = 50k (under 1M ✓)

// Where it goes wrong:
// ISR: 200 pages × revalidate: 60 × 1440 min/day × 30 days
//    = 8.6M writes/month (2M included → 6.6M overage)
//    = ~$16 in ISR write overage

// Database-calling functions, 500ms each:
// 50k × 0.5s × 1GB = 25,000 GB-seconds = 6.9 GB-hours
// (under 1000 included ✓)

// Image Optimization: 2000 blog post images
// (under 5000 ✓)

// Real culprit: Aggressive ISR revalidation
// Fix: revalidate: 3600 instead of 60
// New ISR writes: 144k/month (under 2M ✓)