Skip to content
Algo-Science
Redis
Initializing search
Algo-Science.
Home
Getting Started
Courses
Free Resources
Algorithms
Monotonic Stack
Greedy Algorithms
Tree Algorithms
Mathematics for Problem Solving
Number Theory
Data Structures
Dynamic Programming
Graph Algorithms
Interview Prep
System Design
Quizzes
Cohort Curriculum
Low-Level Design
Misc
Algo-Science
Algo-Science.
Home
Getting Started
Courses
Courses
C++ for CP ↗
Monotonic Stack ↗
Greedy Algorithms ↗
Google Interview ↗
Free Resources
Free Resources
Maths for Beginners
Maths for Beginners
Shapes and Curves
Parameter Fixing
Sets and States
Chaining and Dependency
Sample Topics
Sample Topics
Generating Functions - Theory
Generating Functions - Practice
Golden Rules of Function Addition
Algorithms
Algorithms
Overview
Maths for Problem Solving
Maths for Problem Solving
Shapes & Curves
Shapes & Curves
Seeing Numbers as Curves
Difference Arrays - The Geometric Toolkit
When Shapes Survive - Function Addition
Parameter Fixing
Parameter Fixing
The Fixing Mindset
Fix the Equation
Fix the Structure
Fix the Group
Sets & States
Sets & States
Containers, Sets, and Operations
Defining States - The Art of DP
Chaining & Dependency
Chaining & Dependency
Thinking in Chains
Structural Chains
Chains in DP and Greedy
Advanced
Advanced
Matrix Exponentiation
Recursion
Recursion
Recursion vs Iteration
Recursion and Memory
Logical Recursion
Structural Recursion
Structural Recursion for NP Tasks
Fix and Count (Running Pointer)
Merge Sort & Running Pointers
Contribution Technique on Trees
Unified Theory of Traversal
Searching
Searching
Binary Search - Brainstorming Tasks
Binary Search - Implementation Variations
Binary Search - Practice Tasks
ICPC 2025 Online Round
Sorting
Sorting
Quick Sort
Stack
Stack
Stack Parenthesis
Graph Algorithms
Graph Algorithms
Dijkstra
Monotonic Stack
Monotonic Stack
Chains of Inequality
Chains of Inequality
From Chains to Stacks
The Four Variants
Beyond Inequality — Bitmask Chaining
The Monotonic Queue
The Monotonic Queue
Sliding Window Min/Max
Lifespan & Expiration
1D DP Optimization
Dual Queues with Two Pointers
Thinking in Histograms
Thinking in Histograms
Heights & Boundaries
Largest Rectangle in Histogram
The Contribution Technique
Matrix Elevations — 2D Histograms
Weighted Histograms
Greedy Stack Construction
Greedy Stack Construction
Remove K Digits
The Pop Budget
Lexicographic Subsequences
Cartesian Trees ⚠️ Advanced
Cartesian Trees ⚠️ Advanced
What Is a Cartesian Tree
Properties & RMQ Equivalence
Cartesian Tree DP
Convex Hull Trick ⚠️ Advanced
Convex Hull Trick ⚠️ Advanced
Lines as Candidates
The Geometric Eclipse
Beyond Lines — Li Chao Tree
Real-Time Processing ⚠️ Advanced
Real-Time Processing ⚠️ Advanced
Streaming Data
Real-Time Heatmaps
Advanced Integrations ⚠️ Advanced
Advanced Integrations ⚠️ Advanced
Offline Range Queries
2D Monotonic Queue
Cheat Sheet
Greedy Algorithms
Greedy Algorithms
The Greedy Mindset
The Greedy Mindset
What Is Greedy?
The Guess-and-Prove Workflow
When Greedy Fails
Classic Greedy Algorithms
Classic Greedy Algorithms
Huffman Coding
Dijkstra’s Shortest Path
Minimum Spanning Trees
Greedy Stays Ahead
Greedy Stays Ahead
Interval Scheduling
Coverage Problems
Left-Right Decisions
Exchange Arguments
Exchange Arguments
Sorting by Formula
Custom Comparators
Two-Phase Sorting
Assignment Problems
Structural Greedy
Structural Greedy
Sweep and Invariants
Greedy Construction
Priority Queue Greedy
Greedy with Undo ⚠️ Advanced
Greedy with Undo ⚠️ Advanced
The Undo Trick
Stock Trading
Advanced Sweep Patterns ⚠️ Advanced
Advanced Sweep Patterns ⚠️ Advanced
Decoupled Sweeps
CSES Stick Differences
Prefix-Suffix Sweeps
Block Compression
WQS Binary Search ⚠️ Advanced
WQS Binary Search ⚠️ Advanced
The Alien’s Trick
Connecting WQS, Undo, and Slope Trick
Slope Trick Intro
LP and Flow Connections
Advanced Graph-Based Greedy ⚠️ Advanced
Advanced Graph-Based Greedy ⚠️ Advanced
Conflict Graphs & Bipartite DSU
Implicit State Space Search
Greedy Tree Traversals
Mathematical Foundations ⚠️ Advanced
Mathematical Foundations ⚠️ Advanced
Greedoids, Matroids, and When Greedy Works
Antimatroids and Scheduling
Tree Algorithms
Tree Algorithms
The Tree Mental Model
The Tree Mental Model
Trees Are Recursive Structures
The Call Stack IS the Tree
Top-Down vs Bottom-Up
Subtrees vs Paths
The DFS Template
Tree Input Formats
Traversal Mastery
Traversal Mastery
Recursive Traversals
Iterative DFS
BFS Level Order
All Three in One
Morris Traversal
Bottom-Up Pattern
Bottom-Up Pattern
Postorder Template
Pair Return Pattern
Subtree Aggregation
LCA via Postorder
Top-Down Pattern
Top-Down Pattern
Preorder Template
Boundary and Views
Nodes at Distance K
Burning Tree
Prefix Sums on Trees
Step-by-Step Directions via LCA
Tree Construction
Tree Construction
Construct from Traversals
Serialize and Deserialize
Flatten to Linked List
BST from Preorder
Sorted Array to Balanced BST
Binary Search Trees
Binary Search Trees
Search, Insert, Delete
Validate BST with Range
Kth Smallest Inorder
Merge, Two Sum, Largest BST
Maximum Sum BST
Trees as a Thinking Lens
Trees as a Thinking Lens
Recursion Tree Visualization
Master Theorem as Tree
Search as Tree Traversal
Divide and Conquer Trees
Game Trees and Minimax
Trees in the Wild
Include-Exclude on Trees
Include-Exclude on Trees
Max Independent Set
Min Vertex Cover
Max Matching on Trees
Tree Coloring
Binary Tree Cameras
Tree DP
Tree DP
Subtree DP
Path DP
The Stack Connection
The Stack Connection
Stack as Ancestor Tracker
Monotonic Stack on Trees
Iterative DFS with State
Checkpoint — You're Interview Ready
Checkpoint — You're Interview Ready
Interview Graduation
Linearization ⚠️ Advanced
Linearization ⚠️ Advanced
Euler Tour and DFS Ordering
Subtree Queries via Flattening
Path Queries and RMQ
When to Linearize
LCA Deep Dive ⚠️ Advanced
LCA Deep Dive ⚠️ Advanced
LCA Postorder Review
Binary Lifting
LCA via Euler Tour and RMQ
Distance and Path Queries
Difference Arrays on Trees
Max Distance to Marked Vertices
Heavy-Light Decomposition ⚠️ Advanced
Heavy-Light Decomposition ⚠️ Advanced
Heavy-Light Decomposition
Centroid, DSU & Synthesis ⚠️ Advanced
Centroid, DSU & Synthesis ⚠️ Advanced
Centroid Decomposition
DSU on Tree
Virtual Tree
Classification Flowchart
Combining Techniques
Trees and Mathematics ⚠️ Appendix
Trees and Mathematics ⚠️ Appendix
Catalan Numbers and Trees
Prüfer Sequences and Cayley’s Formula
Tree Isomorphism via Hashing
Kirchhoff’s Matrix Tree Theorem
Mathematics for Problem Solving
Mathematics for Problem Solving
Foundations
Foundations
Algebra
Algebra
Expressions and Linear Equations
Quadratics — Factoring, Formula, and Completing the Square
Polynomials — Arithmetic, Roots, and Theorems
Systems of Equations and Inequalities
Algebraic Manipulations and Factoring Tricks
Functions and Sequences
Functions and Sequences
Functions — Domain, Range, and Composition
Exponents, Logarithms, and Radicals
Arithmetic and Geometric Sequences and Series
Telescoping, Recursion, and Advanced Series
Inequalities and Optimization
Inequalities and Optimization
Linear and Quadratic Inequalities
AM-GM, Cauchy-Schwarz, and Power Mean
Optimization Techniques and Functional Equations
Geometry Essentials
Geometry Essentials
Triangles, Angles, and the Pythagorean Theorem
Polygons, Area, and Circles
Coordinate Geometry
Trigonometry Basics
Complex Numbers, Vectors, and Matrices
Complex Numbers, Vectors, and Matrices
Complex Number Arithmetic
Polar Form, Exponential Form, and Roots of Unity
Vectors in 2D and 3D
Matrices, Determinants, and Inverses
The Problem-Solving Toolkit
The Problem-Solving Toolkit
Four Moves, Every Problem
Numbers Are Sets, Operations Are Everything
Bits Are Sets
Equations Are Constraints
Arrays Are Curves
Primes and Divisors
Primes and Divisors
Primality and Factorization
The Sieve of Eratosthenes
Counting and Summing Divisors
Sieve Variations
GCD, LCM, and the Euclidean Family
GCD, LCM, and the Euclidean Family
GCD and LCM as Set Operations
GCD Variations
Extended Euclidean and Bezout's Identity
Linear Diophantine Equations
Modular Arithmetic
Modular Arithmetic
The Rules of Modular World
Binary Exponentiation
Modular Inverse via Fermat's Little Theorem
Modular Inverse: General Case and Precomputation
Euler's Totient Function
Combinatorics and Structured Counting
Combinatorics and Structured Counting
Permutations, Combinations, and Identities
Computing nCr Under Mod
Stars and Bars
Catalan Numbers
Inclusion-Exclusion and Set Counting
Inclusion-Exclusion and Set Counting
The Inclusion-Exclusion Principle
Derangements
The Pigeonhole Principle
Coprime Counting and the Mobius Connection
Probability and Expected Value
Probability and Expected Value
Probability Basics for CP
Linearity of Expectation
Expected Value DP
Game Theory
Game Theory
Nim and the XOR Trick
Sprague-Grundy Theorem
Game Variations
Multiplicative Functions and Mobius
Multiplicative Functions and Mobius
The Language of Divisors
Multiplicative Functions
Dirichlet Convolution and Mobius Inversion
The Floor Staircase
Large Numbers: Miller-Rabin and Pollard's Rho
Linear Algebra for CP
Linear Algebra for CP
Matrix Exponentiation
The Tropical Semiring
XOR Basis and GF(2)
Polynomials and Transforms
Polynomials and Transforms
Polynomials as Counting Tools
Polynomials as Points: DFT and Roots of Unity
FFT: The Divide-and-Conquer Algorithm
NTT and Modular Convolution
FWHT and Bitwise Convolution
CRT, Burnside, and Synthesis
CRT, Burnside, and Synthesis
Chinese Remainder Theorem
Burnside's Lemma
Putting It All Together
Number Theory
Number Theory
Primes and Factorization
GCD, LCM, and Modular Arithmetic
Data Structures
Data Structures
Overview
Aggregate Queue
Dynamic Programming
Dynamic Programming
Introduction
Graph Algorithms
Graph Algorithms
The Graph Mental Model
The Graph Mental Model
Graphs vs Trees
Representations
DFS on Graphs
BFS on Graphs
Bipartiteness
Grid Graphs
Grid Graphs
Grids as Graphs
Flood Fill
Multi-Source BFS
Path Reconstruction
Topological Sort
Topological Sort
Kahn's Algorithm
DFS Topo Sort
Lexicographic Ordering
DP on DAGs
Counting Orderings
Union-Find
Union-Find
DSU Core
Dynamic Connectivity
Weighted DSU
DSU Applications
The Shortest Path Toolbox
The Shortest Path Toolbox
Dijkstra
When Dijkstra Breaks
Bellman-Ford
Floyd-Warshall
All-Pairs Applications
Resource Dimensions 💪
Resource Dimensions 💪
Resource Expansion Principle
Binary Resource
Bounded Integer Resource
Resource with Refueling
Hop Budget
Temporal & Parity Layers ⏰
Temporal & Parity Layers ⏰
Time-Dependent Edges
Non-Linear Wait
Parity Toggle Layers
Modular Layers
Reverse Time
Directional Momentum 🏎️
Directional Momentum 🏎️
0-1 BFS
Sliding Pieces
Direction and Momentum
Potential Functions
Mode-Switching 🚂
Mode-Switching 🚂
Two-Mode Graphs
Company Line Switching
Graph on Graph
Multi-Criteria
Product Graphs 👥
Product Graphs 👥
Two-Agent BFS
Two-Pointer Graph
Two-Source Combine
Collision Analysis
Implicit Virtualization 🧩
Implicit Virtualization 🧩
Arithmetic as Graph
Geometric Graphs
Set-Membership Graphs
Auxiliary Virtual Nodes
Parametric Search
Reverse Causality 🔍
Reverse Causality 🔍
Reverse BFS
Edge Necessity
Graph Reconstruction
Shortest Cycle
MST — Cut, Cycle, Beyond ⚠️ Advanced
MST — Cut, Cycle, Beyond ⚠️ Advanced
Kruskal's and Prim's
Cut and Cycle Property
MST Edge Queries
Virtual Nodes MST
SCC & 2-SAT ⚠️ Advanced
SCC & 2-SAT ⚠️ Advanced
Tarjan's and Kosaraju's
Condensation Graph
2-SAT
Reachability Analysis
Euler, Hamilton & Flow ⚠️ Advanced
Euler, Hamilton & Flow ⚠️ Advanced
Euler Circuits and Paths
De Bruijn Sequences
Hamiltonian Bitmask DP
Max Flow
Min Cut and Matching
Functional Graphs ⚠️ Advanced
Functional Graphs ⚠️ Advanced
Functional Graph Structure
Binary Lifting Successor
Cycle Detection
Interview Prep
Interview Prep
Google
Google
Aggregating Truncated Election Results
Converting Org Tree to Engineer-Only Graph
Trees & Graphs
Trees & Graphs
Overview
Delete a Tree
Remove Edges from Tree
Islands in a Tree
Walk Through Shadow Area
Find Largest Connected Graph
Validate Sequence of Numbers
Blind Robot in a Maze
Dynamic Programming
Dynamic Programming
Overview
Electoral Tie Analysis
How Many Ways Can the Party Win
Red Card Black Card Game
Swiss Gondolas
The Jumping Game
Painting Fence
Score Combinations in Football
System Design
System Design
Overview
Global Minimum on Network
Domain Name Scoring
Counting Rate of Events
Dashboard for Monitoring Slow Queries
Implement a TCP Stream
Implement an Aggregator
Find Top N Largest Files
Design a Large Scale Cache
Binary Search & Arrays
Binary Search & Arrays
Overview
Measuring Service Success
Binary Search in RLE List
Find Largest Subsequence of K Digits
Splitting Cakes
Longest Sequence After Substitution
Find Number in Sorted Array
Google Shopping Price Retrieval
Strings & Hashing
Strings & Hashing
Overview
Apply Refactor to Source Code
Transform a C-Style String
Implement a Swype Keyboard
Best Anagram Finder
Find Buddies in Strings
Contained Characters in Grouped String
Find Strings with Prefix
Stacks & Queues
Stacks & Queues
Overview
Calculate PnL for Stock Transactions
Building a Market Order Book
Processing Highway Toll Logs
Find Shortest Queue
Intervals & Scheduling
Intervals & Scheduling
Overview
Merge Calendar Intervals
Schedule Car Rentals
Supercomputer Schedule
Recursion & Backtracking
Recursion & Backtracking
Overview
Screen Pattern Lock
Plant Flowers in Neighborhood
Vegetable Garden
Geometry & Math
Geometry & Math
Overview
Maximum Boxes Cut by Line
Largest Rectangle from Points
Super Prime Cut Numbers
Validate Date from Three Numbers
Greedy & Optimization
Greedy & Optimization
Overview
Packetize Data Optimally
Optimal Fun Event Selection
Create a Match Maker
Winners of a Tournament
Parse Paginated Results
Elections with Partial Information
Media.net
Media.net
Overview
Waymo
Waymo
Validate Stack Sequences
Uber
Uber
Overview
DSA Questions
System Design (HLD)
LLD / Machine Coding
1-Month Roadmap
3-Month Roadmap
Microsoft
Microsoft
Overview
DSA Questions
System Design (HLD)
LLD / Machine Coding
1-Month Roadmap
3-Month Roadmap
Meta
Meta
Overview
DSA Questions
System Design (HLD)
LLD / Machine Coding
1-Month Roadmap
3-Month Roadmap
Amazon
Amazon
Overview
DSA Questions
System Design (HLD)
LLD / Machine Coding
System Design
System Design
Introduction
Networking
Networking
How Networks Work
How Networks Work
The Layered Model
Life of a Web Request
Transport Layer
Transport Layer
UDP
TCP
TCP vs UDP — How to Pick
Application Protocols
Application Protocols
HTTP & HTTPS
REST APIs
GraphQL & gRPC
Real-Time Communication
Real-Time Communication
Server-Sent Events
WebSockets
WebRTC
Load Balancing
Load Balancing
Why Load Balancing
Client-Side Load Balancing
L4 vs L7 Load Balancers
Algorithms & Health Checks
Scaling the Load Balancer
Failures & Regionalization
Failures & Regionalization
Regionalization & Latency
Retries & Idempotency
Circuit Breakers
Data Modelling
Data Modelling
How Databases Work
How Databases Work
Tables, Rows & the Relational Model
How Data Lives on Disk
B-Trees, LSM Trees & Hash Indexes
Schema Design
Schema Design
Entity-Relationship Modelling
Normalization
Denormalization
Choosing the Right Data Model
Choosing the Right Data Model
The Relational Model
Document & Key-Value Models
Wide-Column & Time-Series Models
Specialized Models
Replication, Consistency & Concurrency
Replication, Consistency & Concurrency
Replication Models
Consistency Models & CAP
Concurrency Control & Isolation Levels
Indexing & Query Performance
Indexing & Query Performance
Composite & Specialized Indexes
Query Patterns That Break at Scale
Partitioning & Sharding
Partitioning & Sharding
Partitioning
Sharding
Consistent Hashing & Resharding
Cross-Shard Queries & Hot Spots
Advanced Patterns
Advanced Patterns
Distributed Transactions
CQRS, Event Sourcing & Materialized Views
Schema Evolution
Real-World Case Studies — Data Modelling
Real-World Case Studies — Data Modelling
Social Media at Scale
Messaging & Real-Time
Infrastructure at Scale
Interview Cheat Sheet
API Design
API Design
API Protocols
API Protocols
The API Landscape
The Decision Framework
REST API Design
REST API Design
Resource Modeling
HTTP Methods and Idempotency
Request and Response Design
GraphQL
GraphQL
Why GraphQL Exists
Schema Design and Queries
N+1 Problem and Pitfalls
RPC and gRPC
RPC and gRPC
How RPC Works
gRPC and Protocol Buffers
Streaming Patterns
Common API Patterns
Common API Patterns
Pagination
Versioning and Compatibility
Filtering, Sorting, and Search
Async, Caching, and Concurrency
API Security
API Security
Authentication
Authorization and RBAC
Rate Limiting and Protection
API Case Studies
API Case Studies
Designing APIs for Interviews
APIs at Scale
Common Mistakes
Interview Cheat Sheet
Architecture Patterns
Architecture Patterns
Read-Heavy Systems
Read-Heavy Systems
The Read Bottleneck
Optimize Before You Scale
Read Replicas
Caching
Cache Failures
CDN and Edge Caching
Write-Heavy Systems
Write-Heavy Systems
Why Writes Are Harder
Vertical Optimization
Sharding for Write Throughput
Queues, Batching, and Load Shedding
Distributed Counters
Concurrency Control
Concurrency Control
Race Conditions
Transactions, Locks, and Optimistic Updates
The Reservation Pattern
Distributed Coordination
Saga vs 2PC
Push Architectures
Push Architectures
The Problem with Polling
SSE and WebSockets
Fan-out
Presence and Connection Management
Async Processing
Async Processing
Why Sync Breaks Down
Queue Architectures
Retries, Dead Letters, Poison Messages
Job Status and Progress
Scaling Workers
Distributed Workflows
Distributed Workflows
Why Multi-step Is Hard
Evolution of Solutions
Workflow Orchestration
Idempotency and Compensation
Large File Architectures
Large File Architectures
Why Large Files Break
Presigned URLs
Chunked and Resumable Uploads
Deduplication and Processing
Storage Tiers and Cost
Interview Cheat Sheet
Interview Cheat Sheet
Architecture Patterns Cheat Sheet
Pattern to Question Bridge
Infrastructure Stack
Infrastructure Stack
Redis — The Swiss Army Cache
Redis — The Swiss Army Cache
Data Structures and When to Use Each
Persistence, Replication, and Cluster Mode
Redis Patterns for System Design Interviews
PostgreSQL — The Relational Workhorse
PostgreSQL — The Relational Workhorse
MVCC and Concurrency Control
Indexing — B-tree, GIN, GiST, and When to Use Each
Partitioning, Replication, and Connection Pooling
MongoDB — The Document Store
MongoDB — The Document Store
The Document Model — When Documents Beat Tables
Sharding, Replica Sets, and Consistency
Aggregation Pipeline and Schema Patterns
Kafka — The Event Backbone
Kafka — The Event Backbone
Log-Structured Storage — Why Kafka Is Fast
Partitions, Consumer Groups, and Ordering Guarantees
Exactly-Once Semantics and Transactions
Kafka Streams vs Flink — When to Use Each
Elasticsearch — Search at Scale
Elasticsearch — Search at Scale
Inverted Index Internals — How Lucene Works
Relevance Scoring — BM25, Boosting, and Tuning
Sharding, Replicas, and Near-Real-Time Search
Cassandra and DynamoDB — Wide-Column at Scale
Cassandra and DynamoDB — Wide-Column at Scale
Partition Keys, Clustering Keys, and Data Locality
Tunable Consistency, Hinted Handoff, and Repair
Cassandra vs DynamoDB — Trade-offs and When to Choose
Message Queues and Stream Processing
Message Queues and Stream Processing
RabbitMQ vs Kafka vs SQS — Choosing the Right Queue
Delivery Guarantees and Idempotent Consumers
Flink, Watermarks, and Windowed Aggregation
API Gateways and Service Mesh
API Gateways and Service Mesh
API Gateway — Rate Limiting, Auth, and Routing
Kong vs Envoy vs AWS API Gateway
The Sidecar Pattern and Service Mesh
ZooKeeper, etcd, and Coordination
ZooKeeper, etcd, and Coordination
ZooKeeper — Ephemeral Nodes, Watches, and Leader Election
etcd, Consul, and Modern Alternatives
When You Need Coordination and When You Don't
OLAP and Data Warehousing
OLAP and Data Warehousing
OLTP vs OLAP — Why Column Storage Wins for Analytics
ClickHouse vs Redshift vs BigQuery vs Snowflake
ETL, ELT, and the Modern Data Stack
Observability — Prometheus, Grafana, and Tracing
Observability — Prometheus, Grafana, and Tracing
Metrics — Prometheus, Pull Model, and PromQL
Distributed Tracing — Jaeger, Zipkin, and the Dapper Model
Structured Logging and Alerting Pipelines
Solved at Scale
Solved at Scale
Short Links and Content Delivery
Short Links and Content Delivery
Design a URL Shortener
Design a Cloud File Sync Service
Design a Photo-Sharing Platform
Real-Time Messaging and Collaboration
Real-Time Messaging and Collaboration
Design an Encrypted Messaging Service
Design a Live Stream Comment System
Design a Channel-Based Chat Platform
Design a Collaborative Text Editor
Search, Discovery, and Geo
Search, Discovery, and Geo
Design a Social Search Engine
Design a Proximity Search Service
Design a Top-K Trending System
Design a News Aggregation Platform
Design a Geo-Based Matching Service
Design a Type-Ahead Suggestion Service
Marketplace and Transactions
Marketplace and Transactions
Design a Ticket Booking System
Design an Online Auction Platform
Design a Stock Brokerage Platform
Design a Payment Processing System
Design a Flash Sale System
Design a Calendar and Scheduling Service
Streaming and Media
Streaming and Media
Design a Video Streaming Platform
Design an Online Code Judge
Design a Fitness Activity Tracker
Design a Music Streaming Service
Infrastructure and Platform
Infrastructure and Platform
Design a Distributed Rate Limiter
Design a Distributed Cache
Design a Distributed Job Scheduler
Design a Web Crawler
Notifications and Fan-Out
Notifications and Fan-Out
Design a Social Feed System
Design a Multi-Channel Notification Service
Design a Price Alert Service
Analytics and Monitoring
Analytics and Monitoring
Design a Real-Time Click Aggregation Pipeline
Design a Metrics Monitoring Platform
Design a Ride-Sharing Platform
Design a Local Delivery Service
Design a Real-Time Leaderboard
Design a Real-Time Geospatial Heatmap
Distributed Mechanics
Distributed Mechanics
Consensus Algorithms
Consensus Algorithms
Raft — Leader Election, Log Replication, and Safety
Paxos and Multi-Paxos — Simplified
Vector Clocks, Lamport Timestamps, and Causal Ordering
Specialized Data Structures
Specialized Data Structures
Bloom Filters — Probabilistic Set Membership
HyperLogLog and Count-Min Sketch
Skip Lists — The Engine Inside Redis Sorted Sets
LSM Trees vs B-Trees — Write-Optimized vs Read-Optimized
Geo-Spatial and Temporal Systems
Geo-Spatial and Temporal Systems
Geohash, Quadtree, R-tree, S2, and H3 — A Comparison
Time-Series Databases — Storage, Compression, and Downsampling
Vector Databases — HNSW, IVF, and Similarity Search
Consistency and Replication Internals
Consistency and Replication Internals
CRDTs — Conflict-Free Replicated Data Types
Distributed Transactions — 2PC, 3PC, and Saga
Chain Replication and Alternatives
Distributed File Systems — GFS and HDFS
Operational Mechanics
Operational Mechanics
Distributed Tracing Internals — The Dapper Model
Traffic Control — Token Bucket and Leaky Bucket at Scale
Feature Flags and A/B Testing Infrastructure
Quizzes
Quizzes
Algorithms
Algorithms
Logical Recursion ↗
Structural Recursion ↗
Structural Recursion (NP) ↗
System Design
System Design
Introduction
Core Concepts
Core Concepts
Networking Essentials
API Design
Data Modeling
Database Indexing
Caching
Sharding
Consistent Hashing
CAP Theorem
Numbers to Know
Question Breakdowns
Question Breakdowns
Bit.ly
Dropbox
Local Delivery Service
News Aggregator
Ticketmaster
FB News Feed
Tinder
LeetCode
WhatsApp
Yelp
Strava
Rate Limiter
Online Auction
FB Live Comments
FB Post Search
Price Tracking Service
Instagram
YouTube Top K
Uber
Robinhood
Google Docs
Distributed Cache
YouTube
Job Scheduler
Web Crawler
Ad Click Aggregator
Payment System
Metrics Monitoring
Patterns
Patterns
Real-time Updates
Dealing with Contention
Multi-step Processes
Scaling Reads
Scaling Writes
Handling Large Blobs
Managing Long Running Tasks
Key Technologies
Key Technologies
Redis
Elasticsearch
Kafka
API Gateway
Cassandra
DynamoDB
PostgreSQL
Flink
ZooKeeper
Advanced Topics
Advanced Topics
Data Structures for Big Data
Vector Databases
Time Series Databases
Cohort Curriculum
Cohort Curriculum
Week 1 — Foundations
Week 2 — Recursion & Backtracking
Week 3 — Trees & Graphs
Week 4 — Dynamic Programming I
Week 5 — Dynamic Programming II
Week 6 — Advanced Graph Algorithms
Week 7 — Low Level Design
Week 8 — System Design & Interview Prep
Low-Level Design
Low-Level Design
OOP from Scratch
OOP from Scratch
Classes, Objects, Encapsulation
Inheritance vs Composition
Polymorphism and Interfaces
Abstract Classes vs Interfaces
Why Java for LLD
Why Java for LLD
Java Advantages
C++ and Python Toolkit
Design Principles
Design Principles
KISS
DRY and YAGNI
Separation of Concerns
SOLID Principles
SOLID Principles
Single Responsibility
Open/Closed
Liskov Substitution
Interface Segregation
Dependency Inversion
Interview Framework
Interview Framework
Anatomy of an LLD Interview
Scoping and Requirements
Entity Discovery and Demotion
The Orchestrator Pattern
Derive vs Track State
Misc
Misc
Translated Chinese Papers
Translated Chinese Papers
Composite Spherical Regions Algorithm
Notes on Cognitive Focus
About
Redis Quiz
Placeholder content for Redis Quiz
Back to top