🏗System Design

System Design Articles

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

157 articles·Browse all topics

Start Here

The newest guide in this topic.

System Design

LLD Mastery: The Factory Design Pattern

Object creation is one of the most common actions in software development. However, spreading the new keyword throughout a codebase leads to tight coupling, making the system rigid and difficult to test. The Factory Patt…

Apr 27, 202612 min readIntermediateDeep Dive

#java#system-design

HLD & LLD Mastery Course

Read Article →

More System Design Guides

System DesignIntermediate

LLD Mastery: The Singleton Design Pattern

In object-oriented programming, some classes manage shared resources that must have exactly one coordinator. Examples include database connection pools, local cache registries, threads pools, and application configuratio…

Apr 27, 202613 min read

Deep DiveHLD & LLD Mastery Course

#java#system-design

System DesignIntermediate

LLD Mastery: The Strategy Design Pattern

Conditional statements (such as if-else or switch-case blocks) are the natural building blocks of branching logic. However, as business rules expand, embedding these conditionals within core service classes creates monol…

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 (TinyURL/Bitly)

Case Study: Design Uber (Ride-Hailing at Global Scale)

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

API Design: REST vs GraphQL vs gRPC — When to Use Each

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

Event-Driven Architecture: CQRS and Event Sourcing in Practice

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

Microservices Patterns: Circuit Breaker, Retry, Bulkhead, and Saga

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 a Real-Time 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