System Design

Abstract Algorithms

AbstractAlgorithms

Home>Learn>System Design

System Design

Practice requirements, topology, bottlenecks, tradeoffs, failure modes, and operational constraints as a design loop.

215

Resources

57h 44m

Total Learning Time

0/215

Completed

Start Learning

Choose your learning style

Multiple ways to learn the same concept. Pick what works best for you.

Choose your learning style

Recommended Articles

Here’s a fresh, high-impact system design topic that avoids overlap with the existing list:

System Design HLD Example: Proximity Service (Yelp/Google Places)

System Design HLD Example: Real-Time Leaderboard

System Design HLD Example: Collaborative Document Editing (Google Docs)

System Design HLD Example: Search Autocomplete (Google/Amazon)

System Design HLD Example: Video Streaming (YouTube/Netflix)

System Design HLD Example: News Feed (Home Timeline)

**The "Request Hedging" Pattern: Betting on Latency to Win Reliability**

System Design HLD Example: Distributed Cache Platform

System Design HLD Example: URL Shortener (TinyURL and Bitly)

Consistent Hashing

Change Data Capture Pattern: Log-Based Data Movement Without Full Reloads

System Design Databases: SQL vs NoSQL and Scaling

System Design Data Modeling and Schema Evolution: Query-Driven Storage That Survives Change

System Design: Designing a Financial Ledger with Double-Entry Constraints

System Design Message Queues and Event-Driven Architecture: Building Reliable Asynchronous Systems

System Design HLD Example: Distributed Job Scheduler

System Design Networking: DNS, CDNs, and Load Balancers

LLD for Movie Booking System: Designing BookMyShow

How to serve data at lightning speed | Caching Strategies (Redis/Memcached)

API Gateway vs. Load Balancer vs. Reverse Proxy: What's the Difference?

Backend for Frontend (BFF): Tailoring APIs for UI

Big Data Architecture Patterns: Lambda, Kappa, CDC, Medallion, and Data Mesh

Blue-Green Deployment Pattern: Safe Cutovers with Instant Rollback

Canary Deployment Pattern: Progressive Delivery Guarded by SLOs

Circuit Breaker Pattern: Prevent Cascading Failures in Service Calls

Data Pipeline Orchestration Pattern: DAG Scheduling, Retries, and Recovery

Dead Letter Queue Pattern: Isolating Poison Messages and Recovering Safely

Deployment Architecture Patterns: Blue-Green, Canary, Shadow Traffic, Feature Flags, and GitOps

Designing for High Availability: The Road to 99.99% Reliability

Feature Flags Pattern: Decouple Deployments from User Exposure

Strategy Design Pattern: Simplifying Software Design

Infrastructure as Code Pattern: GitOps, Reusable Modules, and Policy Guardrails

Lambda Architecture Pattern: Balancing Batch Accuracy with Streaming Freshness

Serverless Architecture Pattern: Event-Driven Scale with Operational Guardrails

Service Mesh Pattern: Control Plane, Data Plane, and Zero-Trust Traffic

System Design Sharding Strategy: Choosing Keys, Avoiding Hot Spots, and Resharding Safely

System Design: Designing an Autonomous AI Coding Agent (Devin at Scale)

System Design HLD Example: E-Commerce Platform (Amazon)

System Design HLD Example: Chat and Messaging Platform

System Design HLD Example: API Gateway for Microservices

System Design HLD Example: Distributed Rate Limiter

System Design HLD Example: Web Crawler

System Design HLD Example: Payment Processing Platform

System Design HLD Example: Hotel Booking System (Airbnb)

System Design HLD Example: Ride-Sharing (Uber/Lyft)

System Design HLD Example: File Storage and Sync (Dropbox and Google Drive)

System Design Interview Basics: A Beginner-Friendly Framework for Clear Answers

System Design HLD Example: Notification Service (Email, SMS, Push)

System Design Requirements and Constraints: Ask Better Questions Before You Draw

The Ultimate Guide to Acing the System Design Interview

BASE Theorem Explained: How it Stands Against ACID

How It Works: The Internals of Database B+ Tree Indexes

LLD for URL Shortener: Designing TinyURL

Types of Locks Explained: Optimistic vs. Pessimistic Locking

How do websites survive unexpected traffic spikes? | Load Balancing Explained

ID Generation Strategies in System Design: Base62, UUID, Snowflake, and Beyond

System Design: Complete Guide to Caching — Patterns, Eviction, and Distributed Strategies

System Design Core Concepts: Scalability, CAP, and Consistency

System Design Multi-Region Deployment: Latency, Failover, and Consistency Across Regions

System Design Replication and Failover: Keep Services Alive When a Primary Dies

What happens when a database gets too big for one server? | Database Sharding & Partitioning

Big Data 101: The 5 Vs, Ecosystem, and Why Scale Breaks Everything

Choosing the Right Database: CAP Theorem and Practical Use Cases

Data Warehouse vs Data Lake vs Data Lakehouse: Which One to Choose?

The Dual Write Problem: Why Two Writes Always Fail Eventually — and How to Fix It

Distributed Transactions: 2PC, Saga, and XA Explained

High-Level Design: Scaling a Concert Ticket Booking System under Flash Load

Understanding Consistency Patterns: An In-Depth Analysis

Apache Cassandra Architecture: When to Use, Pitfalls, and Performance Tuning

How OAuth 2.0 Works: The Valet Key Pattern

How SSL/TLS Works: The Handshake Explained

How Kubernetes Works: The Container Orchestrator

How It Works: Under the Hood of the Redis Single-Threaded Engine

How It Works: Thread Safety Internals of Java's ConcurrentHashMap

X.509 Certificates: A Deep Dive into How They Work

Understanding Inverted Index and Its Benefits in Software Development

The "Request Hedging" Pattern: Betting on Latency to Win Reliability