Topic series

Ordered series keep distinct perspectives separate while linking overview → deep dive → production.

Caching

From cache vocabulary through strategies, distributed caching, stampede control, and edge CDNs.

  1. Caching 101 — Memory Offloading and Latency Reduction (canonical-overview)
  2. Caching Strategies — Aside, Through, Behind, and Refresh-Ahead (deep-dive)
  3. Cache Eviction Policies — LRU, LFU, TTL, and Friends (deep-dive)
  4. Distributed Caching — Sharding and High-Availability Clusters (production-guide)
  5. Cache Stampede — When Expiry Melts the Database (failure-case)
  6. Stale Cache After Write — When Your Own Update Disappears (failure-case)
  7. Content Delivery Networks (CDN) — Edge Acceleration and Caching (production-guide)
  8. Bloom Filters — Probabilistic Set Membership at Scale (deep-dive)

Rate Limiting

Algorithms, service design, distributed enforcement, resilience coupling, and interview framing.

  1. Rate Limiting Algorithms — Token Bucket, Windows, and Bursts (foundation)
  2. Rate Limiter Design — Case Study (deep-dive)
  3. Distributed Rate Limiting — Shared Quotas Across Many Pods (production-guide)
  4. Circuit Breakers & Rate Limiting Together (production-guide)

Idempotency & Exactly-Once

API idempotency, retries, duplicate gaps, practical EOS, and payment-domain reconciliation.

  1. Idempotency, Retries & Backoff (deep-dive)
  2. Duplicate Requests & the Idempotency Gap (failure-case)
  3. Exactly-Once Processing vs Practical Deduplication (deep-dive)
  4. Payment Idempotency and Reconciliation (case-study)

CAP, Consistency & Quorums

Consistency vocabulary from CAP through models, strong vs eventual trade-offs, and quorum practice.

  1. CAP Theorem — Consistency, Availability, and Partition Tolerance (canonical-overview)
  2. Consistency Models — From Strong to Eventual (deep-dive)
  3. Strong vs Eventual Consistency — Trade-offs in Distributed Systems (deep-dive)
  4. CAP, Consistency & Idempotency (deep-dive)
  5. Quorum Reads vs Quorum Writes (production-guide)

Payments Architecture

Platform architecture, design cases, idempotent money movement, SEPA lifecycle, and banking platforms.

  1. Payment Platform Architecture (canonical-overview)
  2. Payment Platform Design (Interview Sketch) (deep-dive)
  3. Payment Idempotency and Reconciliation (production-guide)
  4. SEPA Lifecycle & Reconciliation (case-study)
  5. Banking Transaction Platform Design (case-study)

Kafka & Event Streaming

Queues to Kafka architecture, ordering, EOS, Streams, outbox/saga, and Spring integration.

  1. Message Queues — Hand Work Off Without Blocking the User (foundation)
  2. Kafka Architecture — Brokers, Partitions, ISR, and Consumers (canonical-overview)
  3. Kafka Partition Ordering and Delivery Guarantees (deep-dive)
  4. Kafka Exactly-Once Semantics — What Is Actually Guaranteed (deep-dive)
  5. Transactional Outbox and Saga Patterns — Reliable Multi-Step Work (production-guide)
  6. Kafka Streams Introduction (deep-dive)
  7. Kafka with Spring Boot Code Walkthrough (implementation-guide)

Replication

Replication foundations, Postgres failover, DDIA notes, and quorum read/write practice.

  1. Data Replication — Keeping Copies in Sync (canonical-overview)
  2. DDIA Notes — Replication & Partitioning (book-notes)
  3. PostgreSQL Replication & Failover (production-guide)
  4. Quorum Reads vs Quorum Writes (deep-dive)

Reliability & Failover

