🏗System Design

System Design Articles

Architecture deep dives, scaling trade-offs, reliability patterns, and system design walkthroughs for backend engineers.

158 articles·Browse all topics

Start Here

The newest guide in this topic.

System Design

LLD Mastery: The Factory Design Pattern

1. What is the Factory Pattern? Mental Model > Connecting isolated components into a resilient, scalable, and observable distributed web. The Factory Pattern is a creational design pattern that provides an interface for…

Apr 27, 20268 min readIntermediateDeep Dive

#java#system-design

HLD & LLD Mastery Course

Read Article →

More System Design Guides

System DesignIntermediate

LLD Mastery: The Singleton Design Pattern

1. What is the Singleton Pattern? Mental Model > Connecting isolated components into a resilient, scalable, and observable distributed web. The Singleton Pattern is a creational design pattern that guarantees a class has…

Apr 27, 20268 min read

Deep DiveHLD & LLD Mastery Course

#java#system-design

System DesignIntermediate

LLD Mastery: The Strategy Design Pattern

1. What is the Strategy Pattern? Mental Model > Connecting isolated components into a resilient, scalable, and observable distributed web. The Strategy Pattern is a behavioral design pattern that lets you define a family…

System Design Articles

Start Here

LLD Mastery: The Factory Design Pattern

More System Design Guides

LLD Mastery: The Singleton Design Pattern

LLD Mastery: The Strategy Design Pattern

How HLD Translates to LLD

Introduction to High-Level Design

Case Study: Design an Elevator System

Case Study: Design Tic Tac Toe

Designing for 99.999% Availability: The Five Nines Blueprint

System Design Module 1: Introduction to Distributed Systems

System Design Module 3: Scalability Basics (Vertical vs Horizontal)

System Design Module 10: API Design & Rate Limiting

Bonus: The Ultimate System Design Cheatsheet

System Design: Designing a Distributed Cache (Redis)

System Design Masterclass: Designing a Distributed Lock Service (Chubby/Zookeeper)

System Design: Designing a Distributed Message Queue (Kafka)

Case Study: Design Instagram (Photo Sharing)

System Design Module 2: The Interview Framework (PEDAL)

Case Study: Design a Notification System

Case Study: Design a Payment System (Stripe/UPI)

Complete System Design Interview Preparation Roadmap

Case Study: Design a URL Shortener (Bitly)

Case Study: Design Uber (Ride-Hailing)

System Design: Designing Stateless Authentication

gRPC vs REST: The Decision-Maker's Guide for Backend Architecture

gRPC vs REST: A Decision-Maker's Guide for Backend Architecture

Pagination at Scale: Keyset vs Offset

API Pagination at Scale: Why OFFSET 100,000 is a Database Killer

API Rate Limiting at Scale: Redis-Based Strategies

Chaos Engineering for Data Infrastructure: Testing Distributed Resilience

Cloud-Native Databases: Why the Log is the Database

Consistent Hashing: The Secret Sauce of Distributed Scalability

Database Sharding Part 7: Case Study - Scaling Discord to Billions

Distributed Data Observability: Metrics That Actually Matter

Distributed Deadlock Detection: Wait-For-Graphs

Distributed Locking: Redis Redlock vs. Zookeeper vs. Database Constraints

Distributed Tracing Propagation: Mastering B3 and W3C Traceparent Headers

Distributed Transactions Part 1: The Death of ACID

Distributed Transactions Part 2: The Blocking Trap

Distributed Transactions Part 3: The Saga Pattern

Distributed Transactions Part 5: The Idempotency Layer

Distributed Transactions Part 7: Case Study - The Global Fintech Ledger

Backpressure Propagation: Designing Flow Control in Microservices

Bypassing the Kernel: User-Space Networking for Sub-Microsecond Performance

Distributed Garbage Collection: Managing References Across Networks

Distributed Snapshots: Chandy-Lamport Algorithm

HyperLogLog at Scale: Billion-Cardinality Estimation

Multi-Region DR: Warm Standby vs Active-Active

TLA+ for Backend Devs: Formally Verifying Distributed Systems

Graceful Degradation: Feature Shedding

gRPC Schema Evolution: Avoiding Breaking Changes

Kubernetes Networking: What Happens Between the Load Balancer and Your Pod?

Linearizability vs. Sequential Consistency: A Developer's Guide to Correctness

Beyond CAP: Why PACELC is the Real Rule for Distributed Databases

Beyond CAP: The PACELC Theorem for Distributed Databases

Multi-Tenancy in NoSQL: Data Isolation Strategies for SaaS

The Saga Pattern: Managing Distributed Transactions in NoSQL

Service Mesh Internals: How Envoy and Istio Manage the Mesh

Speculative Retries: The Google Approach to Solving Tail Latency

Stateless Auth: Managing JWT Blacklisting at Scale

System Design: Designing an Ad Click Aggregator

System Design: Designing Airbnb (Hotel/Home Booking)

System Design: Designing a Collaborative Editor (Google Docs)

System Design: Designing a Content Delivery Network (CDN)

System Design: Designing a Content Moderation System (Meta/TikTok Scale)

System Design: Data Partitioning and Sharding Strategies

System Design: Designing a Database Proxy for Sharding (Vitess Style)

System Design: Designing a Digital Wallet and Ledger System

System Design: Designing a Distributed BLOB Store (like S3/GCS)

System Design: Designing a Distributed File Lock (Zookeeper/Curator)

System Design: Designing a Distributed File System (HDFS/GCS Style)

System Design: Designing a Distributed ID Generator (Snowflake)

System Design: Designing a Local-First Key-Value Store (LevelDB/RocksDB)

Distributed Locking: The Danger of Fencing Tokens

System Design: Designing a Distributed Lock Manager

System Design: Designing a Distributed Logging System (TB/Day Scale)

System Design: Designing a Global Distributed Rate Limiter

System Design: Designing a Distributed Search Engine (Elasticsearch)