System Design for Beginners (2026): The Complete Scalable Architecture Masterclass

// The Evolution of a Scalable System
// Phase 1: Single Server (Monolith + Local DB + Local Files) -> Bottleneck: Shared RAM/CPU
// Phase 2: Decoupled Storage (Stateless App Server + Managed DB + Object Storage S3)
// Phase 3: Horizontal App Scaling (Load Balancer + N App Servers)
// Phase 4: Edge Acceleration (CDN for Global Media Delivery)
// Phase 5: Caching & Indexing (Redis Cache-Aside + Database B-Tree Indexes)
// Phase 6: Async Decoupling (Message Queue + Worker Fleet for Media Resizing)
// Phase 7: Database Scaling (Primary-Replica Read Clusters + Horizontal Sharding)

export interface SystemArchitectureTier {
  tierName: string;
  primaryRole: string;
  scalingStrategy: "vertical" | "horizontal";
  bottlenecks: string[];
}

// Back-of-the-Envelope Estimation Formula Standards
export function estimateSystemScale(dau: number, avgUploadsPerUser: number, avgPhotoSizeMB: number) {
  const SECONDS_PER_DAY = 86400;
  
  const dailyUploads = dau * avgUploadsPerUser;
  const writeQPS = Math.ceil(dailyUploads / SECONDS_PER_DAY);
  const peakWriteQPS = writeQPS * 2; // Standard 2x peak traffic multiplier
  
  const readQPS = writeQPS * 50; // Assuming 50:1 read-to-write ratio
  const peakReadQPS = readQPS * 2;
  
  const dailyStorageGB = (dailyUploads * avgPhotoSizeMB) / 1024;
  const yearlyStorageTB = (dailyStorageGB * 365) / 1024;
  
  return {
    writeQPS,
    peakWriteQPS,
    readQPS,
    peakReadQPS,
    dailyStorageGB: Math.round(dailyStorageGB),
    yearlyStorageTB: Math.round(yearlyStorageTB)
  };
}

// Decoupled Storage Architecture: Direct-to-S3 Upload Handler
import { S3Client, PutObjectCommand } from "@aws-sdk/client-s3";
import { getSignedUrl } from "@aws-sdk/s3-request-presigner";

const s3 = new S3Client({ region: "us-east-1" });

export async function generateUploadUrl(userId: string, filename: string) {
  const objectKey = `uploads/${userId}/${Date.now()}_${filename}`;
  
  const command = new PutObjectCommand({
    Bucket: "production-photo-storage",
    Key: objectKey,
    ContentType: "image/jpeg"
  });

  // Generate 15-minute temporary pre-signed upload URL
  const uploadUrl = await getSignedUrl(s3, command, { expiresIn: 900 });

  return {
    uploadUrl,
    objectKey,
    publicUrl: `https://cdn.photoapp.com/${objectKey}`
  };
}

// Load Balancer Routing Algorithm Implementations
export class LoadBalancer {
  private servers: { id: string; isHealthy: boolean; activeConnections: number }[] = [];
  private currentIndex: number = 0;

  addServer(id: string) {
    this.servers.push({ id, isHealthy: true, activeConnections: 0 });
  }

  // 1. Round-Robin Routing
  getRoundRobinServer(): string | null {
    const healthyServers = this.servers.filter(s => s.isHealthy);
    if (healthyServers.length === 0) return null;
    
    const server = healthyServers[this.currentIndex % healthyServers.length];
    this.currentIndex++;
    return server.id;
  }

  // 2. Least Connections Routing
  getLeastConnectionsServer(): string | null {
    const healthyServers = this.servers.filter(s => s.isHealthy);
    if (healthyServers.length === 0) return null;

    return healthyServers.reduce((prev, curr) => 
      curr.activeConnections < prev.activeConnections ? curr : prev
    ).id;
  }
}

// Express / Next.js Response Headers for CDN Optimization
export function setCdnHeaders(res: any, assetType: "immutable_media" | "dynamic_api") {
  if (assetType === "immutable_media") {
    // Cache at edge CDN and browser for 1 full year; immutable prevents revalidation
    res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
  } else {
    // Dynamic user API: Cache for 60s at edge, must revalidate with origin
    res.setHeader("Cache-Control", "public, s-maxage=60, stale-while-revalidate=30");
  }
}

