Sign In — Vetora

Vetora

Pricing Playground

System Design Templates

Easy

Notification System — Async Pipeline (Priority Queue)
Notification System — Naive (Synchronous Send)
Pastebin — Naive (Single Service + SQL)
Pastebin — Object Storage + NoSQL TTL
Pastebin — RDBMS with Cache (Postgres + Redis)
Pastebin — Text Sharing Service
TinyURL — Counter-Based (Base62)
TinyURL — Naive Single-Server
TinyURL — Serverless (Lambda + DynamoDB)
Web Crawler — Naive (Single-Threaded BFS)
Web Crawler — Producer-Consumer (Kafka Frontier)

Medium

Ad Click Aggregator — Naive (Single Service + SQL)
Ad Click Aggregator — Stream Processing (Kafka + Windowed Aggregation)
Distributed Cache — Consistent Hash Sharding
Distributed Cache — Naive (Single Redis Node)
Distributed Cache — Redis Cluster with Replication + Multi-Tier
Distributed Counter — Sharded Aggregation
Dropbox / File Sync — Block-Level Chunked (SHA-256 + Kafka)
Dropbox / File Sync — Naive (Whole-File Upload + Polling)
E-Commerce Checkout — Naive (Monolith + ACID Transaction)
E-Commerce Checkout — Saga Orchestrator (Event-Driven)
Email System — Transactional & Bulk Delivery
Feed Ranking — Multi-Stage ML Pipeline
Feed Ranking — Naive (Chronological + Heuristic)
Feed Ranking — Real-Time Online Learning + Multi-Tower
Instagram — CDN + Presigned Upload (Async Processing)
Instagram — Naive (API-Proxied Upload + No CDN)
Job Scheduler — Distributed Cron System
Job Scheduler — Leader-Elected Queue (Advisory Lock + Kafka)
Job Scheduler — Naive (Single Scheduler + DB Polling)
Live Sports Betting — Naive (Polling + Monolith)
Notification System — Multi-Channel Fanout
Online Code Editor — Container + CRDT Collaboration
Online Code Editor — Container + OT Collaboration
Online Code Editor — Naive (Shared Process Pool)
Rate Limiter — API Throttling
Real-Time Chat — Kafka Fan-Out (WebSocket + Presence)
Real-Time Chat — Naive (HTTP Polling + SQL)
Ride Hailing — Naive (Monolith + SQL Distance Sort)
Search Autocomplete — Naive (Database LIKE Query)
Search Autocomplete — Trie + Top-K (In-Memory Trie)
Search Autocomplete — Trie-Based Suggestions
TinyURL — Production Multi-Region
Twitter Feed — Fanout-on-Write (CQRS-Lite Push Model)
Twitter Feed — Naive (Fanout-on-Read / Pull Model)
Video Streaming — Adaptive Multi-Region (HLS + Edge + Cassandra)
Video Streaming — CDN + Async Transcode (HLS + CloudFront)
Video Streaming — Naive (Single Bitrate, No CDN)
Web Crawler — Distributed (Bloom + Priority Frontier)
Web Crawler — Distributed URL Frontier

Hard

