Learn how big systems really work.
Free system design interview preparation, from “what is a server” to designing a real product in an interview: lessons, animated step-by-step walkthroughs, code labs and timed exams, one phase at a time.
The system design course: 15 phases, 86 topics
Phase 0 · Start here
How the web works, where data lives, speed and size, staying up and the building blocks, in plain words.
- How the web works: What really happens when you tap a button in an app: clients and servers, requests and responses, DNS (Domain Name System: the internet’s phone book), round trips, HTTP (HyperText Transfer Protocol: the rules for writing web messages) methods, status codes and APIs (Application Programming Interfaces: the menu of requests a server understands), all shown on one small online tea shop.
- Where data lives: Memory versus disk, what a database is, tables, rows, columns and primary keys, indexes and queries, reads versus writes, and where photos and fast copies go.
- Speed and size: Latency (how long one request takes), throughput (how many finish per second), p50 and p99 (p = percentile: the typical and the slowest-1-in-100 request times), requests per second, peaks and storage, with plain numbers
- Staying up: What "down" costs a shop, how the nines (uptime targets such as 99.9%) turn a percentage into minutes, and how spare copies, zones (separate groups of buildings full of servers) and backups keep Chai & Co open and its orders safe.
- The building blocks: Load balancers, caches, CDNs, queues, replicas, shards (slices of the data kept on separate machines) and consistency (whether every copy shows the latest change): the names every design uses
Phase 1 · Fundamentals
Requirements, estimation and the vocabulary of scale.
- Scaling One App from 1 User to 1 Million (and Beyond): One Indian D2C store on NestJS + Postgres, taken stage by stage from a single VM to multi-region. Each stage gives the metric that forces the change, the change itself, what it costs or breaks, and a diagram.
- Scalability, Availability, Reliability, Latency & Throughput: The vocabulary of scale: how systems grow, how they fail, how to do availability math, and why p99 (not the average) decides your architecture.
- Capacity, Storage, Bandwidth & Peak Estimation: Guesstimates — quick, rounded maths that drives real design decisions: DAU → QPS → peak, storage over 5 years with replication, ingress/egress, cache memory, and server counts.
- Requirements & The Interview Framework: Turn a one-line prompt into scoped functional requirements, measurable SLO-style NFRs, an API contract and a 45-minute plan you actually control.
- OS & Kernel for Backend Engineers: Processes, Memory, I/O & the Durability Path: What the kernel is really doing under your NestJS service, Postgres and Redis: fork and copy-on-write, scheduling and CFS throttling, page faults and the OOM killer, file descriptors, epoll/io_uring, libuv, socket buffers, acceptor patterns with SO_REUSEPORT, and the full write() → fsync → device-cache → media path.
Phase 2 · Networking & Traffic
Protocols, real-time transports, gateways, mesh and load balancing.
- DNS, TCP/UDP, HTTP/1.1 → HTTP/2 → HTTP/3 & TLS: Where every millisecond of a request goes before your handler runs — and the connection-management bugs that page senior engineers at 3am.
- REST vs gRPC vs WebSockets vs SSE vs Long Polling: Pick the right transport, then make it survive scale: connection servers, pub/sub fan-out, heartbeats, backpressure, reconnect storms and C1M capacity.
- Reverse Proxy, Forward Proxy, API Gateway & BFF: The edge of your system: what each layer does, where cross-cutting concerns belong, how BFFs aggregate, and how gateways fail.
- Service Mesh: Service-to-Service Traffic: Sidecars, control vs data plane, mTLS identity, retries and circuit breaking in the mesh, traffic splitting, ambient/sidecarless — and when not to adopt one.
- Load Balancing: L4/L7, Algorithms, Consistent Hashing: How traffic is spread, why algorithms fail in surprising ways, consistent hashing with virtual nodes, health checks, LB tiers, long-lived connections and draining.
Phase 3 · Caching & CDN
Cache patterns, cache failure modes and global edge delivery.
- Caching Patterns, Eviction & Redis/Memcached: Why and where to cache, read/write patterns, eviction policies (with an LRU implementation), Redis data structures, persistence and Cluster, Memcached, and multi-level caches.
- Cache Invalidation, Consistency & Failure Modes: Invalidation strategies and races, stampede, penetration, avalanche, hot keys, warming, Redis down or full, stale local caches, fast-changing data, and debugging a hit-ratio drop.
- CDN, Edge Caching & Global Architecture: Push vs pull CDNs, HTTP caching headers, origin shield, purge vs versioned URLs, GeoDNS vs Anycast, multi-region routing, data residency and edge compute.
Phase 4 · Databases
Modeling, indexing, pooling, replication, sharding and DB firefighting.
- SQL Fundamentals: Joins, Query Execution Order, Normal Forms & Schema Design: Every join type on one tiny dataset, NULL traps, the logical order a SELECT is evaluated in, how Postgres actually executes it (nested loop / hash / merge), window functions, CTEs, 1NF→5NF on one evolving order sheet, deliberate denormalization, an interview-grade e-commerce schema and the classic SQL round problems.
- SQL vs NoSQL, Data Models, ACID & Isolation: Relational, document, key-value, wide-column, graph and time-series models; normalization trade-offs; transactions, ACID vs BASE; isolation levels, anomalies and MVCC; choosing a database.
- Indexing & Query Optimization: B-tree vs LSM vs hash vs GIN/GiST/BRIN, composite indexes and the leftmost-prefix rule, covering and partial indexes, reading EXPLAIN ANALYZE, finding slow queries, N+1 and DataLoader, keyset pagination, write amplification and timeouts.
- Connection Pooling, Lock Contention & Deadlocks: Why DB connections are expensive, sizing pools with Little's Law, the pods × pool explosion, PgBouncer modes, leaks and timeouts, backpressure, row/table locks, SKIP LOCKED, deadlocks and hot-row contention — plus the "connections exhausted" incident in depth.
- Replication, Read Replicas & Replication Lag: Single-leader, multi-leader and leaderless replication; sync vs async vs semi-sync; WAL streaming vs logical replication; read replicas and routing; read-your-writes and monotonic reads; failover, split brain; lag causes and fixes; why replicas do not scale writes.
- Partitioning, Sharding & Zero-Downtime Migration: Split data without splitting your team: shard keys, hot shards, cross-shard queries, resharding with logical shards, and moving a live table with no downtime.
- Database Firefighting: Six Production Scenarios: An on-call playbook: symptoms → diagnosis (real Postgres/MySQL queries and metrics) → fixes in order of cost, for the six database incidents interviewers love to ask about.
- Inside PostgreSQL: The Life of a Write and a Read: Postmaster and backends, the background workers, shared buffers and clock-sweep, heap page and tuple layout, TOAST, the WAL-before-data rule, full-page writes and torn pages, checkpoints and crash recovery, the commit path, the read path through planner, executor and visibility checks, and the tunables that matter when it hurts in production.
Phase 5 · Distributed Systems
Consistency, consensus, distributed transactions and concurrency.
- CAP, PACELC & Consistency Models: What "consistent" really means across replicas: CAP as a partition-time choice, PACELC for the normal case, the model hierarchy from linearizable to eventual, quorums, anti-entropy, and conflict resolution with CRDTs.
- Consensus, Leader Election & Time: How machines agree when networks lie and clocks drift: Raft in detail, Paxos intuition, etcd/ZooKeeper in practice, leases with fencing tokens, failure detectors, split brain, NTP vs TrueTime, and Lamport/vector/hybrid logical clocks.
- Idempotency, Distributed Transactions, 2PC & Sagas: Keeping money and orders correct across services: idempotency keys on both sides of every hop, 2PC and why it blocks, TC/C, sagas with compensations, transactional outbox + CDC, inbox dedup, the exactly-once illusion, and reconciliation.
- Concurrency, Locking & Distributed Locks: Race conditions, optimistic vs pessimistic locking, atomic ops, Redis/etcd locks, fencing tokens and deadlocks — the bugs that only show up at 3 AM under load.
- Data Systems Theory: System Models, Ordering, Encoding & Derived Data: The theory senior interviews probe without naming it: system models and fault types, safety vs liveness, the two generals and FLP results, state machine replication and why total order broadcast is consensus, Avro schema resolution and rolling upgrades, stream-table duality, the three kinds of stream join, "unbundling the database" with CDC and a log, the end-to-end argument for exactly-once, when Byzantine fault tolerance is worth it, and what modern data systems add.
Phase 6 · Messaging & Data Pipelines
Queues, Kafka, async failure modes and stream processing.
- Message Queues & Kafka Internals: Queues vs pub/sub vs logs, Kafka partitions, replication, ISR and acks, consumer groups, offsets, ordering and exactly-once — plus when RabbitMQ or SQS is the better tool.
- Async Processing Failure Modes: The production incidents of queue-based systems: slow APIs, 10× spikes, lag, crashes mid-message, duplicates, poison pills, ordering under retries, hot partitions and backpressure. For each one: symptoms, root cause, fix.
- Data Pipelines: Batch, Streaming & CDC: ETL vs ELT, batch vs stream, lambda vs kappa, windows, event time and watermarks, exactly-once checkpoints, CDC with Debezium, lakes vs warehouses, real-time dashboards and reconciliation.
Phase 7 · Reliability & Resilience
Resilience patterns, disaster recovery and rate limiting.
- Timeouts, Retries, Circuit Breakers & Bulkheads: How slow dependencies take down healthy services, and the resilience toolkit (deadlines, jittered retries, retry budgets, breakers, bulkheads, load shedding, hedging) that stops it.
- Redundancy, Disaster Recovery & Multi-Region: From availability math and backups to RPO/RTO tiers, multi-AZ vs multi-region, active-active conflicts, failover pitfalls, cells and chaos engineering — plus what to do when the DB, Redis, Kafka, an AZ or a whole region disappears.
- Rate Limiting & Throttling: Fixed window, sliding log, sliding window counter, token bucket and leaky bucket — implemented, compared and distributed across a fleet, with the headers, placement and fail-open/fail-closed decisions interviewers probe.
- Production Judgment: Avoiding Fallback, Constant Work, Queue Backlogs, Metastable Failures & Rollback-Safe Deploys: The senior-level instincts from the Amazon Builders' Library and metastable-failure research: why rarely-run code paths betray you, how constant-work designs remove modes, how queues fall into insurmountable backlogs, why outages outlive their triggers, and how to make every deploy reversible.
Phase 8 · APIs & Security
API design, evolution, testing, OAuth2/JWT and application security.
- API Design: REST, GraphQL & gRPC: Resource modeling, HTTP semantics, problem+json errors, cursor pagination, idempotency keys, ETags, bulk operations, GraphQL (DataLoader, cost limits, persisted queries), gRPC (protobuf, deadlines, streaming) and how to choose between them.
- API Versioning, Contracts & Testing: Evolving APIs without breaking consumers: semantic versioning, URI/header/media-type versioning, expand-contract, deprecation and Sunset, automated breaking-change detection, protobuf evolution, consumer-driven contracts with Pact, Testcontainers, and the strangler fig for monolith APIs.
- API Authentication, Authorization & Threat Modeling: OAuth2 grants, PKCE, JWT validation and revocation, opaque tokens, OIDC, mTLS, scopes vs fine-grained authz, STRIDE and the OWASP API Top 10
- Application Security, Secrets & Multi-Tenancy: TLS, envelope encryption with KMS, password hashing, secrets management, RBAC/ABAC/ReBAC, tenant isolation with Postgres RLS, injection/XSS/CSRF/SSRF, layered DDoS defence and zero trust
- Authentication Building Blocks: Sessions vs Tokens, SSO (SAML & OIDC), 2FA/TOTP, JWT vs PASETO & API Keys: Where session state lives, the five ways to authenticate a REST call (incl. SigV4-style HMAC signing), API-key lifecycle, SSO end to end with SAML and OIDC, single logout, TOTP math, passkeys, PASETO and auth for a multi-app company
Phase 9 · Platform & Operations
Search, observability, microservices, deployment and object storage.
- Search Systems & Elasticsearch: Inverted indexes, analyzers, BM25 relevance, autocomplete, fuzzy matching, CDC indexing pipelines, zero-downtime reindexing and cluster sizing.
- Observability: Logs, Metrics, Traces & SLOs: Structured logs, Prometheus metrics, OpenTelemetry traces, sampling, cardinality, SLOs, error budgets and burn-rate alerting, plus how to debug a 20-service system at 3am.
- Microservices Architecture & Monolith Migration: Monolith vs modular monolith vs microservices, DDD boundaries, data ownership, sync vs async, CQRS, event sourcing, strangler fig migration and the distributed-monolith trap
- Deployment, Kubernetes & Release Strategies: Images, probes, resources, autoscaling, canaries, feature flags, graceful shutdown and zero-downtime migrations — how code actually reaches production safely
- Object & File Storage: Block vs file vs object, S3 internals (data/metadata split, placement, erasure coding, checksums), multipart & presigned uploads, resumable uploads, dedup, lifecycle tiers, CDN delivery and video streaming.
- Key Technology Deep Dives: DynamoDB, Temporal & ZooKeeper: Three technologies interviewers love to probe once you name them: DynamoDB (keys, single-table design, GSI vs LSI, partition limits, transactions, DAX, Streams, global tables), Temporal durable execution (workflows vs activities, deterministic replay, versioning, history limits, when it beats saga + outbox), and ZooKeeper (ZAB, znodes, one-shot watches, recipes, and why Kafka and Kubernetes moved to KRaft and etcd).
- AI/LLM Fundamentals for Engineers: Transformers, Fine-tuning vs RAG vs LoRA, and Agent Protocols: The fundamentals underneath every LLM system design: tokens and BPE (and why Hindi or Tamil text costs more), embeddings and cosine similarity, the Transformer and self-attention worked through with real numbers, decoder-only generation and sampling, why long context is expensive, training vs fine-tuning vs inference, prompt engineering vs RAG vs fine-tuning, full fine-tuning vs LoRA vs QLoRA with parameter and memory arithmetic, evaluation basics, MCP vs A2A, and when an agent framework beats a plain loop.
Phase 10 · Production Problem → Solution
Senior-level incident scenarios and the architecture that fixes them.
- Incidents I: Slowness & Data-Layer Pain: War-room playbooks for slow systems: databases, connection pools, N+1, caches, Redis outages and a blocked Node event loop — symptoms, first 5 minutes, fixes, and the interview answer.
- Incidents II: Scale & Growth: Traffic 10× and 100×, hot servers and hot shards, read/write saturation, replication lag, sharding and zero-downtime migrations, global latency, static content, big uploads and millions of jobs
- Incidents III: Async, Dependencies & Resilience: Growing queues, slow and crashing consumers, duplicates, ordering, retries and retry storms, unavailable or slow downstreams, circuit breakers, cascading failures and noisy tenants
- Incidents IV: Correctness, Regions & Operability: Duplicate payments, races, deadlocks and locks; consistency choices; AZ and region failures, DR; sudden latency, bad deploys, tracing; slow and stale search
- Real-World Dissections: Famous Architectures & Outages, Explained: Twelve primary-source case studies (GitHub, Discord, Uber, Hotstar, Slack, Cloudflare, AWS, Meta, Figma, Notion), each told as context, timeline, root cause, what changed, lessons, and how to cite it in an interview
- Architecture Evolution Stories: Airbnb, Netflix & Shopify: Three companies hit the same growth wall and gave three different answers: layered SOA, cloud microservices behind a gateway, and a deliberately modular monolith split into pods. Each story is told stage by stage (trigger, constraint, decision, cost, lesson) from primary sources, then turned into a staged plan for a NestJS monolith
Phase 11 · Complete System Designs
End-to-end case studies from classic to advanced.
- The Recurring Patterns: Recognise the Problem Shape, Pick the Solution Ladder: Seven problem shapes cover most design prompts. Learn the phrases that reveal each one, the ladder of solutions from simple to advanced, the numbers at which each rung breaks, and where the app already works each pattern end to end.
- Classic Designs: URL Shortener, Pastebin, KV Store, Unique IDs & Notifications: The warm-up designs every interviewer reaches for — walked end-to-end with the 4-step framework, real numbers, and the deep dives that separate senior from mid-level.
- Location Systems: Proximity Service, Nearby Friends, Google Maps & Uber: Geospatial indexing, real-time location fan-out, map tiles and routing, and ride-hailing dispatch — the designs where "where is it?" meets "how fast can I answer?".
- Social & Media: Chat/WhatsApp, News Feed (Twitter/Instagram) & YouTube/Netflix: Real-time messaging with ordering and receipts, feeds that survive celebrities, and video pipelines that transcode, stream and count at planetary scale.
- Infrastructure Systems: Distributed Message Queue, Metrics Monitoring, Ad Click Aggregation, Job Scheduler & Logging Platform: Designing the systems other systems stand on — a Kafka-like log, a time-series monitoring stack, an exactly-once click pipeline, a distributed scheduler, and a log platform with tiered storage.
- Commerce & Money: Hotel/Ticket Booking, E-commerce, Payment System & Digital Wallet: Five end-to-end case studies where a wrong answer costs real money: inventory that must never oversell, seats held under flash-sale load, carts that turn into orders, payments that must happen exactly once, and wallets that must balance to the paisa.
- Storage Systems: Dropbox/Google Drive, Distributed Email & Distributed File System: Three case studies about keeping user bytes safe at petabyte scale: file sync with block-level dedup and delta sync, a Gmail-scale email service, and a GFS/HDFS-style distributed file system with leases and replication.
- Advanced: Leaderboard, Stock Exchange, Distributed Cache, Global Rate Limiter, Search Engine/Typeahead, Ad Serving, Recommendation System & Multi-tenant SaaS: Eight senior/staff-level case studies, each crisp but deep: Redis sorted-set leaderboards, a microsecond matching engine, a sharded cache tier, rate limiting across regions, typeahead and web search, real-time ad auctions, multi-stage recommenders, and tenant isolation in SaaS.
- Real-time, Media & AI: Live Streaming (Hotstar/Twitch), Video Conferencing (Zoom/Meet), ChatGPT-style LLM Service & Google Docs: Four designs interviewers added to their rotation in 2024–2026: one-to-50-million video fan-out, sub-150 ms group calls, GPU-bound token streaming, and convergent real-time co-editing.
- More Classics: Web Crawler, Top-K / Trending, Distributed Counters (Likes & Views), Online Judge (LeetCode) & Online Auction (eBay): Five designs that interviewers keep asking and that test different muscles: politeness and dedup at web scale, streaming heavy hitters with sketches, counting under extreme write contention, running untrusted code safely during a contest spike, and strongly consistent bidding against a deadline.
- Consumer & Marketplace: Flash Sale (Big Billion Days), Price Tracker & Alerts (CamelCamelCamel), Tinder, News Aggregator (Google News) & Strava: Five consumer designs that each hide one hard problem: selling 50K units to 5M people in a minute without overselling or rewarding bots, matching millions of price rules without spamming anyone, detecting a mutual like exactly once, turning 3M articles a day into a few hundred stories, and timing an athlete over a GPS trace that never lies on the segment.
- Platform, Fintech & AI: Robinhood-style Brokerage, CI/CD Runner (GitHub Actions), Online Chess Server, Calendar & Scheduling (Google Calendar / Calendly) & RAG Document Q&A: Five designs that interviewers moved into their loops in 2025–2026: a retail brokerage that must stay correct at the opening bell, a CI platform that runs strangers' code fairly and safely, a real-time game server where 300 ms decides a game, a calendar where time itself is the hard part, and an enterprise "chat with your docs" system where retrieval, not the LLM, decides quality.
- Instagram & Food Delivery (Swiggy / Zomato / DoorDash): Two of the most-asked product designs, taken past the generic building blocks: Instagram's media pipeline, ranked feed, Stories, Explore and celebrity-scale engagement; and a three-sided food-delivery marketplace with serviceability, an idempotent order state machine, dispatch with batching, ETA promises, delivery fees and peak-hour failure handling.
- AI Agents & LLM Apps: Agent Loops, Tools/MCP, Agentic RAG, Security, Evals & Troubleshooting: The 2026 "AI system design" round: build agents as distributed systems with budgets, validated tools, durable steps, least privilege and evals, then debug them when they are slow, wrong, stuck or expensive.
Phase 12 · Low-Level Design (LLD) & Machine Coding
From HLD to classes: OOP, SOLID, patterns, concurrency, the LRU cache and classic LLD rounds.
- From HLD to LLD: The Bridge & The Machine-Coding Round: How HLD (high-level design) and LLD (low-level design) rounds differ and connect, the requirements → entities → class diagram → interfaces → patterns → concurrency → extensibility flow, a URL shortener taken from boxes to TypeScript classes, and how Indian product companies run and score 60–90 minute machine-coding rounds.
- OOP, SOLID & Modelling for LLD: The four pillars used for protecting invariants rather than as textbook vocabulary, composition over inheritance, interfaces vs abstract classes in TypeScript and Java, every SOLID principle as violation → fix, UML relationships in ASCII, cohesion and coupling, value objects and aggregates, and designing for testability with NestJS providers.
- Design Patterns & Concurrency for LLD: The thirteen patterns that actually appear in LLD and machine-coding rounds, each with when to use it, idiomatic TypeScript and the trap interviewers set, plus how to make an in-memory design safe under concurrency, from one event loop to worker_threads to many pods.
- LRU Cache: Implementation & The Follow-up Ladder: The most-asked LLD question, done properly: where an LRU sits in a real system, the hash map + hand-written doubly linked list with sentinels and its pointer moves, a generic TypeScript implementation and how to test it. Then every rung of the follow-up ladder: weight, TTL, thread safety, O(1) LFU, scan resistance, pluggable policies, stats, listeners, write-back and distribution.
- LLD Case Studies I: Parking Lot, Elevator, BookMyShow & Splitwise: The four most-asked machine-coding problems in Indian product companies, each done the way a strong senior does it: requirements and a thin HLD first, then entities, an ASCII class diagram and the patterns that earn their place, then the hard core in TypeScript (spot allocation and slab pricing, LOOK scheduling with State, TTL seat holds that survive many pods, debt simplification), concurrency, extensibility probes and a 90-minute build plan.
- LLD Case Studies II: Rate Limiter, In-memory Pub/Sub, Task Scheduler & a Game (Snake & Ladder / Chess): Four machine-coding favourites done HLD → LLD: a pluggable rate-limiter library, a Kafka-lite pub/sub with consumer groups, offsets, retries and a DLQ, a heap-based task scheduler with cron, retries and misfire handling, and Snake & Ladder with the Chess pivot — plus how to time-box the 90 minutes.
Phase 13 · Miscellaneous: Interview Question Bank
Rapid-fire and deep-dive questions on the Tier 1 and Tier 2 concepts interviewers ask most in 2026.
- HTTP, DNS, Real-time Transports, Sessions & Auth: A question bank over the web plumbing every backend interview touches: HTTP/1.1 to HTTP/3, DNS, WebSockets and SSE, cookies and sessions, JWTs, refresh tokens and the authN/authZ split. Fresh angles only.
- Load Balancing, Gateways, Rate Limits, CDN & Multi-tenancy: A question bank on the traffic edge: balancing algorithms, L4 vs L7, draining, consistent hashing, gateways, rate limits, CDN caching, multi-tenancy and noisy neighbours — fresh angles, real reported questions, sharp distractors.
- Caching, Redis & Cache Failure Modes: Question bank: caching trade-offs, Redis internals, Redis Cluster vs Sentinel failover mechanics, stampede, penetration, avalanche, hot keys, warming and stale-while-revalidate — fresh angles for 2026 loops.
- Indexes, Pools, Replication, Sharding, Transactions & Migrations: Question bank: fresh angles on indexing, connection pooling, replication, read replicas, sharding, partitioning, transactions, isolation levels, schema evolution and zero-downtime migrations — with Postgres vs MySQL differences called out.
- Consistency, Consensus, Locks, Sagas & Event-driven Patterns: Question bank: consistency models, CAP, quorums, leader election, Raft, distributed locks, fencing tokens, idempotency, sagas, CQRS and event sourcing. New angles on concepts the deep-dive topics already teach.
- Queues, Kafka & Resilience Patterns: Question bank: queues vs logs, Kafka partitions and the KIP-848 rebalance protocol, lag that lies, DLQ redrive, the real scope of exactly-once, retry budgets, deadlines, breakers, backpressure, shedding and degradation ladders.
- Microservices, Observability, SLOs, Releases & Disaster Recovery: Question bank: service boundaries, telemetry that works during a disaster, percentile maths, SLI/SLO/SLA contracts, error-budget policy and burn-rate alerts, canaries, feature flags, Multi-AZ, multi-region and DR drills. New angles only, no repeats of the deep-dive topics.
Phase 14 · Behavioural & Hiring-Manager Round
STAR stories, Amazon Leadership Principles, bar raiser and senior scenarios: the rounds that decide the level and the offer.
- The Behavioural Round: Signals, STAR & Your Story Bank: What behavioural and hiring-manager interviewers actually score, how your answers set your level (SDE-2 vs Senior vs Staff), STAR/STARL/CARL done well, quantified impact, a story bank built from a backend career, the project deep-dive, and the India-specific HM topics: notice period, buyout, counter-offers and compensation.
- Amazon Leadership Principles & The Bar Raiser: All 16 LPs decoded for a backend engineer: how the loop and the Bar Raiser work, how answers are scored at SDE-2 vs SDE-3, example STAR stories, the follow-up drill-down and the traps
- Senior Behavioural Scenarios: Conflict, Failure, Incidents, Influence & Mentoring: The twelve high-frequency senior prompts (design disagreements, incidents you owned, missed deadlines, scope pushback, tech debt, cross-team influence, mentoring, ambiguity, pressure, difficult teammates, tough feedback and decisions on incomplete data), each with the signal, the trap and an example STAR answer from a backend engineer’s world.
Company-wise system design interview questions
Real questions from Google, Amazon, Meta, Microsoft, Apple, Netflix, Uber, Airbnb, Stripe, LinkedIn, Atlassian, Salesforce, Adobe, Walmart Global Tech, Flipkart, Swiggy, Zomato, Razorpay, PhonePe, Paytm, CRED, Meesho, Zepto, Goldman Sachs, with guided walkthroughs.
Shorts
Two-minute animated system design stories from real companies, each ending in one question.