Data and consistency
Start here for transactions, CAP tradeoffs, isolation, replicas, sharding, and eventual consistency.
Knowledge map
See how backend ideas connect.
Explore by domain and module when you need context, then enter a guided path when you are ready to study in sequence.
01
9 modules
System Design
Design reliable backend systems through data, traffic, async work, and failure trade-offs.
Database performance and operations
Diagnose query explosions, tune concurrency and pools, and prepare replicas, migrations, backups, and recovery.
Production database query performance
Diagnose and safely remediate slow database workloads through plans, statistics, indexes, MVCC, locking, partitioning, compatible schema changes, and evidence-driven recovery.
- Database Query Performance for Backend Systems Explained
- PostgreSQL EXPLAIN and Query Plans Explained
- Query Planner Statistics and Cardinality Estimation Explained
- Composite, Covering, and Partial Indexes Explained
- MVCC, VACUUM, and Table Bloat Explained
- Database Lock Contention and Long Transactions Explained
- Table Partitioning and Partition Pruning Explained
- Zero-Downtime Database Schema Migrations Explained
- Production Slow Query Troubleshooting for Backend Systems
Reliability and resilience
Learn how production systems handle failures, retries, duplicate work, lock contention, overload, and recovery.
Async reliability
Follow one failure chain from durable event publication through delivery guarantees, duplicate-safe consumers, dead-letter recovery, and Saga compensation.
- Event-Driven Architecture Decisions Explained
- Message Queues Explained
- Transactional Outbox Pattern Explained
- Message Delivery Semantics Explained
- Idempotent Consumer Pattern Explained
- Dead Letter Queue Explained
- Saga Pattern and Compensating Transactions Explained
- Background Jobs Explained
- Webhooks Explained
- Event Ordering, Deduplication, and State Convergence
- Production Kafka and Event-Driven Systems Troubleshooting
Production observability
Follow one production incident from user-impact detection through metrics, logs, traces, telemetry pipelines, SLO alerting, mitigation, and verified recovery.
- Observability for Backend Systems Explained
- Structured Logging and Correlation IDs Explained
- RED, USE, and Golden Signals Explained
- Distributed Tracing and Context Propagation Explained
- OpenTelemetry Collector Pipeline Explained
- SLI, SLO, Error Budgets, and Burn-Rate Alerts Explained
- Production Incident Troubleshooting with Logs, Metrics, and Traces
Production resilience and overload control
Design deadlines, resource isolation, bounded work, admission control, degradation, health checks, and evidence-driven incident response for overloaded production systems.
- Production Resilience for Backend Systems Explained
- Timeouts, Deadlines, and Cancellation Propagation Explained
- Bulkhead Pattern and Resource Isolation Explained
- Backpressure, Bounded Queues, and Flow Control Explained
- Load Shedding and Adaptive Concurrency Limits Explained
- Graceful Degradation and Fallback Design Explained
- Liveness, Readiness, and Startup Health Checks Explained
- Production Overload Troubleshooting for Backend Systems
- Production Java Concurrency Troubleshooting
Traffic and API architecture
Study how requests reach backend services and how public API contracts stay stable over time.
Additional guided lessons
Complete the course with focused guides that extend the core sequence.
02
3 modules
Spring Backend
Build production Spring services across request, transaction, data, security, operations, testing, and recovery boundaries.
Request and HTTP boundaries
Follow one order request from production architecture through a thin controller, bounded request validation, and stable failure contracts.
Application and data boundaries
Keep local transactions explicit, diagnose the SQL that JPA actually produces, and operate typed configuration without confusing profiles with secrets.
Security, operations, testing, and recovery
Deny access by default, expose bounded operational evidence, prove production-sensitive behavior against PostgreSQL, and recover from incidents deliberately.
- Spring Security Filter Chain and Authorization Explained
- Spring Boot Actuator, Health, and Metrics Explained
- Spring Boot Integration Testing with Testcontainers Explained
- Production Spring Boot Incident Troubleshooting
- Java Virtual Threads for Backend Services
- Production Java Concurrency Troubleshooting
- Production JVM Performance Diagnostics Explained
- Java Heap Dumps and Memory Leak Analysis
- Evidence-Based JVM Tuning and Capacity Verification
03
5 modules
Event-Driven Systems
Design message-driven systems across contracts, publication, consumption, ordering, recovery, and production operations.
Foundations and architectural decisions
Choose asynchronous boundaries, then connect Kafka partitions, consumer groups, ordering, and delivery semantics to business outcomes.
Event contracts and reliable publication
Define stable envelopes and schemas, evolve them compatibly, and publish durable business facts through an operated outbox.
Consumption, duplicates, ordering, and recovery
Make consumer effects duplicate-safe, configure bounded Spring Kafka recovery, and converge when records arrive late or more than once.
Coordination and production operations
Coordinate long-running work and troubleshoot real event flows from durable intent through consumer state and user recovery.
Interactive failure lab
Run deterministic crash, retry, acknowledgement, and idempotency scenarios, then connect each timeline to production evidence and recovery ownership.
04
6 modules
Java Concurrency & Async Programming
Master shared-state correctness, task execution, cancellation, virtual threads, finite capacity, and production concurrency evidence.
Shared state and correctness
Build one model for task ownership, visibility, atomicity, locking, concurrent collections, and business invariants.
Task execution, composition, and cancellation
Own executor admission, compose asynchronous results, propagate deadlines, and distinguish cancellation requests from stopped effects.
Virtual threads and structured tasks
Use Java 21 virtual threads deliberately, then isolate Java 25 Scoped Values and JDK 26 preview Structured Concurrency.
Capacity and production operations
Protect finite resources through bulkheads, backpressure, admission, and evidence-driven JVM and downstream troubleshooting.
JVM performance, GC, and runtime diagnostics
Move from user impact through GC, managed and native memory, thread, JIT, container, and capacity evidence before changing runtime policy.
- Production JVM Performance Diagnostics Explained
- JVM Garbage Collection Logs and Pause Diagnosis Explained
- G1 Garbage Collector Diagnosis and Tuning
- ZGC Low-Latency Garbage Collection Diagnosis and Tuning
- Java Heap Dumps and Memory Leak Analysis
- JVM Native Memory, Metaspace, and Container OOM Diagnosis
- JVM Thread Dumps, Safepoints, and CPU Saturation Diagnosis
- JVM JIT, Code Cache, and Warmup Diagnosis
- Evidence-Based JVM Tuning and Capacity Verification
Interactive concurrency lab
Run six deterministic queue, virtual-thread, capacity, deadline, and cancellation scenarios without creating real load.
05
5 modules
Cloud-Native Backend Operations
Ship and operate backend services through immutable artifacts, Kubernetes workload boundaries, capacity, safe rollout, and verified recovery.
Container artifact and runtime boundaries
Trace reviewed source into an immutable OCI artifact, registry, runtime bundle, and least-privileged Java process.
Kubernetes application boundaries
Connect controllers, Services, configuration, identity, probes, traffic eligibility, and graceful application termination.
Capacity, availability, and scaling
Budget JVM and dependency resources, distribute failure domains, and scale from signals without inventing capacity.
Release and production operations
Coordinate mixed-version rollout, collect safe evidence, mitigate reversibly, and verify customer and durable-state recovery.
Capstone lab
Run six deterministic readiness, surge, termination, stall, and capacity scenarios without contacting a cluster.
06
5 modules
Production Observability & SRE
Operate Spring services through trustworthy telemetry, bounded signals, SLO alerting, incident command, and verified recovery.
Evidence foundations
Define trustworthy telemetry identity, quality, and Spring instrumentation before building operational views.
Production signals
Use bounded logs, metrics, traces, JVM recordings, GC, thread, and JIT evidence according to each signal's boundary.
- Structured Logging and Correlation IDs Explained
- RED, USE, and Golden Signals Explained
- Distributed Tracing and Context Propagation Explained
- JVM Profiling and JFR for Production Backends
- JVM Garbage Collection Logs and Pause Diagnosis Explained
- G1 Garbage Collector Diagnosis and Tuning
- ZGC Low-Latency Garbage Collection Diagnosis and Tuning
- JVM Thread Dumps, Safepoints, and CPU Saturation Diagnosis
- JVM JIT, Code Cache, and Warmup Diagnosis
Telemetry delivery and reliability objectives
Operate the telemetry chain, define user-centered objectives, and route actionable alerts to owned runbooks.
Incident operations
Coordinate response, communicate facts, learn without blame, and verify recovery with independent evidence.
Capstone lab
Compare modeled user impact with observed evidence, SLO burn, alert windows, telemetry gaps, and recovery.
07
6 modules
Production Database Engineering
Operate PostgreSQL 18 and MySQL 8.4 InnoDB through transactions, concurrency, capacity, change, recovery, and incident evidence.
Engine and transaction boundaries
Locate durable order state across storage engines, MVCC, logs, and local transaction outcomes.
Concurrency and application correctness
Protect order invariants with explicit isolation, deadlock, and optimistic-conflict decisions.
Query and connection capacity
Connect indexes, plans, statistics, transactions, and finite connection ownership.
Change, replication, and recovery
Ship compatible change, reason about replicas and failover, and prove recoverability through restore evidence.
Scale and incident operations
Measure before sharding, preserve safe engine evidence, mitigate reversibly, and verify business recovery.
Capstone lab
Model pool saturation, lock waits, retry amplification, replica lag, and failover ambiguity without contacting a database.
08
6 modules
Java Collections
Choose Java collections by access pattern, correctness constraints, and performance behavior.
Map fundamentals
Start with HashMap behavior, TreeMap ordering, legacy Hashtable differences, load factor tuning, and concurrent map choices.
Equality and hashing
Understand equals, hashCode, key mutability, collision handling, and why hash-based collections behave the way they do.
Set choices
Compare hash-based uniqueness with sorted set behavior, range navigation, comparator rules, and membership checks.
List choices
Compare ArrayList and LinkedList through access patterns, insertion cost, memory overhead, and backend usage.
Queues and priority
Choose between FIFO queues, double-ended queues, heap-backed priority queues, and algorithmic top-K patterns.
Complexity and performance
Use Big-O as a practical language for collection choices, hot paths, memory overhead, and code reviews.
09
7 modules
API Design
Build clear API contracts that remain predictable through errors, retries, and change.
API style and contracts
Choose API style, review REST contracts, document schemas, evolve versions, and understand where an API gateway and browser preflight behavior fit.
Responses and errors
Design status codes, stable error shapes, request IDs, and client-friendly failure behavior.
HTTP caching and delivery
Understand cache headers, choose Cache-Control policies, validate with ETags, operate through CDNs, and keep private responses out of shared caches.
Authentication and access
Protect APIs with authentication choices, cookies vs tokens, API keys, OAuth scopes, service credentials, gateways, and clear auth failures.
Reliability and retries
Make API retries safer with idempotency, abuse prevention, rate limits, backoff, and predictable response contracts.
Data and integrations
Handle paginated data, pagination metadata, webhook delivery, JSON contracts, schemas, and payload inspection.
Implementation and delivery
Connect API design decisions to a concrete Spring Boot controller implementation.
10
4 modules
Authentication
Understand identity, tokens, sessions, OAuth, and browser security boundaries.
Authentication architecture
Compare identity, credentials, permissions, sessions, JWTs, OAuth, OpenID Connect, and login tradeoffs.
- Password Hashing Explained for Backend Developers
- Password Reset Token Best Practices
- MFA Explained for Web Apps
- Authorization vs Authentication
- JWT vs Session Authentication: Practical Backend Tradeoffs
- Cookie vs Token Authentication
- OAuth 2.0 vs OpenID Connect
- OAuth 2.0 Explained for Backend Developers
- OAuth Authorization Code Flow Explained
- OAuth Scopes Explained
- OAuth Client Credentials Flow Explained
- Service Accounts Explained
Token lifecycle and claims
Understand access tokens, refresh tokens, API keys, JWT claims, expiration, rotation, and local inspection.
Browser security risks
Connect CORS, cookies, bearer tokens, CSRF, XSS, storage choices, session fixation, and safe browser authentication design.
Protected API behavior
Design permission checks, least privilege, authentication failures, gateway checks, OAuth resource servers, API keys, and clear API responses.
11
5 modules
Backend Security
Protect APIs, credentials, sessions, integrations, and operational trust boundaries.
Identity and access control
Separate identity, permissions, login state, delegated authorization, and protected resource checks.
- Password Hashing Explained for Backend Developers
- MFA Explained for Web Apps
- Authorization vs Authentication
- RBAC vs ABAC: Access Control Models Explained
- JWT vs Session Authentication: Practical Backend Tradeoffs
- OAuth 2.0 vs OpenID Connect
- OAuth 2.0 Explained for Backend Developers
- OAuth Scopes Explained
- OAuth Client Credentials Flow Explained
- Service Accounts Explained
- API Key vs OAuth Token: Practical Backend Differences
Token and session safety
Understand token claims, expiration, refresh behavior, local inspection, timestamps, and revocation tradeoffs.
Browser and cross-origin risks
Connect origins, credentials, cookie behavior, cookie hardening, preflight requests, CSRF, XSS, URL encoding, and browser-backed API calls.
Operational security
Use security event logs, audit logs, secret handling, service accounts, least privilege, and safe evidence trails to operate production systems.
Secure API behavior
Design gateway checks, rate limits, 401 and 403 responses, safe error messages, and useful debugging signals.
12
7 modules
Algorithms
Build practical complexity judgment for search, arrays, heaps, and backend code reviews.
Complexity fundamentals
Learn the growth curves behind common algorithms and use Big-O as a practical code review language.
Array and subarray patterns
Study windows, pointers, prefix sums, monotonic stacks, and interval frontiers for array and range problems.
Search and sorted data
Understand binary search, sorted input requirements, logarithmic growth, and lookup tradeoffs.
Heaps and top K
Use heap-backed priority queues for ranking, scheduling, streaming medians, k-way merge, and top K.
Graph traversal
Choose BFS or DFS for reachability, shortest unweighted paths, components, cycles, and dependency-style traversals.
Probabilistic data structures
Use Bloom filters and hashing to avoid expensive negative lookups while keeping correctness in an exact source of truth.
Java collection choices
Connect algorithm complexity to everyday backend collection choices, maps, lists, queues, and sets.