81 articles in applied systems › architecture scenarios.
Tech stack selection questions test whether you can reason about trade-offs rather than cargo-culting. Learn the framework for evaluating databases, languages, and infrastructure choices under interview pressure.
The full journey from keystroke to rendered page — DNS resolution, TCP handshake, TLS negotiation, HTTP request, server processing, and browser rendering pipeline.
Cost is a first-class design constraint at scale. Interviewers at senior levels expect you to reason about instance costs, data transfer fees, storage tiers, and the performance trade-offs that come with cost reduction.
Migrations in production fail when you try to do them all at once. Learn the patterns for zero-downtime migrations: strangler fig, dual write, expand-contract, and phased traffic splitting.
How to count active users in real time using sliding windows, HyperLogLog, and distributed counter aggregation while handling millions of concurrent heartbeats.
How large-scale systems perform schema changes, data migrations, and database switches without downtime using expand-contract, dual writes, and shadow reads.
Walk through the design challenge Netflix faced when limiting simultaneous screens per subscription plan, covering device identification, session tracking, distributed counting, and the race conditions that make this harder than it looks.
Design the backend for a high-concurrency limited-availability sale event, covering inventory locking, queue-based fairness, and surviving 100x normal traffic.
Graceful degradation is the practice of designing systems to remain partially functional when components fail. Learn the patterns, tradeoffs, and interview answers.
Design the like counter system and live-updating like button for Facebook posts, covering accurate counting at scale for high-profile posts, real-time push to all viewers, and the data consistency vs latency trade-offs that make it interesting.
How large-scale systems handle file uploads using presigned URLs, multipart chunked uploads, virus scanning pipelines, and CDN distribution.
What actually happens in the TLS 1.3 handshake: ClientHello, ServerHello, key exchange, certificate verification, and how both parties derive symmetric session keys without ever transmitting them.
Understand the system design behind short-video recommendation feeds like Instagram Reels and TikTok For You Page: the candidate retrieval, ranking pipeline, real-time signals, and feedback loops that decide which video plays next.
How OAuth 2.0 enables delegated authorization — Authorization Code flow, PKCE for mobile, token types, scope enforcement, and how OpenID Connect adds identity on top.
Understand the algorithms behind gzip, zstd, and LZ4 that compress files and network payloads, the entropy theory, dictionary-based compression, and why system designers must understand when to compress, when not to, and what the tradeoffs are.
How TCP delivers reliable, ordered byte streams: the three-way handshake, sequence numbers, flow control, congestion control, and why TCP behavior matters when designing distributed systems.
Understand the system design behind web-scale search: how Google crawls billions of pages, builds an inverted index, ranks results with PageRank and learning-to-rank models, and serves queries in under 200ms globally.
How Docker creates isolated containers using Linux kernel primitives: namespaces, cgroups, UnionFS layers, container networking modes, and what Docker does that the kernel does not.
Understand the WebSocket protocol: the upgrade handshake, bidirectional framing, connection lifecycle, and scaling challenges, plus when to pick WebSockets vs Server-Sent Events vs long polling for real-time features.
How Kubernetes orchestrates containers: control plane components, the scheduler, Pod lifecycle, service discovery, rolling deployments, and how it self-heals on node failure.
Redis handles data at microsecond latency using a single-threaded event loop, carefully tuned data structures, and flexible persistence. Here is what is happening under the hood.
How Kafka achieves exactly-once semantics with idempotent producers, transactions, epoch fencing, the difference from at-least-once, and what exactly-once actually guarantees versus what it does not.
How Elasticsearch indexes and searches text at scale: inverted indexes, shards and replicas, the scatter-gather query execution, BM25 relevance scoring, and near-real-time indexing mechanics.
How to run a truly active-active multi-region system, conflict resolution strategies, global load balancing, the latency vs. consistency trade-off, DNS failover, and what active-active really costs.
How to architect for extreme traffic spikes with pre-warming, autoscaling, circuit breakers, graceful degradation, and the pre-event runbook that keeps your site alive at 50x load.
HTTP/2 solves HTTP/1.1's head-of-line blocking with multiplexed streams, binary framing, HPACK header compression, and server push. Learn how these mechanisms work and when they actually help.
HTTP/3 replaces TCP with QUIC, a UDP-based transport that eliminates TCP head-of-line blocking, enables 0-RTT connection resumption, and supports connection migration when device IPs change.
Git stores everything as content-addressed objects: blobs, trees, commits, and tags. Understanding the object model, DAG structure, and ref mechanics explains why rebase, merge, and reset work the way they do.
Email delivery involves SMTP relay chains, MX record lookups, store-and-forward queuing, and authentication protocols (SPF, DKIM, DMARC). Understanding these explains why spam exists and why it's structurally hard to eliminate.
YouTube transcodes every uploaded video into multiple formats and bitrates using a parallel pipeline. Learn how adaptive bitrate streaming (DASH/HLS), codec tradeoffs (AV1 vs H.264), and CDN delivery combine to serve billions of hours of video daily.
Spotify's recommendation engine combines collaborative filtering (matrix factorization on listening history), NLP on playlist metadata, and audio analysis. Learn how Discover Weekly and Daily Mixes are generated at scale.
Google Maps combines rasterized and vector tile delivery, contraction hierarchy routing algorithms, and real-time probe data from Android phones to compute routes and traffic. Learn what's behind the blue line.
Online card payments flow through a chain of actors: cardholder, merchant, payment gateway, acquirer, card network, and issuer. Learn the authorize-capture split, why charge.succeeded fires before money moves, and what actually settles funds.
WhatsApp uses the Signal Protocol's Double Ratchet algorithm to provide end-to-end encryption with forward secrecy. Learn how X3DH key agreement bootstraps a session, why past messages stay safe even if keys are compromised, and what the key distribution problem is.
GitHub Actions runs CI/CD workflows on ephemeral VMs called runners. Learn how workflow triggers, runner registration, job execution, and artifact storage work, and the architectural difference between GitHub-hosted and self-hosted runners.
TikTok's For You Page uses video completion rate as its primary signal, feeds that into a real-time recommendation model, and bootstraps new users with trending content before personalization kicks in. Here's what's known about how it works.
Zoom delivers real-time video to hundreds of participants using a Selective Forwarding Unit (SFU) topology over DTLS-SRTP encrypted WebRTC streams. Learn the SFU vs MCU vs P2P choice, packet loss concealment, and how simulcast handles bandwidth variance.
Content moderation combines perceptual hashing (PhotoDNA) for known bad content, ML classifiers for new violations, and human review queues for high-confidence ambiguous cases.
Modern fraud detection combines a rule engine for known patterns, an ML ensemble for scoring novel transactions, and a real-time feature store for sub-100ms decisions. Learn the architecture behind Stripe Radar, PayPal, and bank card fraud systems.
P99 latency spikes in production almost always trace to a small set of causes: GC pauses, database lock contention, slow query plans, connection pool exhaustion, or downstream dependencies. Here's the systematic playbook.
Implementing GDPR's right to erasure requires more than deleting a database row. You also need to purge caches, search indexes, backups, derived data, and data shared with third parties. Here is the full pipeline.
How sports apps deliver sub-second score updates to millions of concurrent users using WebSocket fan-out, server-sent events, and intelligent client polling with delta compression.
How Discord uses WebRTC with a selective forwarding unit, Opus codec encoding, jitter buffers, and voice server routing to deliver low-latency group voice chat to millions of concurrent users.
How Uber's dispatch system uses geospatial indexing, supply-demand scoring, and the Hungarian algorithm to match riders to drivers in under 3 seconds.
How Netflix uses adaptive bitrate streaming, predictive prefetching, and Open Connect CDN appliances to deliver smooth video on degraded connections.
How Spotify pre-buffers the next track's first few seconds, applies gain normalization, computes the overlap window, and blends audio PCM frames for gapless playback.
How Slack uses WebSocket connections, channel fan-out, message ordering with Flannel, and graceful degradation when connections drop.
How GitHub's code search uses a custom Rust indexer, trigram indexes, and sharded search infrastructure to return results across all public repos.
How Notion uses operational transforms, block-level syncing, and optimistic local updates to keep documents consistent across multiple editors.
How LinkedIn combines creator affinity, engagement prediction, and diversity constraints to rank feed items using a two-pass scoring system.
How the Kubernetes scheduler filters and scores nodes using resource requests, affinity rules, taints, topology spread, and priority preemption to place pods optimally.
How Spotify uses predictive prefetching, Vorbis/AAC codec switching, local cache management, and crossfade buffering for instant playback.
How messaging systems maintain ordering guarantees using partition keys, sequence numbers, vector clocks, and causal ordering when total order is too expensive.
How real-time bidding, user profiling, contextual targeting, and auction mechanics determine which ad appears in your feed within 100ms.
How Airbnb uses optimistic locking, calendar availability checks, idempotent booking requests, and distributed coordination to prevent two guests from booking the same dates.
How APNs and FCM maintain persistent connections, handle token management, topic-based routing, and delivery confirmation for billions of daily notifications.
How Amazon calculates delivery promises using inventory location, fulfillment center proximity, carrier capacity, route optimization, and real-time demand signals.
How rate limiting uses token bucket and sliding window algorithms, communicates limits through HTTP headers, and scales across distributed API gateways with Redis counters.
How search autocomplete uses trie data structures, precomputed suggestion lists, personalization layers, and edge caching to return suggestions within 50ms of each keystroke.
How CDN cache invalidation uses TTL expiry, purge APIs, surrogate keys, stale-while-revalidate, and versioned URLs to keep edge caches consistent with origin servers.
How load balancers and orchestrators use connection draining to gracefully remove backend servers by completing in-flight requests before deregistering, preventing 502 errors during deployments.
How database clusters detect primary failures using heartbeats, promote replicas through consensus protocols, and redirect client connections to achieve automatic failover with minimal data loss.
How Stripe, PayPal, and bank APIs use idempotency keys, deduplication windows, and two-phase state machines to prevent double charges on network failures.
How ETL pipelines extract data from source systems, transform it through cleaning and enrichment stages, and load it into data warehouses using batch and streaming architectures.
How feature flag systems use consistent hashing, sticky bucketing, and gradual rollout percentages to safely ship features to a subset of users with instant kill-switch capability.
How a single viral post or celebrity login creates a hot key in Redis or DynamoDB, causing throttling cascades, and the techniques to distribute the load.
How Datadog and Elasticsearch-based pipelines collect, buffer, transform, and index logs from thousands of services using agents, Kafka, and tiered storage.
How apps check version compatibility, display blocking vs non-blocking upgrade prompts, and handle API versioning to support old and new clients simultaneously.
How Redis Cluster migrates hash slots between nodes during resharding: MIGRATING/IMPORTING states, live key migration, and how clients handle ASK redirects.
How APIs use client-generated idempotency keys with server-side deduplication windows to make retries safe for payments, orders, and state mutations.
How Twitter detects trending topics using streaming count-min sketches, time-decay scoring, and personalized trend ranking across geographic regions.
How Google Photos extracts visual embeddings from every photo at upload time, stores them in a vector index, and retrieves semantically similar images using approximate nearest-neighbor search.
How WhatsApp's typing indicator works: ephemeral signals, WebSocket delivery, presence coalescing, and why the indicator disappears after 3 seconds even if you keep typing.
How YouTube maintains accurate comment counts on videos with millions of comments using distributed counters, eventual consistency, and anti-spam reconciliation.
How Slack propagates read horizons, notification badges, and message state across mobile, desktop, and web clients using server-sent events and a per-device cursor model.
How Instagram schedules story expiry using time-to-live fields, delayed job queues, and CDN cache invalidation to remove content reliably at the 24-hour mark.
How GitHub broadcasts cursor positions and edit presence to collaborators using WebSocket channels, distributed pub-sub, and client-side reconciliation.
How TikTok tracks which videos you have already seen and filters them from the For You Page feed using Bloom filters, server-side impression logs, and session-scoped exclusion sets.
How Stripe's fraud scoring pipeline combines device fingerprinting, transaction velocity checks, geographic anomalies, and a real-time ML model to reject fraudulent charges before authorization.
How Apple's Jetsam memory pressure daemon ranks suspended apps by priority, RSS size, and foreground recency to reclaim memory without user-visible crashes.
How Twitter runs a real-time classifier on every reply using user reputation signals, text embeddings, and behavioral features to hide low-quality content before it reaches readers.