Ad Click Aggregator — CQRS + Event Sourcing
Ad Click Aggregator — Lambda Architecture (Speed + Batch Layers)
Distributed Cache — Consistent Hashing
Distributed Counter — CRDT (Multi-Region Grow-Only Counters)
Distributed Counter — Naive (Single PostgreSQL Row)
Distributed Counter — Sharded with Async Aggregation
Distributed File System — Erasure-Coded Multi-Region Storage
Distributed File System — Metadata + Distributed Block Storage
Distributed File System — Naive (Single NFS-Like Server)
Distributed Filesystem — Metadata + Block Storage
Dropbox — File Storage & Sync
Dropbox / File Sync — Delta Sync + Dedup (WebSocket + CDN)
E-Commerce Checkout — Distributed Saga + Outbox Pattern
Email Service — Multi-Stage Pipeline (IP Reputation + Webhooks)
Email Service — Naive (Synchronous SMTP)
Email Service — Queue-Based Pipeline (Kafka + Workers)
Feed Ranking — ML-Powered News Feed
Flash Sale — Naive (Direct DB Lock)
Flash Sale — Queue-Based Commerce
Flash Sale — Tiered (Waiting Room + Bot Detection + CDN Edge)
Flash Sale — Virtual Queue + Token Bucket
Instagram — Async Media Pipeline (Hybrid Feed + Whale Detection)
Instagram — CDN-First Photo Sharing
Job Scheduler — Sharded Time-Wheel + DAG Workflows
Live Betting — Real-Time Odds Engine
Live Sports Betting — Event-Sourced Ledger (WebSocket + Kafka)
Live Sports Betting — Global Compliant (Event-Sourced + Jurisdiction Router)
Logging Pipeline — Kafka + Indexing Pipeline (Hot/Warm/Cold)
Logging Pipeline — Multi-Tier with Alerting & Distributed Query
Logging Pipeline — Naive (Direct-to-Database)
Logging Pipeline — Tiered Observability Platform
Multiplayer Game — Authoritative Server Architecture
Multiplayer Game Server — Authoritative Dedicated Server
Multiplayer Game Server — Global Competitive Platform
Multiplayer Game Server — Naive (Client-Hosted P2P)
Online Code Editor — Collaborative Editing with OT
Payment System — Idempotent Ledger + Saga (Kafka Orchestration)
Payment System — Multi-Region Distributed (Active-Active with Fraud ML)
Payment System — Naive (Single Service + SQL Transactions)
Payment System — Transaction Processing
Real-Time Chat — Multi-Region WebSocket Mesh + CRDT Receipts
Ride Hailing — Geo-Indexed Match (Redis GEO + Kafka)
Ride Hailing — Global Resilient (State Machine + Payment Saga + Multi-Region)
Search Autocomplete — Streaming Trending + ML Ranking
Ticketmaster — CDN Edge + Waiting Room
Ticketmaster — Naive (SELECT FOR UPDATE)
Ticketmaster — Per-Seat Redis Hold
Ticketmaster — Ticket Booking System
Twitter Feed — Hybrid Push+Pull (Whale-Aware)

Components

CDN
Geo-DNS
API Gateway
Rate Limiter
Load Balancer
Service
WebSocket Service
Worker
Stream Processor
Cache
Database
Object Storage
Event Stream

Concepts

Foundations

ACID vs BASE
CAP Theorem
Fallacies of Distributed Computing
Latency Numbers Every Engineer Should Know
Little's Law
PACELC Theorem
Reliability, Availability, and Durability

Networking & Protocols

CDN Architecture
DNS (Recursive, Authoritative, Anycast)
gRPC vs REST vs GraphQL
HTTP/1.1 vs HTTP/2 vs HTTP/3
L4 vs L7 Load Balancers
Load Balancing Algorithms
Long Polling vs Short Polling
TCP vs UDP
WebSockets

Storage

Document Stores (MongoDB)
Key-Value Stores (Redis, DynamoDB)
NewSQL (CockroachDB, Spanner, YugabyteDB)
Object Storage (S3, GCS)
Relational Databases (PostgreSQL, MySQL)
Search Engines (Elasticsearch, OpenSearch)
Vector Databases (pgvector, Pinecone, Milvus)
Wide-Column Stores (Cassandra, Bigtable, HBase)
B-Tree and B+ Tree
Bloom Filters and Cuckoo Filters
LSM Tree (Log-Structured Merge Tree)
LSM Tree vs B-Tree
Write-Ahead Log (WAL)
Leader-Follower (Primary-Replica) Replication
Leaderless (Dynamo-Style) Replication
Multi-Leader Replication
Quorums (R + W > N)
Replication Lag and Read-Your-Writes
Synchronous vs Asynchronous Replication
Consistent Hashing
Hash Partitioning
Hotspot Mitigation
Range Partitioning

Caching

Cache Stampede (Thundering Herd)
Cache-Aside (Lazy Loading)
Eviction Policies: LRU, LFU, ARC, TinyLFU
Tiered Caching (L1/L2/CDN)
TTL Strategies (Hard, Soft, Jittered)
Where to Cache: Client, CDN, Server, Database
Write-Back (Write-Behind) Cache
Write-Through Cache

Messaging & Streaming

