Lock In &
Level Up

Distributing traffic across multiple servers to maximize throughput, minimize latency, and avoid overload. Covers algorithms: round-robin, least connections, IP hashing.

Relational vs non-relational databases — when to choose each, trade-offs in consistency, scalability, and schema flexibility.

Designing operations that can be safely retried without causing unintended side effects. Critical for payment systems, message queues, and distributed APIs.

Async communication via Kafka, RabbitMQ, SQS. Topics: pub/sub, dead letter queues, ordering guarantees, consumer groups, and backpressure.

Consistency, Availability, and Partition Tolerance — you can only guarantee two. Understanding CP vs AP systems and the PACELC extension.

API design principles: versioning, pagination, error handling, authentication patterns, rate limiting, and documentation best practices.

MapReduce, Spark, Flink, Kafka Streams. Lambda vs Kappa architecture. When to process data in bulk vs real-time event streams.

Cache-aside, write-through, write-behind, read-through. Where to cache: client, CDN, app server, DB. Cache invalidation and stampede problems.

Event-driven HTTP callbacks. Delivery guarantees, retry logic, signature verification, fan-out patterns, and webhooks vs polling vs SSE.

SLAs, the "nines" (99.9% vs 99.99%), redundancy, failover, health checks, circuit breakers, and designing for high availability across regions.

Horizontal partitioning by key, range, or hash. Hotspot problems, cross-shard queries, rebalancing, and the difference between sharding and partitioning.

Probabilistic data structure for membership tests. Space-efficient "maybe yes, definitely no" filter. Used in databases, CDNs, and duplicate detection.

Stateless services scale horizontally easily; stateful ones need sticky sessions or external state stores. Implications for microservices, k8s, and auth.

Paxos, Raft consensus, gossip protocols, vector clocks, two-phase commit (2PC), Lamport timestamps, and leader election algorithms.

Single entry point for microservices. Handles auth, rate limiting, routing, SSL termination, request aggregation, and observability (Kong, AWS API GW).

Forward proxy (client anonymity, filtering) vs reverse proxy (server protection, load balancing, caching). NGINX, HAProxy, and Envoy use cases.

Advanced: dynamic sharding, directory-based sharding, resharding without downtime, celebrity/hotspot problem, and global vs local indexes.

Real-time communication: polling, long-polling, SSE, WebSockets. Trade-offs in connection overhead, latency, scalability, and browser support.

Hash ring for distributing keys across nodes with minimal remapping when nodes join/leave. Virtual nodes for balance. Used in Cassandra, DynamoDB, Memcached.

Choosing between communication protocols: REST for simplicity, GraphQL for flexible queries, gRPC for performance, tRPC for type-safe TS full-stack.

Redis vs Memcached. Cache tiers (CPU L1-L3, app cache, distributed cache). Cache hit ratio, TTL, cold start, and thundering herd problem at scale.

Vertical (scale-up) vs horizontal (scale-out) scaling. Auto-scaling policies, database read replicas, stateless service scaling, and cost implications.

LRU, LFU, FIFO, MRU, Random, TTL-based. When to use each, implementation complexity, and how Redis implements these under the hood.

Choosing the right DB: OLTP vs OLAP, columnar stores, time-series DBs, graph DBs, full-text search. Replication, leader/follower, read replicas.

JSON Web Tokens for stateless auth. Header/payload/signature structure, signing algorithms (HS256 vs RS256), token refresh patterns, and revocation challenges.

Microservices vs monolith vs SOA. Service decomposition, inter-service communication, service discovery, circuit breakers, and service mesh (Istio).

Concurrency = dealing with multiple things at once; Parallelism = doing multiple things at once. Threads, goroutines, event loops, locks, deadlocks, race conditions.

Tracking and propagating DB changes in real-time using WAL/binlog. Tools: Debezium, Kafka Connect. Powers data sync, search indexing, cache invalidation.

Atomicity, Consistency, Isolation, Durability. Isolation levels (Read Uncommitted → Serializable), phantom reads, dirty reads, 2PL, MVCC, and BASE vs ACID.

Content Delivery Networks — edge caching, PoP servers, anycast routing, push vs pull CDN, cache purging, and using CDN for dynamic content.

Synchronous (blocking) vs asynchronous (non-blocking) communication. Callbacks, promises, async/await, event-driven architectures, and temporal coupling.

Token Bucket, Leaky Bucket, Fixed Window, Sliding Window Log, Sliding Window Counter. Distributed rate limiting with Redis. Choosing the right algorithm.

RESTful constraints: statelessness, uniform interface, HATEOAS, resource naming, HTTP methods/status codes, and REST maturity model (Richardson).

Protocol Buffers vs JSON, HTTP/2 vs HTTP/1.1, bidirectional streaming, code generation, browser support limitations, and performance benchmarks.

Designing for failure: circuit breakers, bulkheads, retries with exponential backoff, timeouts, graceful degradation, chaos engineering, and disaster recovery.