Availability, reliability, fault tolerance, failover, multi-region survival, and disaster recovery.

  1. Availability — Nines, Error Budgets, and Redundancy (canonical-overview)
  2. Reliability — Correct Results Under Stress (foundation)
  3. Fault Tolerance — Keep Working When Parts Fail (foundation)
  4. Failover — Switching to a Healthy Spare (deep-dive)
  5. Multi-Region Failover — Surviving a Region Outage (case-study)
  6. Disaster Recovery — RPO, RTO, and Backups That Work (production-guide)

Spring Boot Production

DI core through lifecycle, MVC, JPA transactions, security, and production practices.

  1. Spring Core Dependency Injection (canonical-overview)
  2. Spring Bean Lifecycle (deep-dive)
  3. Spring Boot Startup Lifecycle (deep-dive)
  4. Spring MVC REST APIs (implementation-guide)
  5. Spring Data JPA and Transactions — Persistence Without Surprises (production-guide)
  6. Spring Security OAuth2 Resource Server (JWT) (production-guide)
  7. Spring Boot Best Practices (production-guide)

Java Collections

Collections overview through HashMap, lists, ConcurrentHashMap, and Streams.

  1. Java Collections Overview (canonical-overview)
  2. HashMap Internals (deep-dive)
  3. ArrayList vs LinkedList — When Contiguous Beats Nodes (deep-dive)
  4. ConcurrentHashMap Internals — Concurrent Hashing Without Global Locks (deep-dive)
  5. Java Streams API Deep Dive (deep-dive)

Java Concurrency

Memory model and virtual threads through locks, futures, executors, and race debugging.

  1. Java Memory Model & Virtual Threads (canonical-overview)
  2. Synchronization, Locks & Deadlocks (deep-dive)
  3. CompletableFuture Patterns (deep-dive)
  4. Java Executor Framework — Thread Pools Done Right (production-guide)
  5. Race Conditions — Finding and Fixing (failure-case)

CDC, Outbox & Sagas

Dual-write problems, outbox/saga patterns, practical exactly-once, and idempotent handlers.

  1. CDC vs Dual Writes — Keeping Two Stores in Sync (foundation)
  2. Transactional Outbox and Saga Patterns — Reliable Multi-Step Work (canonical-overview)
  3. Exactly-Once Processing vs Practical Deduplication (deep-dive)

Staff Decision Operating System

How Staff engineers make change durable: ADRs, RFCs, quality-attribute scenarios, and architecture reviews.

  1. Architecture Decision Records (ADRs) (canonical-overview)
  2. Technical RFCs That Ship (production-guide)
  3. Quality-Attribute Scenarios (deep-dive)
  4. Architecture Reviews Without Theater (production-guide)
  5. Technical Strategy for Staff Engineers (concept)
  6. Cost-Aware Architecture (deep-dive)

Reliability & SRE Practice

From availability vocabulary to SLOs, capacity, tails, PRRs, and incident command.

  1. Availability — Nines, Error Budgets, and Redundancy (foundation)
  2. SLIs, SLOs, and Error Budgets — Measure Reliability Like a Product (canonical-overview)
  3. Capacity Planning for Backend Services (deep-dive)
  4. Tail Latency and Load Shedding — Surviving Peak Traffic Overload (deep-dive)
  5. Production-Readiness Reviews (PRRs) (production-guide)
  6. Incident Command for Backend Teams (production-guide)

Security Hardening for Backends

Threat modelling through secrets, multi-tenant isolation, privacy, and supply chain.

  1. Threat Modelling for Backend Services (canonical-overview)
  2. Secrets and Key Management (production-guide)
  3. Multi-Tenant Isolation Patterns (deep-dive)
  4. Privacy Engineering Basics (concept)
  5. Supply-Chain Security and SBOMs (concept)

Platform as a Product

IDP, GitOps, progressive delivery, and contract testing as platform capabilities.

  1. Internal Developer Platforms (canonical-overview)
  2. GitOps Fundamentals (concept)
  3. Progressive Delivery and Feature Flags (production-guide)
  4. Contract Testing for Services (production-guide)
  5. CI/CD & Developer Experience (production-guide)

Shubham Jain · Learning Lab