-- Relational Schema & Indexing Strategy for Photo App
CREATE TABLE users (
  id UUID PRIMARY KEY,
  username VARCHAR(50) UNIQUE NOT NULL,
  email VARCHAR(255) UNIQUE NOT NULL,
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE photos (
  id UUID PRIMARY KEY,
  user_id UUID NOT NULL REFERENCES users(id),
  s3_url VARCHAR(500) NOT NULL,
  caption TEXT,
  likes_count INT DEFAULT 0,
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Crucial Secondary Indexes for Fast Feed Queries
CREATE INDEX idx_photos_user_created ON photos (user_id, created_at DESC);
CREATE INDEX idx_photos_created_at ON photos (created_at DESC);

// Redis Cache-Aside Pattern Implementation
import Redis from "ioredis";
const redis = new Redis();

export async function getUserProfile(userId: string, dbQueryFn: (id: string) => Promise<any>) {
  const cacheKey = `user:profile:${userId}`;

  // 1. Try fetching from in-memory Redis cache
  const cachedData = await redis.get(cacheKey);
  if (cachedData) {
    return JSON.parse(cachedData); // Cache Hit: Sub-millisecond return
  }

  // 2. Cache Miss: Fetch from primary database
  const dbData = await dbQueryFn(userId);
  if (!dbData) return null;

  // 3. Populate Redis with 1-hour expiration (TTL = 3600 seconds)
  await redis.setex(cacheKey, 3600, JSON.stringify(dbData));

  return dbData;
}

// Asynchronous Message Queue Event Architecture
export interface PhotoProcessingJob {
  photoId: string;
  s3RawUrl: string;
  userId: string;
  timestamp: number;
}

// 1. Web Server Handler: Fast enqueue & immediate HTTP 202 response
export async function handlePhotoUpload(req: any, res: any, queueClient: any) {
  const { photoId, s3RawUrl, userId } = req.body;

  // Publish event to background message queue
  await queueClient.publish("photo.processing", {
    photoId,
    s3RawUrl,
    userId,
    timestamp: Date.now()
  });

  return res.status(202).json({ 
    status: "processing", 
    message: "Photo accepted. Thumbnails are being generated." 
  });
}

// 2. Background Worker Fleet Consumer
export async function startWorkerConsumer(queueClient: any, imageProcessor: any) {
  queueClient.subscribe("photo.processing", async (job: PhotoProcessingJob) => {
    console.log(`[Worker] Processing thumbnails for photo: ${job.photoId}`);
    await imageProcessor.generateThumbnails(job.s3RawUrl);
    await imageProcessor.notifyFollowers(job.userId, job.photoId);
  });
}

// Database Sharding Router using Shard Key Hashing
import crypto from "crypto";

export class DatabaseShardRouter {
  private shardEndpoints: string[];

  constructor(shardEndpoints: string[]) {
    this.shardEndpoints = shardEndpoints;
  }

  // Deterministically routes user operations to the correct DB shard
  getShardForUser(userId: string): string {
    const hash = crypto.createHash("md5").update(userId).digest("hex");
    // Convert first 8 hex characters to integer
    const hashNum = parseInt(hash.substring(0, 8), 16);
    const shardIndex = hashNum % this.shardEndpoints.length;
    
    return this.shardEndpoints[shardIndex];
  }
}

// SYSTEM DESIGN MASTER ARCHITECTURE COMPONENT MATRIX
// ------------------------------------------------------------------------------------------------
// Tier               | Technology Examples         | Primary Scaling Role
// ------------------------------------------------------------------------------------------------
// DNS & Edge CDN     | Cloudflare, CloudFront      | Global Anycast routing & static media caching
// Load Balancing     | NGINX, AWS ALB, Envoy       | Distribute HTTP traffic & active health checks
// Application Tier   | Node.js, Go, Python (Docker)| Stateless compute & business logic execution
// In-Memory Cache    | Redis, Memcached            | Sub-millisecond Cache-Aside read acceleration
// Object Storage     | Amazon S3, MinIO, GCS       | High-durability (11 9s) binary photo storage
// Relational DB      | PostgreSQL, MySQL           | ACID transactions & structured metadata
// DB Read Replicas   | Read-only DB Instances      | Scale read throughput linearly across regions
// Database Sharding  | Citus, Vitess, Manual Hash  | Scale write throughput and partition petabytes
// Message Queues     | RabbitMQ, Apache Kafka, SQS | Asynchronous task decoupling & burst smoothing
// Worker Fleet       | Background Consumers        | Heavy thumbnail generation & push notifications
// ------------------------------------------------------------------------------------------------