High-level and low-level design concepts with practical, interview-ready examples.
Architecture, scalability, data flow, infrastructure choices, and complete distributed-system designs.
Distributed event streaming, partitions, consumer groups, replication, and real-world use cases.
In-memory data store, data structures, persistence, caching patterns, pub/sub, and Lua scripting.
Distributed search engine, inverted index, shards, mappings, query DSL, and aggregations.
Probabilistic data structures for set membership — false positives, hash functions, and 15 design use cases.
Cassandra vs PostgreSQL vs DynamoDB — when to use each, trade-offs, consistency models.
Sharding, partitioning, write-ahead logs, CQRS, and strategies for write-heavy workloads.
Conditional writes, pessimistic and optimistic locking, serializable isolation, and temporary reservations.
Read replicas, caching strategies, CDNs, database indexing, and denormalization patterns.
When to use serverless functions vs container orchestration — cost, cold starts, scalability trade-offs.
Back-of-envelope estimation, latency numbers every engineer should know, throughput reference tables.
OSI model, TCP/IP, DNS, HTTP/HTTPS, load balancing, CDN, and common interview networking questions.
Processes vs threads, scheduling, memory management, deadlocks, and concurrency primitives.
Kafka-backed workflow orchestration, DAG-based job and subtask scheduling, isolated runners, live logs, secrets, retries, and 100K concurrent jobs.
WebSockets, Kafka fan-out, Cassandra message store, offline delivery, presence, and group chat at scale.
Event-driven microservices, order state machine, cart in Redis, real-time tracking, and background job patterns.
Fan-out on write vs read, celebrity problem, Redis sorted set timelines, Snowflake IDs, and ML ranking.
Pre-signed S3 uploads, HLS transcoding pipeline, CDN edge serving, adaptive bitrate, and view count at scale.
Task queues, Kafka fan-out, DAG workflows, exponential backoff, DLQ, idempotency, and real-world patterns.
Race conditions, Kafka partition serialisation, optimistic locking, Redis Lua atomicity, and auction-end edge cases.
No double booking via per-night Redis locks + DB CAS, one-row-per-night availability model, geo search with availability counter, and real-time multiplier-based pricing.
Recurring meetings as one RRULE row instead of infinite occurrences, a single nullable-date attendee table for per-occurrence add/remove and RSVP, and DST-safe expansion.
Fan-out to millions of subscribers, Kafka per-channel topics, APNs/FCM for mobile push, retry with exponential backoff, DLQ, and idempotency via Redis.
50M emails/day with urgent and bulk priority isolation, transactional outbox, crash recovery, idempotency, retries, DLQ, and multi-provider failover.
Real-time driver matching with Redis GEORADIUS, 600K GPS writes/sec, geohash spatial indexing, sequential driver offering, and live trip tracking via WebSockets.
Distributed seat locking with Redis NX, no double-booking under 10M concurrent users, Elasticsearch search, thundering herd queue, and idempotent bookings.
Real-time fan-out to millions of viewers, Redis channel-per-video, WebSocket delivery, Kafka spike buffering, and hot video scaling.
Distributed transactions across microservices — choreography vs orchestration, compensating transactions, and the outbox pattern.
Persistent bidirectional TCP, handshake, scaling with sticky sessions and Redis pub/sub, and 8 common production problems.
Interview-focused class design, object collaboration, design principles, and practical coding thought process.
Encapsulation, abstraction, inheritance, polymorphism, and composition with real-world examples and code patterns.
Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion with problem/solution patterns.
A 5-phase interview framework to organize requirements, entities, class APIs, edge cases, and trade-offs.
The 5 arrows, multiplicity, sequence and state diagrams, and the order to draw them in an interview.
One shared instance, controlled access, and interview trade-offs around global state and testability.
Use when replacing if/else logic with interchangeable behaviors.
Readable object creation with many optional fields plus centralized validation during construction.
Use when the concrete class depends on input and callers shouldn't know concrete types.
Add behavior by wrapping an object without changing its class or creating many subclasses.
Expose one simple interface that hides and coordinates a complex group of subsystems.
Use when multiple components need to react to a single event.
Use when behavior depends on current state and transition logic becomes messy.