Dead Letter Queues
Delivery Semantics
Idempotency Keys
Kafka Architecture
Ordering Guarantees
Outbox Pattern
Pub/Sub vs Message Queues
SQS, SNS & EventBridge
Windowing in Stream Processing

Consensus & Coordination

Distributed Locks
Gossip Protocol
Lamport Timestamps
Leader Election
Paxos
Raft Consensus Algorithm
Service Discovery
Vector Clocks

Consistency & Transactions

Database Isolation Levels
Eventual Consistency
Idempotency
Linearizability
Read-Your-Writes Consistency
Saga Pattern
Serializability
Snapshot Isolation
Two-Phase Commit (2PC)

Scalability Patterns

Auto-Scaling & Elasticity
Connection Pooling
Database Sharding
Horizontal vs Vertical Scaling
Read Replicas
Stateless Service Design

Reliability & Resilience

Bulkhead Pattern
Chaos Engineering
Circuit Breaker Pattern
Disaster Recovery (DR)
Graceful Degradation
Load Shedding
Multi-Region Deployment Strategies
Rate Limiting
Retry with Exponential Backoff and Jitter
Timeouts and Deadline Propagation

Observability

Alerting & On-Call
Distributed Tracing
Health Checks & Readiness Probes
Log Aggregation
OpenTelemetry
SLOs, SLIs & SLAs
Three Pillars of Observability

Security

API Security & Threat Modeling
Authentication vs Authorization
Encryption at Rest & in Transit
JWT & Token Design
OAuth 2.0 & OpenID Connect
Zero Trust Architecture

Performance

Back-of-Envelope Estimation
Capacity Planning
Latency vs Throughput
P99 & Tail Latency
CDN & Edge Caching
Load Testing & Benchmarking
Profiling & Flame Graphs

Architectural Patterns

Monolith vs Microservices
Saga Pattern
CQRS (Command Query Responsibility Segregation)
Event Sourcing
Hexagonal Architecture (Ports and Adapters)
Service Mesh
Strangler Fig Pattern

Cloud-Native

Containers & Docker
Infrastructure as Code
Kubernetes Orchestration
GitOps
Immutable Infrastructure
Serverless & FaaS
Service Discovery

Data Engineering

Batch Processing
ETL Pipelines
Stream Processing
Change Data Capture
Data Lake & Lakehouse
Data Partitioning & Shuffles
Exactly-Once Semantics

AI / ML Infrastructure

Model Serving & Inference
RAG Architecture
A/B Testing & Experimentation
Feature Stores
GPU Orchestration
ML Model Registry
Training Pipelines

Trade-Off Deep Dives

CAP Theorem Deep Dive
Consistency vs Availability
SQL vs NoSQL
Synchronous vs Asynchronous
Build vs Buy
Push vs Pull

Interview Toolkit

Clarifying Requirements
Communicating Trade-offs in Interviews
Cost Questions in System Design Interviews
Drawing System Design Diagrams
GenAI Curveballs in System Design Interviews
Interview Walkthrough: Chat System
Interview Walkthrough: News Feed / Timeline
Interview Walkthrough: RAG-Powered Search
Interview Walkthrough: Rate Limiter
Interview Walkthrough: Top-K / Trending Topics
Interview Walkthrough: URL Shortener
Numbers to Memorize for System Design
Self-Scoring Rubric for System Design Practice
The Four-Step System Design Framework

Benchmarks

Performance Comparison of the Top 5 System Design Templates
Cassandra vs DynamoDB at 1 Billion Writes

Compare Technologies

Caching

Redis vs Memcached

Messaging

Kafka vs RabbitMQ

Database

SQL vs NoSQL
PostgreSQL vs DynamoDB

API Design

REST vs GraphQL
gRPC vs REST

Architecture

Monolith vs Microservices
Event-Driven vs Request-Response

Traffic

CDN vs Load Balancer

Real-Time

WebSocket vs Server-Sent Events (SSE)

Compute

Kubernetes vs Serverless

Databases

PostgreSQL vs MySQL

Load Balancing

Nginx vs HAProxy

NoSQL Databases

Cassandra vs DynamoDB

Document Storage

MongoDB vs PostgreSQL JSONB

Object Storage

AWS S3 vs Azure Blob Storage

Analytics

ClickHouse vs Snowflake

System Design Simulation Platform