HLD
High-Level Design
Architecting systems at scale — the design questions senior interviews lead with.
Prime Video HLD: The Transcoding Pipeline Behind Streaming Video
How a streaming service prepares video: splitting a master into segments, fanning out parallel transcode jobs across a segment-by-rendition matrix, progressive playability, and serving from the edge.
Mentorship Platform HLD: Matching Mentees to the Right Mentor
How a mentorship platform like Preplaced matches people: hard filters that remove the unqualified, a weighted skill-overlap score that ranks the rest, and the search-match-book architecture.
Topmate HLD: Booking Paid 1:1 Sessions Without Double-Booking
How a creator-session platform works inside: turning availability windows into bookable slots, the interval-overlap test that prevents double-booking, and the hold-pay-confirm flow.
Crypto Exchange HLD: The Double-Entry Ledger That Never Loses a Coin
How a crypto exchange tracks money correctly: a double-entry ledger where balanced transactions conserve value, overdrafts are impossible, plus hot/cold wallet custody and the deposit/withdraw flow.
ngrok HLD: Exposing localhost to the Internet With Reverse Tunnels
How a secure tunneling service works inside: the reverse tunnel that needs no open firewall port, stream multiplexing many requests over one connection, and subdomain routing at the edge.
Google Docs HLD: Operational Transformation for Real-Time Co-Editing
How Google Docs lets many people edit one document at once: why naive concurrent edits diverge, how Operational Transformation rewrites operations to converge, and the central-server OT architecture.
Gmail HLD: Storing Billions of Mailboxes and Threading Conversations
How an email service works inside: accept-fast ingestion, the shared message store plus per-user mailbox index, conversation threading by reply headers with union-find, and per-user search.
Alexa HLD: How a Voice Assistant Turns Speech Into Action
How a voice assistant works inside: the wake-word-to-speech pipeline, the NLU layer that resolves an utterance to an intent and slots, the thin-device cloud-brain split, and the skill fan-out.
GitHub's Data Model: How to Store Version History in a Database
Modelling version control in a database the way Git does: content-addressable blobs, trees and commits as a Merkle DAG, structural sharing of unchanged files, and the two-table schema that backs it.
AWS Lambda HLD: How Serverless Runs Your Code Without a Server
How a serverless platform works inside: the invocation path, cold versus warm starts, the scheduler that reuses execution environments, concurrency-limited autoscaling, and where latency goes.
NoSQL Internals HLD: The LSM Tree That Makes Writes Cheap
How a write-optimized NoSQL store works inside: the LSM tree (memtable, write-ahead log, immutable SSTables), the read path with bloom filters, compaction and tombstones, and LSM versus B-tree.
LinkedIn HLD: Degrees of Separation on a Billion-Edge Graph
A LinkedIn system design: the connection graph, degrees of separation via BFS, People You May Know ranked by mutual connections, why deep traversal is precomputed, and scaling the graph.
Tinder HLD: Mutual Matches, a Swipe Firehose, and a Fresh Deck
A Tinder system design: mutual-match detection that fires exactly once, the recommendation deck from a geospatial index, the swipe write firehose, privacy of one-sided likes, and scaling.
Zoom HLD: Why Video Calls Use an SFU, Not a Mesh
A Zoom / video-conferencing system design: mesh vs SFU vs MCU topologies, an SFU that uploads once and fans out, simulcast layer selection, signaling vs media, NAT traversal, and scaling rooms.
Dropbox / Google Drive HLD: Sync That Only Moves What Changed
A file sync system design (Dropbox / Drive): content-addressed chunks with dedup, delta sync that uploads only changed chunks, the metadata-vs-block split, and conflict handling.
AWS S3 HLD: Object Storage That Loses Nothing (Erasure Coding)
An AWS S3 system design: a flat bucket/key namespace, durability via erasure coding across AZs, the metadata index mapping keys to shards, multipart upload, and how object storage scales.
Load Balancer HLD: The Front Door That Never Sends You to a Dead Server
A load balancer system design: balancing algorithms (round-robin, least-connections, consistent hashing), health checks, L4 vs L7, and keeping the balancer itself from being a single point of failure.
Google Maps HLD: Fastest Route on a Planet-Sized Graph
A Google Maps system design: modelling roads as a weighted graph, A* routing with an admissible heuristic, precomputation for continent scale, live-traffic edge weights, and map tiles.
WhatsApp HLD: Real-Time Chat for Billions, Online or Off
A WhatsApp / chat-at-scale system design: persistent connections and a routing registry, store-and-forward for offline users, idempotent ordered delivery, and the delivery-tick receipts.
HackerRank CodePair HLD: Two People, One File, No Conflicts
A real-time collaborative editor design (CodePair / Google Docs-style): a sequence CRDT with fractional positions, converging concurrent edits over WebSockets, presence, and per-room scaling.
BitTorrent HLD: Downloading From Strangers, With No Server
A BitTorrent system design: splitting a file into hashed pieces, the peer swarm and tracker, rarest-first piece selection, tit-for-tat incentives, and why P2P scales up as demand grows.
Zerodha HLD: The Matching Engine at the Heart of a Stock Exchange
A stock exchange system design (Zerodha): a limit order book with price-time priority, the matching algorithm, an in-memory engine kept durable by a journal, and correctness over availability.
Amazon HLD: The Cart That Never Says No (Dynamo, Quorums, Merge)
An Amazon system design on the always-available shopping cart: AP over CP, a Dynamo-style replicated key-value store, quorums, consistent hashing, and merging divergent carts.
OYO / Airbnb HLD: Find Places Near Me, Free for My Dates
An Airbnb / OYO system design: geospatial search with geohash prefixes, date-range availability, booking without double-booking, the data model, and scaling location search.
Google Calendar DB Design: Store the Recurrence Rule, Not a Million Rows
A database deep dive on modelling Google Calendar: storing a recurrence rule instead of infinite instances, expanding on read, cancellations and overrides, timezones/DST, and time-range queries.
Spotify HLD: Streaming Audio That Starts Fast and Never Stalls
A Spotify system design: storing audio as a chunked bitrate ladder in object storage behind a CDN, adaptive bitrate selection from bandwidth and buffer, the metadata model, and play history at scale.
Stack Overflow HLD: Search Is the System, and It Isn't a SQL LIKE
A Stack Overflow system design: full-text search via an inverted index ranked by TF-IDF and votes, a read-heavy cache/CDN path, the Q&A data model, and keeping search in sync with the source of truth.
Cricinfo Live Score HLD: Serving One Hot Score to Millions of Readers
A live cricket score system design (Cricinfo-style): read fan-out to tens of millions, collapsing a hot key with caching and single-flight, push vs poll delivery, and freshness over consistency.
Reddit Comments DB Design: Modelling a Threaded Tree That Scales
A database deep dive on modelling Reddit-style threaded comments in SQL: adjacency list vs materialized path vs closure table, fetching a subtree in one query, plus scores and sharding by post.
Newsletter Service HLD: Fan Out a Million Emails Without Sending Twice
A newsletter service system design: fan a campaign out to millions of subscribers, the send-log idempotency key that stops double-sends, plus deliverability, retries, and open/click tracking.
Ad Click Aggregation HLD: Counting a Firehose Without Keeping It
An ad click event aggregation system design (HLD): tumbling windows, exactly-once counting by dedup, the Count-Min Sketch for fixed-memory counts, and stream processing with a batch recompute.
Real-Time Leaderboard HLD: Your Rank Among 50 Million, Instantly
A real-time leaderboard system design (HLD): why top-N is easy but a single player's rank is hard, the sorted set and order-statistics that make rank O(log n), time windows, and the hot-key at scale.
Twitter HLD: Fan-Out, the Celebrity Problem, and Merging a Timeline
A Twitter / X news feed system design (HLD): fan-out on write vs read, the celebrity problem, the push-pull hybrid, and assembling a timeline by merging K sorted streams at scale.
Ride Sharing HLD: Finding the Nearest Driver Without Asking All of Them
A ride sharing system design (Uber/Ola-style): the geospatial cell index that finds nearby drivers fast, the driver offer as a hold with a TTL, the double-match race, and surviving a hot region.
Movie Ticket Booking HLD: The Seat Hold Is the Whole System Design
A movie ticket booking system design (BookMyShow-style): the data model, a seat-hold with a TTL, stopping double-booking with an atomic update, and idempotent payment at scale.
A Rookie's Guide to HLD: Design Zomato with Nouns and Verbs
How to approach any high-level design interview: extract the data model and APIs from plain sentences — nouns, verbs, hidden tables — applied live to a Zomato-style food delivery system design.
Designing a Rate Limiter
The system design classic: where a rate limiter sits in your architecture, fixed window vs sliding window vs token bucket, going distributed with Redis, and a thread-safe core you can ship.