Edge Computing
Comprehensive guide to edge computing architecture - running compute closer to users for lower latency and better performance.
When to Use This Skill
- Designing edge function architectures
- Deciding where to place compute (edge vs origin)
- Implementing serverless at edge
- Understanding edge platform capabilities
- Optimizing latency-sensitive applications
- Building globally distributed applications
Edge Computing Fundamentals
What is Edge Computing?
Compute Placement Spectrum:
┌─────────────────────────────────────────────────────────────┐
│ │
│ User Device Edge Regional Central Origin │
│ (Client) (CDN) (Cloud) (Cloud) (Cloud) │
│ │
│ ◄──────────────────────────────────────────────────► │
│ │
│ Lowest ┌─────────────────────────────┐ Highest │
│ Latency │ EDGE COMPUTING │ Latency │
│ │ (This skill's focus) │ │
│ └─────────────────────────────┘ │
│ │
│ Limited ◄─────────────────────────────► Full │
│ Resources Resources │
│ │
└─────────────────────────────────────────────────────────────┘
Edge = Running code on CDN/network edge servers (100s of locations)
vs Regional = Running in a few cloud regions (10-20 locations)
vs Origin = Running in one primary location (1-3 locations)Edge vs Serverless vs Traditional
Comparison:
Edge Functions Cloud Functions Containers/VMs
────────────────────────────────────────────────────────────────────────
Locations 100-300+ 10-20 1-10
Cold Start <50ms 100ms-seconds N/A (always warm)
Execution Limit 10-30 seconds 15 minutes Unlimited
Memory 128MB-1GB 256MB-10GB Unlimited
CPU Limited Standard Full control
State Stateless Stateless Stateful OK
Cost Model Per request Per request Per instance
Best For Low-latency, General compute Complex apps,
simple logic long-running
Use Cases by Type:
Edge: Auth, routing, personalization, A/B tests, redirects
Cloud Functions: APIs, webhooks, background processing
Containers: Full applications, databases, ML inferenceEdge Platform Architecture
Edge Platform Components:
┌─────────────────────────────────────────────────────────────┐
│ Control Plane │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ Deploy │ │ Config │ │ Secrets │ │ Metrics │ │
│ │ API │ │ Store │ │ Mgmt │ │ & Logs │ │
│ └────┬─────┘ └────┬─────┘ └────┬─────┘ └────┬─────┘ │
└───────┼─────────────┼─────────────┼─────────────┼──────────┘
│ │ │ │
└─────────────┼─────────────┼─────────────┘
│ │
╔═════════════╧═════════════╧═════════════╗
║ Global Distribution ║
╚═════════════════════════════════════════╝
│
┌─────────────────┼─────────────────┐
│ │ │
┌───▼───┐ ┌───▼───┐ ┌───▼───┐
│ Edge │ │ Edge │ │ Edge │
│ POP 1 │ │ POP 2 │ │ POP N │
│┌─────┐│ │┌─────┐│ │┌─────┐│
││ V8 ││ ││ V8 ││ ││ V8 ││
││Isol.││ ││Isol.││ ││Isol.││
│└─────┘│ │└─────┘│ │└─────┘│
└───────┘ └───────┘ └───────┘
Execution Model:
- V8 Isolates: Lightweight isolation (not containers)
- Instant cold start (sub-50ms)
- Per-request execution
- Auto-scaled per POPEdge Function Patterns
Request Interception
Request/Response Lifecycle:
User Request ──► Edge Function ──► Origin (optional)
│
┌───────┴───────┐
│ │
Modify Request Short-circuit
(continue to (return response
origin) from edge)
Use Cases:
1. URL Rewriting
/old-page → /new-page
/api/v1/* → /api/v2/*
2. Header Manipulation
Add security headers
Add request ID
Normalize Accept-Language
3. Authentication
Validate JWT at edge
Check API key
Redirect to login
4. A/B Testing
Assign cohort
Rewrite to variant URL
5. Bot Protection
Challenge bots
Block known bad actors
6. Geolocation Routing
Route to regional origin
Apply regional rulesResponse Transformation
Response Transformation Patterns:
1. HTML Injection
┌─────────────────────────────────────────┐
│ Inject analytics, A/B test scripts │
│ Add personalized content │
│ Insert GDPR banners by region │
└─────────────────────────────────────────┘
2. Content Optimization
┌─────────────────────────────────────────┐
│ Compress responses │
│ Image optimization/resizing │
│ Minification │
└─────────────────────────────────────────┘
3. Response Caching
┌─────────────────────────────────────────┐
│ Cache API responses at edge │
│ Assemble from cache fragments │
│ Serve stale while revalidating │
└─────────────────────────────────────────┘
4. Error Handling
┌─────────────────────────────────────────┐
│ Fallback pages on origin error │
│ Custom error pages per region │
│ Retry logic with backoff │
└─────────────────────────────────────────┘Edge Storage Patterns
Edge Storage Options:
1. Key-Value Store (KV)
├── Read-heavy workloads
├── Eventually consistent
├── Low latency reads
└── Limited write throughput
Use: Feature flags, configuration, user sessions
2. Durable Objects (Cloudflare)
├── Strong consistency
├── Stateful edge compute
├── Single-instance per ID
└── WebSocket support
Use: Real-time collaboration, chat, gaming state
3. Edge Databases
├── Distributed SQL (PlanetScale, Turso)
├── Read replicas at edge
├── Low latency reads
└── Write to primary region
Use: User data, product catalogs, CMS
4. R2/S3-Compatible Storage
├── Object storage at edge
├── No egress fees (some providers)
└── Large file storage
Use: Static assets, user uploads, backupsCompute Placement Decisions
Decision Framework
Where Should This Run?
Question 1: Latency Requirements
├── <50ms required? → Edge
├── <200ms acceptable? → Regional cloud
└── Latency not critical? → Central origin
Question 2: Compute Complexity
├── Simple transformations? → Edge
├── Moderate logic? → Edge or Regional
└── Complex processing? → Regional or Central
Question 3: Data Dependencies
├── No data needed? → Edge
├── Read-heavy, cacheable? → Edge with cache
├── Strong consistency needed? → Regional
└── Write-heavy? → Central
Question 4: State Requirements
├── Stateless? → Edge
├── Session state? → Edge with KV/Durable Objects
└── Complex state? → Regional or Central
Question 5: Cost Sensitivity
├── High request volume, simple? → Edge (efficient)
├── CPU-intensive? → Regional (cheaper)
└── Long-running? → CentralHybrid Architecture
Hybrid Edge + Origin Architecture:
┌─────────────────────────────────────────────────────────────┐
│ Edge Layer │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ • Authentication/Authorization │ │
│ │ • Rate limiting │ │
│ │ • Request routing │ │
│ │ • Static content │ │
│ │ • Simple personalization │ │
│ │ • Caching logic │ │
│ └─────────────────────────────────────────────────────┘ │
└────────────────────────────┬────────────────────────────────┘
│
Only complex requests pass through
│
┌────────────────────────────▼────────────────────────────────┐
│ Origin Layer │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ • Business logic │ │
│ │ • Database operations │ │
│ │ • Third-party integrations │ │
│ │ • ML inference │ │
│ │ • Complex computations │ │
│ └─────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
Benefits:
- Offload work from origin
- Faster responses for simple requests
- Origin protected from attack traffic
- Scale each layer independentlyEdge Platforms
Cloudflare Workers
Cloudflare Workers:
Execution:
- V8 isolates (not containers)
- <5ms cold start
- 200+ edge locations
- 10ms CPU time (free) / 30s (paid)
Features:
├── Workers KV (key-value store)
├── Durable Objects (stateful)
├── R2 (object storage)
├── D1 (SQLite at edge)
├── Queues (async processing)
└── Hyperdrive (database connection pooling)
Example:
export default {
async fetch(request, env, ctx) {
const url = new URL(request.url);
// Simple routing
if (url.pathname.startsWith('/api/')) {
return handleAPI(request, env);
}
// Serve static
return env.ASSETS.fetch(request);
}
}AWS Lambda@Edge / CloudFront Functions
AWS Edge Options:
CloudFront Functions:
├── JavaScript only
├── Sub-millisecond start
├── 2MB memory
├── Request/response manipulation only
├── Cannot make network calls
└── Very cheap at scale
Lambda@Edge:
├── Node.js, Python
├── 128-3008MB memory
├── Up to 30s execution (origin response)
├── Can make network calls
├── Access to AWS services
└── Higher latency than CF Functions
Use Case Mapping:
CloudFront Functions: Headers, redirects, URL rewrites
Lambda@Edge: Auth, A/B testing, dynamic responses
Lambda (Regional): Full API logic, database accessFastly Compute@Edge
Fastly Compute@Edge:
Execution:
- WebAssembly-based (Wasm)
- Multi-language (Rust, JS, Go, etc.)
- No cold start (pre-compiled)
- 50ms-120s execution time
Features:
├── Geolocation data
├── Device detection
├── Real-time logging
├── Edge dictionaries
└── Origin fetch with caching
Strengths:
- Best for dynamic content
- Real-time purging
- Advanced caching control
- Strong VCL migration path
Example (Rust):
use fastly::{Request, Response};
#[fastly::main]
fn main(req: Request) -> Result<Response, Error> {
match req.get_path() {
"/api" => handle_api(req),
_ => Ok(req.send("origin")?)
}
}Best Practices
Edge Computing Best Practices:
1. Keep It Simple
□ Edge = simple, fast operations
□ Complex logic → origin
□ Minimize dependencies
□ Fail fast and gracefully
2. Optimize Cold Start
□ Minimize code size
□ Lazy load where possible
□ Use global scope for init
□ Avoid heavy dependencies
3. Handle Failures
□ Origin unavailable handling
□ Timeout handling
□ Fallback responses
□ Error tracking
4. Monitor Everything
□ Latency percentiles
□ Error rates
□ Cold start frequency
□ Origin fallthrough rate
5. Security
□ Validate input at edge
□ Rate limit early
□ Sanitize data
□ Use secrets management
6. Cost Optimization
□ Cache aggressively
□ Right-size execution time
□ Use appropriate tier
□ Monitor usage patternsAnti-Patterns
Edge Computing Anti-Patterns:
1. "Everything at Edge"
❌ Moving all logic to edge
✓ Strategic placement based on requirements
2. "Database at Edge"
❌ Complex database operations at edge
✓ Read replicas or cached data at edge
3. "Ignoring Cold Starts"
❌ Large bundles, heavy initialization
✓ Optimize bundle size, lazy loading
4. "Origin Coupling"
❌ Edge functions tightly coupled to origin
✓ Edge functions should work independently when possible
5. "No Fallbacks"
❌ Edge function fails = user sees error
✓ Graceful degradation, cached responses
6. "Synchronous Everything"
❌ Waiting for slow operations at edge
✓ Async processing, fire-and-forget loggingRelated Skills
cdn-architecture- CDN and caching patternsserverless-patterns- Serverless architecturelatency-optimization- End-to-end latency reductionmulti-region-deployment- Global infrastructure