Backend Developer Interview Guide: Concepts, Scenarios & System Design
Use this backend developer interview guide to prepare APIs, databases, caching, distributed systems, production scenarios, and system design.
Structured learning path
Follow this series from the first concept to the final deep dive. Every article is arranged in the recommended reading order.
Start with article 1Your path
88 focused lessons
Use this backend developer interview guide to prepare APIs, databases, caching, distributed systems, production scenarios, and system design.
Learn client-server architecture for backend interviews: request flow, tiers, state, scaling trade-offs, and production failure points.
What is a REST API? Learn resource design, HTTP semantics, idempotency, and the interview answers backend engineers need.
Master HTTP methods for backend interviews: GET, POST, PUT, PATCH, and DELETE semantics, retries, caching, and API design trade-offs.
Master HTTP status codes for backend interviews: 200, 201, 400, 401, 403, 404, 409, 429, 500, and 503 with API examples.
Learn stateless vs stateful architecture for backend interviews: where state lives, scaling trade-offs, sessions, Redis, and failure recovery.
Master authentication vs authorization for backend interviews, including 401 vs 403, sessions, JWTs, API checks, and permission models.
Learn how JWT works for backend interviews: header, payload, signature, expiry, validation, key rotation, and API security pitfalls.
Learn API gateway architecture for backend interviews: routing, authentication, rate limiting, aggregation, failure handling, and trade-offs.
Learn API rate limiting for backend interviews: fixed and sliding windows, token bucket, Redis atomicity, 429 responses, and trade-offs.
Learn idempotency in REST APIs for backend interviews: idempotency keys, retries, race conditions, response replay, and duplicate-payment prevention.
Compare offset, cursor, and keyset pagination for backend interviews: performance, consistency, indexes, API contracts, and trade-offs.
Learn webhooks for backend interviews: delivery flow, retries, HMAC signatures, replay protection, idempotency, queues, and failure handling.
Learn what CORS is for backend interviews: browser origins, preflight requests, credential rules, safe headers, and production debugging.
Compare API gateways, load balancers, and reverse proxies for backend interviews: responsibilities, request flow, overlap, and architecture trade-offs.
Compare SQL vs NoSQL for system design: data modeling, transactions, scale, trade-offs, and the right database for each workload.
Learn database indexing with SQL examples: B-tree indexes, query plans, composite index order, write costs, and interview questions.
Learn how to choose composite index column order for SQL queries using equality, range, sort, selectivity, and EXPLAIN plan trade-offs.
Learn database isolation levels through real transaction examples, including dirty reads, phantoms, write skew, retries, and SQL trade-offs.
Compare optimistic vs pessimistic locking with SQL examples, conflict handling, retries, deadlocks, and practical backend trade-offs.
Learn database deadlocks through transaction examples, wait-for cycles, retries, lock ordering, query design, and production prevention practices.
Learn database replication, read replicas, replication lag, stale reads, and failover trade-offs for reliable backend systems.
Learn why SQL queries are slow and use EXPLAIN ANALYZE, query plans, indexes, and production evidence to fix them safely.
Learn the cache-aside pattern, cache hit and miss flows, write invalidation, TTLs, stampede prevention, and production trade-offs.
Compare write-through vs write-back caching: write latency, durability, consistency, failure recovery, and when each cache write strategy fits.
Learn cache eviction policies including LRU, LFU, FIFO, and TTL. Choose a policy using workload patterns, memory limits, and production metrics.
Learn Redis architecture through data types, persistence, replication, failover, clustering, and the production trade-offs behind fast in-memory systems.
Learn cache invalidation strategies for backend systems: TTLs, delete-on-write, event-driven updates, versioned keys, race conditions, and trade-offs.
Learn cache stampede prevention for avalanche and penetration failures with TTL jitter, request coalescing, stale data, and Bloom filters.
Compare queue vs pub/sub patterns for backend systems. Learn delivery models, retries, fanout, ordering, and how to choose the right fit.
Learn Kafka architecture through producers, brokers, topics, partitions, consumers, and offsets. Understand ordering, replication, lag, and trade-offs.
Learn Kafka partitions, message keys, ordering, and consumer parallelism with production trade-offs, sizing guidance, and interview questions.
Learn Kafka consumer groups, partition assignment, scaling, rebalancing, cooperative protocols, and production failure handling with examples.
Learn Kafka offsets, auto and manual commits, at-least-once processing, replay, recovery, and safe offset management with Java examples.
Learn Kafka ordering guarantees, partition keys, producer retries, parallel consumers, and how to preserve business event sequence in production.
Compare Kafka at-most-once, at-least-once, and exactly-once delivery, including commits, retries, transactions, and idempotent sinks.
Learn Kafka consumer lag, how to measure lag age, find bottlenecks, scale consumers safely, and restore throughput with a production runbook.
Learn Kafka dead letter queues, retry topics, poison messages, failure metadata, safe replay, and offset handling for production consumers.
Compare Kafka vs RabbitMQ across architecture, routing, retention, ordering, delivery, replay, operations, and real production use cases.
Compare synchronous vs asynchronous communication in backend systems, including latency, queues, retries, delivery guarantees, and practical trade-offs.
Learn service discovery with DNS, registries, health checks, and Kubernetes Services, including client-side and server-side trade-offs.
Learn the circuit breaker pattern, its closed, open, and half-open states, failure thresholds, fallbacks, and interaction with retries.
Design safe retries with exponential backoff, jitter, idempotency, retry budgets, and circuit breakers without creating retry storms.
Design backend timeouts with connection, read, request, and deadline budgets that prevent resource leaks and cascading latency.
Understand liveness, readiness, and startup health checks, how Kubernetes uses them, and how bad probes cause restart loops.
Learn backend observability with metrics, structured logs, traces, correlation IDs, SLOs, and a practical incident-debugging workflow.
Learn distributed tracing with trace IDs, span IDs, context propagation, sampling, OpenTelemetry, and practical cross-service debugging.
Learn the backpressure pattern for queues, streams, and APIs, including bounded buffers, rate limits, load shedding, and recovery.
Learn what CAP theorem really says: during a network partition, distributed systems trade consistency for availability, not any two features.
Compare strong, eventual, causal, read-your-writes, and monotonic-read consistency models with backend examples and trade-offs.
Learn distributed locks with leases, fencing tokens, Redis, ZooKeeper, database locks, failure modes, and safer alternatives.
Learn why local ACID stops at service boundaries and how outbox, two-phase commit, and Saga patterns coordinate distributed work.
Understand two-phase commit with prepare and commit phases, coordinator failures, blocking participants, and when 2PC is appropriate.
Learn the Saga pattern for reliable distributed transactions, including orchestration, choreography, compensation, retries, and idempotency.
Understand backend race conditions, see why check-then-act code fails, and learn database, lock, and idempotency patterns that prevent corruption.
Learn leader election in distributed systems, including leases, quorum, fencing tokens, failover, split brain, and safe recovery patterns.
Understand quorum reads and writes, replica overlap, consistency trade-offs, hinted handoff, read repair, and failure behavior in distributed databases.
Learn consistent hashing for distributed caches and sharded databases, including virtual nodes, rebalancing, hotspots, and failure handling.
A practical backend interview scenario for preventing duplicate payments with idempotency keys, unique constraints, retries, and reconciliation.
Solve the last-item inventory race condition in a backend interview with atomic updates, reservations, idempotency, and contention trade-offs.
Walk through a senior backend interview diagnosis for a slow API: compare traces, pools, database plans, GC, caches, and downstream timeouts.
Use a production-safe checklist to investigate database CPU at 100 percent: query plans, locks, indexes, connections, replicas, and rollback.
Design a graceful Redis outage response for a backend interview: cache fallback, sessions, locks, persistence, and recovery.
Diagnose and recover Kafka consumer lag in a backend interview using partition math, consumer throughput, rebalances, retries, and backpressure.
Answer a backend interview scenario about downstream timeouts with deadlines, retry budgets, circuit breakers, bulkheads, and graceful fallbacks.
Work through a 100x traffic increase in a backend interview: capacity math, caching, queues, replicas, sharding, rate limits, and rollout stages.
Design an idempotent webhook consumer for a backend interview with event IDs, deduplication, signatures, ordering, retries, and replay.
Solve an order-payment distributed transaction failure with a Saga, durable state machine, compensation, idempotency, and reconciliation.
Practice a cache hot key thundering herd backend interview scenario with failure handling, capacity math, observability, and trade-offs.
Practice a missing webhook reconciliation backend interview scenario with failure handling, capacity math, observability, and trade-offs.
Practice processing 10 million jobs in a backend interview scenario with partitioning, leases, capacity math, observability, and trade-offs.
Practice handling stale read replicas in a backend interview scenario with consistency choices, lag monitoring, and production trade-offs.
Practice a zero-downtime database migration backend interview scenario with failure handling, capacity math, observability, and trade-offs.
Practice a zero-downtime deployment backend interview scenario with rollout safety, compatibility, observability, and rollback trade-offs.
Practice a cascading microservice failure backend interview scenario with failure handling, capacity math, observability, and trade-offs.
Practice deduplicating Kafka messages in a backend interview scenario with offsets, idempotent consumers, capacity math, and trade-offs.
Practice a flash sale inventory protection backend interview scenario with failure handling, capacity math, observability, and trade-offs.
Practice reducing high P99 latency in a backend interview scenario with traces, queueing, capacity math, observability, and trade-offs.
Practice a database connection pool exhaustion backend interview scenario with failure handling, capacity math, observability, and trade-offs.
Practice stopping a retry storm in a backend interview scenario with budgets, jitter, circuit breakers, observability, and trade-offs.
Practice safe DLQ replay in a backend interview scenario with poison messages, idempotency, capacity math, observability, and trade-offs.
Practice a distributed lock holder crash backend interview scenario with failure handling, capacity math, observability, and trade-offs.
Practice a multi-region application backend interview scenario with data placement, failover, consistency, observability, and trade-offs.
Practice an API abuse and quotas backend interview scenario with bot detection, fair limits, capacity math, observability, and trade-offs.
Practice debugging sudden memory increase in a backend interview scenario with failure handling, capacity math, and trade-offs.
Practice scaling a table to billions of rows in a backend interview scenario with failure handling, capacity math, and trade-offs.
Practice handling out-of-order events in a backend interview scenario with sequence numbers, replay, observability, and trade-offs.
Learn functional vs non-functional requirements in system design interviews with examples for latency, availability, scale, and consistency.