Lesson · Production Database Engineering · Advanced
Database Connection Contention and Recovery Lab Examples
Use six deterministic browser scenarios to reason about pools, locks, retries, replica lag, failover interruption, and evidence boundaries.
Library · 194 lessons
Find the exact backend lesson you need.
Filter the curriculum without losing the original stable article URLs.
194 lessons
Read lesson →
Lesson · Production Database Engineering · Advanced
PostgreSQL and MySQL Observability and Capacity Explained
Correlate demand, pools, sessions, transactions, locks, plans, storage, logs, and replicas without leaking sensitive database data.
Lesson · Production Database Engineering · Intermediate
PostgreSQL and MySQL Query Plans and Statistics Explained
Interpret estimates, runtime plans, statistics, parameters, and index choices using each engine's documented evidence boundaries.
Lesson · Production Database Engineering · Intermediate
PostgreSQL and MySQL Replication and Failover Explained
Separate replication, apply, promotion, fencing, client routing, consistency, and ambiguous write evidence across both engines.
Lesson · Production Database Engineering · Beginner
PostgreSQL and MySQL Storage Engines and MVCC Explained
Compare PostgreSQL tuple visibility and vacuum with MySQL 8.4 InnoDB undo and purge without inventing one shared engine model.
Lesson · Production Database Engineering · Beginner
Production Database Engineering Systems Explained
Trace one Spring order service across relational, engine, transaction, capacity, replication, backup, and recovery boundaries.
Lesson · Production Database Engineering · Advanced
Production Database Incident Troubleshooting
Diagnose pool exhaustion, lock contention, slow plans, failed migrations, replica lag, storage pressure, and failover ambiguity.
Lesson · Production Observability & SRE · Advanced
Incident Command, Communication, and Postmortems
Coordinate incident command, operations, communication, handoffs, factual timelines, blameless learning, and owned follow-up work.
Lesson · Production Observability & SRE · Beginner
JVM Profiling and JFR for Production Backends
Use Java 25 Flight Recorder to investigate CPU, allocation, GC, locks, I/O, and virtual threads without overstating profile evidence.
Lesson · Production Observability & SRE · Intermediate
Production Alerting, On-Call, and Runbooks
Route symptom-based SLO alerts through actionable pages, tickets, ownership, escalation, handoff, and recovery-focused runbooks.
Lesson · Production Observability & SRE · Advanced
SLO Incident Triage Lab: Evidence Gaps, Alerts, and Recovery
Run six deterministic browser scenarios that compare modeled user impact with observed telemetry, alert windows, and recovery evidence.
Lesson · Production Observability & SRE · Beginner
Telemetry Quality, Semantic Conventions, and Cardinality Explained
Build trustworthy telemetry contracts for identity, schemas, units, timestamps, missing data, duplicates, and bounded dimensions.
Lesson · Production Observability & SRE · Beginner
Spring Boot, Micrometer, and OpenTelemetry Instrumentation
Instrument a Spring order service with Actuator, Micrometer Observation, tracing, OTLP, bounded dimensions, and tested propagation.
Lesson · Java Concurrency & Async Programming · Intermediate
Evidence-Based JVM Tuning and Capacity Verification
Turn JVM performance hypotheses into controlled canary changes with representative load, rollback, resource budgets, and user-outcome verification.
Lesson · Java Concurrency & Async Programming · Beginner
G1 Garbage Collector Diagnosis and Tuning
Diagnose Java 25 G1 young, marking, mixed, evacuation, and humongous-object behavior before making minimal evidence-backed tuning changes.
Lesson · Java Concurrency & Async Programming · Advanced
Java Heap Dumps and Memory Leak Analysis
Use Java 25 class histograms and heap dumps to test retention and memory-leak hypotheses while controlling pause, disk, and data exposure.
Lesson · Java Concurrency & Async Programming · Beginner
JVM Garbage Collection Logs and Pause Diagnosis Explained
Read Java 25 garbage collection logs to distinguish allocation pressure, live-set growth, concurrent work, pauses, and Full GC safely.
Lesson · Java Concurrency & Async Programming · Beginner
JVM JIT, Code Cache, and Warmup Diagnosis
Diagnose Java 25 tiered compilation, compilation queues, deoptimization, code cache pressure, warmup, JFR, and AOT profile boundaries.
Lesson · Java Concurrency & Async Programming · Intermediate
JVM Native Memory, Metaspace, and Container OOM Diagnosis
Separate Java heap, HotSpot native memory, metaspace, buffers, stacks, RSS, and container OOM evidence with Java 25 NMT.
Lesson · Java Concurrency & Async Programming · Beginner
JVM Thread Dumps, Safepoints, and CPU Saturation Diagnosis
Diagnose Java 25 platform and virtual threads, locks, safepoints, CPU saturation, pinning, and dependency waits with bounded evidence.
Lesson · Java Concurrency & Async Programming · Advanced
Production JVM Performance Diagnostics Explained
Diagnose production JVM performance from user impact through CPU, garbage collection, memory, threads, containers, and durable outcomes.
Lesson · Java Concurrency & Async Programming · Beginner
ZGC Low-Latency Garbage Collection Diagnosis and Tuning
Diagnose generational ZGC allocation headroom, concurrent work, stalls, heap sizing, and latency-throughput tradeoffs on Java 25.
Lesson · Event-Driven Systems · Beginner
Event Schema Evolution and Compatibility Explained
Evolve event payloads safely with explicit semantics, compatibility checks, tolerant readers, staged rollout, replay evidence, and deprecation boundaries.
Lesson · Event-Driven Systems · Beginner
Event-Driven Architecture Decisions Explained
Learn when event-driven architecture helps, where its reliability boundaries sit, and how to choose events, commands, state, and recovery contracts.
Lesson · Event-Driven Systems · Intermediate
Event Ordering, Deduplication, and State Convergence
Keep event-driven state correct across duplicates and reordering with stable identity, entity versions, conditional updates, and explicit convergence rules.
Lesson · Event-Driven Systems · Beginner
Event Design with CloudEvents and AsyncAPI
Design stable event envelopes, payload schemas, channels, and operations with CloudEvents and AsyncAPI without confusing contracts with delivery guarantees.
Lesson · Event-Driven Systems · Beginner
Kafka Topics, Partitions, Consumer Groups, and Ordering
Understand Kafka topics, partition logs, keys, offsets, consumer groups, rebalances, and the exact boundaries of ordering and parallel processing.
Lesson · Event-Driven Systems · Advanced
Message Delivery Semantics Lab: Crash, Retry, and Idempotency Examples
Run four deterministic delivery scenarios to see how ACK timing, crashes, retries, stable IDs, and DLQ boundaries change business outcomes.
Lesson · Event-Driven Systems · Advanced
Production Kafka and Event-Driven Systems Troubleshooting
Troubleshoot event-driven incidents through user impact, producer acceptance, partition health, consumer progress, retries, and business reconciliation.
Lesson · Event-Driven Systems · Beginner
Reliable Event Publishing with Spring Boot and an Outbox
Build a Spring Boot transactional outbox that commits business state with publication intent, survives relay crashes, and exposes duplicate-safe evidence.
Lesson · Event-Driven Systems · Intermediate
Reliable Spring Kafka Consumers: ACKs, Retries, and DLTs
Design Spring Kafka consumers around durable effects, offset and acknowledgment boundaries, bounded retries, dead-letter recovery, and idempotency.
Lesson · Java Concurrency & Async Programming · Beginner
CompletableFuture Composition, Errors, and Timeouts
Compose Java CompletableFuture stages deliberately across executors, failures, timeouts, cancellation, context, and external side-effect boundaries.
Lesson · Java Concurrency & Async Programming · Beginner
Java Concurrency for Backend Systems Explained
Build a practical model of tasks, threads, shared state, race conditions, thread safety, and bounded concurrency in Java backend services.
Lesson · Java Concurrency & Async Programming · Advanced
Java Concurrency Budget Lab: Queues, Virtual Threads, and Cancellation
Run six deterministic Java concurrency scenarios to compare fixed pools, virtual threads, resource guards, deadlines, and cooperative cancellation.
Lesson · Java Concurrency & Async Programming · Beginner
ExecutorService, Thread Pools, and Work Queues in Java
Design Java executors around admission, worker, queue, rejection, shutdown, and downstream capacity instead of treating threads as free throughput.
Lesson · Java Concurrency & Async Programming · Beginner
Java Interruption, Cancellation, and Deadlines Explained
Propagate Java interruption and request deadlines cooperatively across executors, blocking calls, cleanup, Spring boundaries, and durable effects.
Lesson · Java Concurrency & Async Programming · Beginner
Java Memory Model, Visibility, and Happens-Before Explained
Understand atomicity, visibility, ordering, data races, volatile fields, safe publication, and happens-before reasoning in Java backend code.
Lesson · Java Concurrency & Async Programming · Intermediate
Scoped Values and Structured Concurrency in Modern Java
Separate Java 25 Scoped Values from JDK 26 preview Structured Concurrency and reason about bounded context, task lifetime, failure, and cancellation.
Lesson · Java Concurrency & Async Programming · Intermediate
Java Virtual Threads for Backend Services
Use Java 21 virtual threads for blocking backend tasks while keeping CPU, connection pools, downstream limits, context, and pinning explicit.
Lesson · Java Concurrency & Async Programming · Intermediate
Production Java Concurrency Troubleshooting
Diagnose Java thread starvation, unbounded queues, lock contention, virtual-thread pinning, downstream overload, and failed cancellation with evidence.
Lesson · Java Concurrency & Async Programming · Beginner
synchronized, Locks, and Atomic Variables in Java
Compare Java monitors, ReentrantLock, CAS, atomic variables, lock scope, fairness, and compound invariants through backend examples.
Lesson · Cloud-Native Backend Operations · Beginner
Kubernetes Configuration, Secrets, and Workload Identity
Separate application configuration, Kubernetes Secrets, rotation, Spring property precedence, and workload identity without leaking credentials.
Lesson · Cloud-Native Backend Operations · Intermediate
Kubernetes Horizontal Pod Autoscaling for Backend Services
Reason about HPA metrics, requests, startup delay, stabilization, custom signals, dependency limits, and overload before changing replicas.
Lesson · Cloud-Native Backend Operations · Advanced
Kubernetes Observability and Debugging for Backend Workloads
Trace user impact through workload state, Pod events, container reasons, metrics, logs, traces, dependencies, and durable business evidence.
Lesson · Cloud-Native Backend Operations · Intermediate
Kubernetes Resource Requests, Limits, and JVM Containers
Connect Kubernetes CPU and memory policy to scheduling, throttling, OOM termination, JVM memory, connection pools, and downstream capacity.
Lesson · Cloud-Native Backend Operations · Beginner
Kubernetes Probes and Graceful Shutdown for Spring Boot
Design startup, liveness, readiness, EndpointSlice removal, SIGTERM, preStop, and Spring graceful shutdown as separate lifecycle controls.
Lesson · Cloud-Native Backend Operations · Advanced
Kubernetes Rolling Updates and Safe Backend Releases
Coordinate immutable images, surge, unavailability, readiness, termination, rollback, and compatible database change in a backend rollout.
Lesson · Cloud-Native Backend Operations · Advanced
Kubernetes Rollout Capacity Lab: Readiness, Surge, and Drain
Run six deterministic browser scenarios for rollout capacity, slow readiness, stalled updates, termination risk, and version regressions.
Lesson · Cloud-Native Backend Operations · Intermediate
Kubernetes Scheduling, Disruption, and High Availability
Use topology placement, affinity, taints, disruption budgets, and eviction evidence without mistaking replica count for business availability.
Lesson · Cloud-Native Backend Operations · Beginner
Kubernetes Pods, Deployments, and Services for Backend Apps
Connect Pods, ReplicaSets, Deployments, Services, selectors, and EndpointSlices without confusing restart, replacement, or routing evidence.
Lesson · Cloud-Native Backend Operations · Beginner
OCI Container Images and Runtime Boundaries Explained
Separate OCI image, distribution, runtime, registry, CRI, containerd, Docker, and Kubernetes responsibilities in a production release.
Lesson · Cloud-Native Backend Operations · Beginner
Production Cloud-Native Backend Systems Explained
Trace a Spring backend from source and OCI image through Kubernetes rollout, traffic, capacity, evidence, and verified recovery.
Lesson · Cloud-Native Backend Operations · Advanced
Production Kubernetes Backend Incident Troubleshooting
Diagnose Pending, image pull, crash, probe, OOM, rollout, capacity, and dependency failures from user impact to verified recovery.
Lesson · Cloud-Native Backend Operations · Beginner
Production Container Images, Dockerfiles, and Supply Chain
Build minimal, non-root, traceable backend images with multi-stage Dockerfiles, immutable promotion, SBOMs, scanning, and signatures.
Lesson · Spring Backend · Beginner
Production Spring Boot Backend Systems Explained
Build a production-minded Spring Boot order service by separating HTTP, application, data, security, configuration, operations, testing, and incident-recovery layers.
Lesson · Spring Backend · Advanced
Production Spring Boot Incident Troubleshooting
Troubleshoot Spring Boot incidents from evidence through reversible mitigation, rollback, and recovery verification across correctness, users, and resources.
Lesson · Spring Backend · Advanced
Spring Boot Actuator, Health, and Metrics Explained
Operate Spring Boot with minimal Actuator exposure, safe health groups, liveness and readiness boundaries, low-cardinality metrics, and graceful shutdown.
Lesson · Spring Backend · Beginner
Spring Boot Exception Handling Explained
Design safe Spring Boot error responses with ProblemDetail and RFC 9457 while respecting MVC, filter, security, async, and committed-response boundaries.
Lesson · Spring Backend · Intermediate
Spring Boot Configuration Properties, Profiles, and Secrets Explained
Use typed Spring Boot configuration, deliberate property precedence, environment profiles, secret injection, and drift evidence without exposing operational control planes.
Lesson · Spring Backend · Beginner
Spring Boot Request Validation Explained
Separate Spring Boot request-shape validation from authorization and concurrency-safe business invariants, including nested DTO and collection validation.
Lesson · Spring Backend · Intermediate
Spring Data JPA Query Performance Explained
Diagnose Spring Data JPA performance with query, SQL, plan, row, pool-wait, and user-latency evidence instead of relying on fetch-strategy folklore.
Lesson · Spring Backend · Advanced
Spring Boot Integration Testing with Testcontainers Explained
Use Spring test slices, full-context contracts, Testcontainers PostgreSQL, migrations, security, and failure injection without overstating production equivalence.
Lesson · Spring Backend · Advanced
Spring Security Filter Chain and Authorization Explained
Design ordered Spring Security filter chains, deny-by-default request and method authorization, resource ownership checks, and safe browser boundaries.
Lesson · Spring Backend · Intermediate
Spring Service Layers and Transaction Boundaries Explained
Design Spring application services and transactions that preserve local order invariants without hiding proxy, rollback, thread, remote-call, or side-effect boundaries.
Lesson · System Design · Beginner
Composite, Covering, and Partial Indexes Explained
Learn to design composite, covering, and partial PostgreSQL indexes from real query predicates, ordering, projections, selectivity, and write-cost evidence.
Lesson · System Design · Beginner
Database Lock Contention and Long Transactions Explained
Learn to diagnose PostgreSQL lock contention, blockers, waiters, long transactions, idle-in-transaction sessions, pool exhaustion, and safe cancellation.
Lesson · System Design · Beginner
Database Query Performance for Backend Systems Explained
Learn how to diagnose database query performance using user impact, execution plans, planner estimates, I/O, locks, MVCC, connection pools, and safe production validation.
Lesson · System Design · Beginner
MVCC, VACUUM, and Table Bloat Explained
Learn how PostgreSQL MVCC, snapshots, dead tuples, autovacuum, visibility maps, freezing, HOT updates, and table or index bloat affect backend performance.
Lesson · System Design · Beginner
PostgreSQL EXPLAIN and Query Plans Explained
Learn to read PostgreSQL EXPLAIN plans safely, including costs, estimated and actual rows, loops, scans, joins, sorts, buffers, WAL, and production boundaries.
Lesson · System Design · Beginner
Production Slow Query Troubleshooting for Backend Systems
Use a production runbook to connect user impact, query fingerprints, waits, plans, estimates, buffers, locks, MVCC, pools, mitigations, and verified recovery.
Lesson · System Design · Beginner
Query Planner Statistics and Cardinality Estimation Explained
Learn how query planners estimate rows using statistics, selectivity, histograms, most-common values, correlation, extended statistics, and production validation.
Lesson · System Design · Beginner
Table Partitioning and Partition Pruning Explained
Learn PostgreSQL table partitioning, partition keys, pruning, lifecycle maintenance, indexes, constraints, prepared queries, and production validation.
Lesson · System Design · Beginner
Zero-Downtime Database Schema Migrations Explained
Learn expand-contract database migrations, compatible deploy ordering, bounded backfills, concurrent indexes, constraint validation, locking, and safe production rollout.
Lesson · System Design · Intermediate
Backpressure, Bounded Queues, and Flow Control Explained
Control overload with explicit demand, bounded buffering, queue age, rejection, expiry, and end-to-end flow policies across APIs, streams, and brokers.
Lesson · System Design · Intermediate
Bulkhead Pattern and Resource Isolation Explained
Contain backend failures by isolating concurrency, threads, connection pools, and queues across priorities, tenants, operations, and dependencies.
Lesson · Production Observability & SRE · Beginner
Distributed Tracing and Context Propagation Explained
Trace backend work across HTTP and message queues with W3C context, safe baggage, meaningful spans, sampling boundaries, and broken-trace tests.
Lesson · System Design · Advanced
Graceful Degradation and Fallback Design Explained
Design explicit fallback modes that preserve business invariants, authorization, freshness contracts, and observable recovery under dependency failure.
Lesson · System Design · Advanced
Liveness, Readiness, and Startup Health Checks Explained
Design Kubernetes startup, liveness, and readiness probes that route safely, recover local deadlocks, and avoid overload-driven restart storms.
Lesson · System Design · Intermediate
Load Shedding and Adaptive Concurrency Limits Explained
Protect backend latency and useful throughput with explicit admission, deliberate load shedding, and evidence-tuned concurrency limits.
Lesson · Production Observability & SRE · Beginner
Observability for Backend Systems Explained
Learn how logs, metrics, traces, and events work together to diagnose backend failures, protect telemetry quality, and verify recovery.
Lesson · Production Observability & SRE · Intermediate
OpenTelemetry Collector Pipeline Explained
Build a resilient vendor-neutral telemetry pipeline with OTLP receivers, memory limits, batching, redaction, retries, queues, and self-monitoring.
Lesson · Production Observability & SRE · Advanced
Production Incident Troubleshooting with Logs, Metrics, and Traces
Follow an evidence-driven incident runbook from SLO alert and triage through metrics, traces, logs, mitigation, recovery verification, and postmortem.
Lesson · System Design · Advanced
Production Overload Troubleshooting for Backend Systems
Run an evidence-driven backend overload response from page and user impact through mitigation, controlled recovery, and durable verification.
Lesson · System Design · Advanced
Production Resilience for Backend Systems Explained
Design backend systems that prevent, contain, degrade through, recover from, and verify failures while preserving user objectives and capacity.
Lesson · Production Observability & SRE · Beginner
RED, USE, and Golden Signals Explained
Use RED, USE, and the four golden signals to diagnose request and resource failures with PromQL, safe labels, histograms, and exemplars.
Lesson · Production Observability & SRE · Intermediate
SLI, SLO, Error Budgets, and Burn-Rate Alerts Explained
Turn user journeys into measurable SLIs, realistic SLOs, error budgets, and multi-window burn-rate alerts that page on sustained impact.
Lesson · Production Observability & SRE · Beginner
Structured Logging and Correlation IDs Explained
Design searchable JSON logs and correlation IDs that connect requests, messages, traces, and failures without leaking secrets or exploding cost.
Lesson · System Design · Beginner
Timeouts, Deadlines, and Cancellation Propagation Explained
Design end-to-end request budgets that distinguish hop timeouts, propagated deadlines, cooperative cancellation, and durable side effects under backend overload.
Lesson · System Design · Intermediate
Dead Letter Queue Explained
Design dead-letter handling with bounded retries, failure metadata, alerting, approved replay, and duplicate-safe Java and Node.js recovery workflows.
Lesson · System Design · Intermediate
Idempotent Consumer Pattern Explained
Make at-least-once message processing duplicate-safe with PostgreSQL unique constraints, atomic business updates, and Java and Node.js consumers.
Lesson · System Design · Beginner
Message Delivery Semantics Explained
Compare at-most-once, at-least-once, and exactly-once messaging by tracing producer, broker, consumer, acknowledgment, and side-effect failures.
Lesson · System Design · Advanced
Saga Pattern and Compensating Transactions Explained
Coordinate cross-service workflows with Saga choreography or orchestration, durable state, idempotent steps, compensation, and manual recovery.
Lesson · System Design · Beginner
Transactional Outbox Pattern Explained
Prevent database and message broker dual-write failures with a transactional outbox, PostgreSQL locking, and Java and Node.js publishers.
Lesson · API Design · Beginner
Cache-Control Explained for APIs
Choose safe API caching policies with max-age, s-maxage, private, no-cache, no-store, revalidation, and practical Java and Node.js recipes.
Lesson · API Design · Beginner
CDN Caching Strategies for APIs
Design safe CDN cache keys, shared TTLs, revalidation, stale responses, and invalidation workflows for Java and Node.js APIs.
Lesson · API Design · Beginner
ETag and Conditional Requests Explained
Implement ETag, If-None-Match, Last-Modified, 304 responses, and safe update preconditions with Spring Boot and Express examples.
Lesson · API Design · Beginner
HTTP Cache Headers Explained
Understand Cache-Control, Age, Expires, Vary, freshness, validation, and browser versus shared cache behavior with Java and Node.js examples.
Lesson · API Design · Beginner
Preventing Sensitive Data from Being Cached
Protect authenticated and personalized API responses from browser and shared-cache leaks with safe Java and Node.js policies and tests.
Lesson · Backend Security · Advanced
API Request Signing Explained
Design HMAC API request signing in Java and Node.js with canonical requests, timestamps, nonces, replay defense, rotation, tests, and failure handling.
Lesson · Algorithms · Advanced
Bloom Filter Explained
Learn how Bloom filters trade small false-positive risk for compact membership checks, including sizing math, Java BitSet code, and backend use cases.
Lesson · System Design · Beginner
CAP Theorem Explained
Learn what consistency, availability, and partition tolerance mean during failures, why pick-two is misleading, and how PACELC improves the model.
Lesson · Backend Security · Intermediate
CORS Configuration Best Practices
Configure CORS safely in Spring Boot and Express with exact origins, credentials, preflight caching, rejection behavior, tests, and deployment checks.
Lesson · Production Database Engineering · Beginner
Database Deadlocks Explained
Learn why database deadlocks happen, how PostgreSQL and MySQL detect them, and how to prevent and retry them safely in Java and Node.js.
Lesson · Production Database Engineering · Beginner
Database Isolation Levels Explained
Compare database isolation levels, concurrency anomalies, PostgreSQL and MySQL behavior, and safe Spring and Node.js transaction patterns.
Lesson · Production Database Engineering · Intermediate
Database Backup and Restore Explained
Design database backups around RPO and RTO, compare logical, physical, snapshot, and PITR methods, and build restore drills that prove recovery.
Lesson · Production Database Engineering · Intermediate
Database Read Replicas Explained
Learn how database read replicas work, where replica lag breaks correctness, and how to route reads safely in Spring and Node.js services.
Lesson · Algorithms · Intermediate
Graph Traversal: BFS vs DFS
Compare breadth-first and depth-first graph traversal, choose the right strategy, and implement safe iterative Java versions with complexity and tests.
Lesson · Algorithms · Intermediate
Heap Patterns Explained
Recognize heap patterns for top K, kth elements, streaming medians, k-way merge, and scheduling with safe Java PriorityQueue examples.
Lesson · Algorithms · Beginner
Merge Intervals Explained
Learn the merge intervals pattern, endpoint semantics, sorting invariants, Java implementation, complexity, edge cases, and scheduling variants.
Lesson · Algorithms · Beginner
Monotonic Stack Explained
Learn how monotonic stacks solve next-greater, stock-span, temperature, and histogram problems in linear time with practical Java examples.
Lesson · Authentication · Beginner
OAuth Authorization Code Flow Explained
Implement OAuth Authorization Code with PKCE safely in Spring Security and Node.js, including state, callbacks, token exchange, tests, and mistakes.
Lesson · API Design · Beginner
OpenAPI Security Schemes Explained
Model bearer tokens, API keys, OAuth 2.0, and OpenID Connect in OpenAPI with Springdoc and Express examples, overrides, tests, and enforcement boundaries.
Lesson · Authentication · Beginner
Password Reset Token Best Practices
Build secure single-use password reset tokens in Spring Boot and Node.js with random generation, hash storage, expiry, rate limits, tests, and auditing.
Lesson · API Design · Intermediate
API Rate Limit Headers Explained
Learn how API rate limit headers communicate quotas, remaining capacity, retry timing, and client behavior across current and legacy formats.
Lesson · API Design · Beginner
API Deprecation Headers Explained
Use RFC 9745 Deprecation, deprecation links, and Sunset headers to communicate API lifecycle dates, migration guidance, and removal plans.
Lesson · API Design · Advanced
Cursor Pagination Examples for REST APIs
Build cursor pagination with stable sorting, keyset SQL, opaque signed tokens, filter binding, error handling, and Java and Node.js implementations.
Lesson · API Design · Beginner
Problem Details for HTTP APIs (RFC 9457)
Design RFC 9457 problem details for HTTP APIs with stable type URIs, safe extensions, validation errors, Spring Boot, and Node.js examples.
Lesson · Backend Security · Advanced
API Abuse Prevention Explained
Learn API abuse prevention for backend systems, including rate limits, authentication signals, quotas, bot patterns, logging, errors, and gateways.
Lesson · Authentication · Advanced
API Authentication Best Practices
Learn API authentication best practices, including tokens, API keys, OAuth, mTLS, sessions, gateways, rotation, scopes, errors, and logging.
Lesson · Authentication · Intermediate
Cookie Security Checklist
Use this backend cookie security checklist for HttpOnly, Secure, SameSite, CSRF, session rotation, prefixes, expiration, domains, and testing.
Lesson · Authentication · Beginner
Cookie vs Token Authentication
Compare cookie and token authentication for backend apps, including sessions, JWTs, CSRF, XSS, storage, CORS, mobile clients, and API tradeoffs.
Lesson · Authentication · Intermediate
CORS Preflight Explained
Learn how CORS preflight requests work, including OPTIONS handling, allowed methods, headers, credentials, caching, errors, and backend mistakes.
Lesson · Authentication · Beginner
OAuth Client Credentials Flow Explained
Learn the OAuth client credentials flow for service-to-service APIs, including clients, secrets, scopes, tokens, rotation, and security risks.
Lesson · Authentication · Beginner
OAuth Scopes Explained
Learn OAuth scopes for backend APIs, including permissions, consent, least privilege, access tokens, naming, validation, and common mistakes.
Lesson · Backend Security · Advanced
Security Event Logging Explained
Learn security event logging for backend systems, including auth events, API abuse signals, safe metadata, alerting, retention, and mistakes.
Lesson · Authentication · Beginner
Service Accounts Explained
Learn service accounts for backend systems, including machine identity, API access, least privilege, secrets, rotation, audit logs, and risks.
Lesson · Backend Security · Advanced
Audit Logs Explained for Backend Systems
Learn what audit logs are in backend systems, including actor, action, resource, timestamp, metadata, retention, privacy, and investigation workflows.
Lesson · API Design · Advanced
API Pagination Metadata Best Practices
Learn how to design pagination metadata for REST APIs, including pageInfo, cursors, hasNextPage, limits, totals, links, sorting, and compatibility.
Lesson · Production Database Engineering · Intermediate
Database Connection Pooling Explained
Learn database connection pooling for backend systems, including pool size, timeouts, leaks, max connections, queues, monitoring, and common mistakes.
Lesson · Production Database Engineering · Intermediate
Database Migration Rollback Explained
Learn database migration rollback strategies, including backward-compatible changes, expand-contract migrations, backups, deploy order, and recovery plans.
Lesson · Java Collections · Advanced
HashMap Collision Handling Explained
Learn how HashMap collision handling works in Java, including buckets, hashCode, equals, tree bins, load factor, bad keys, and performance.
Lesson · Java Collections · Beginner
Java equals and hashCode Explained
Learn Java equals and hashCode contracts, why they matter for HashMap and HashSet, common mistakes, records, mutability, and testing.
Lesson · API Design · Beginner
JSON Schema vs OpenAPI Schema
Compare JSON Schema and OpenAPI Schema for backend API contracts, including validation, documentation, examples, tooling, and compatibility.
Lesson · Authentication · Advanced
Least Privilege Explained for Backend Developers
Learn the principle of least privilege for backend systems, including users, services, API keys, database roles, cloud permissions, and operational tradeoffs.
Lesson · System Design · Beginner
N+1 Query Problem Explained
Learn the N+1 query problem in backend apps, including ORM loading, SQL examples, eager loading, batching, joins, query counts, and fixes.
Lesson · Algorithms · Beginner
Prefix Sum Algorithm Explained
Learn prefix sums with Java examples, range-sum queries, subarray patterns, difference arrays, complexity, and when preprocessing is worth it.
Lesson · API Design · Beginner
REST API Design Checklist
Use this REST API design checklist to review resources, methods, status codes, errors, pagination, idempotency, versioning, auth, and OpenAPI docs.
Lesson · Backend Security · Advanced
Secret Management Explained for Backend Developers
Learn secret management for backend apps, including environment variables, secret stores, rotation, least privilege, logging risks, and deployment workflows.
Lesson · Algorithms · Beginner
Sliding Window Algorithm Explained
Learn the sliding window algorithm pattern with Java examples, fixed windows, variable windows, two pointers, complexity, and common mistakes.
Lesson · Spring Backend · Advanced
Spring Boot REST Controller Explained
Learn Spring Boot REST controllers, including @RestController, request mappings, DTOs, validation, status codes, error responses, and testing.
Lesson · Algorithms · Beginner
Two Pointers Algorithm Explained
Learn the two pointers algorithm pattern with Java examples for sorted arrays, pairs, partitions, linked lists, complexity, and common mistakes.
Lesson · Authentication · Advanced
API Key Design Best Practices for Backend APIs
Learn practical API key design best practices, including key format, prefixes, hashing, scopes, rotation, rate limits, audit logs, and safe storage.
Lesson · Authentication · Beginner
API Key vs OAuth Token: Practical Backend Differences
Compare API keys and OAuth tokens for backend APIs, including identity, scopes, rotation, expiration, user context, service access, and security tradeoffs.
Lesson · Java Collections · Beginner
HashSet vs TreeSet in Java
Compare HashSet and TreeSet in Java by ordering, uniqueness, contains performance, null handling, memory cost, and practical backend use cases.
Lesson · Authentication · Beginner
MFA Explained for Web Apps
Learn how multi-factor authentication works in web apps, including TOTP, WebAuthn, backup codes, recovery flows, step-up checks, and backend tradeoffs.
Lesson · API Design · Beginner
OpenAPI Explained for Backend Developers
Learn how OpenAPI describes REST APIs, including paths, operations, schemas, examples, auth, versioning, code generation, and contract review.
Lesson · Authentication · Beginner
Password Hashing Explained for Backend Developers
Learn password hashing basics for backend systems, including salts, slow hashes, peppers, verification, resets, storage risks, and common mistakes.
Lesson · API Design · Beginner
PUT vs PATCH in REST APIs
Compare PUT and PATCH in REST APIs, including replacement vs partial updates, idempotency, validation, status codes, and backend implementation choices.
Lesson · Java Collections · Intermediate
Queue vs Deque in Java
Compare Queue and Deque in Java, including FIFO queues, double-ended operations, ArrayDeque, LinkedList, stack usage, and practical backend defaults.
Lesson · Authentication · Beginner
RBAC vs ABAC: Access Control Models Explained
Compare RBAC and ABAC for backend authorization, including roles, attributes, policies, ownership checks, tenant context, and practical tradeoffs.
Lesson · Authentication · Beginner
Refresh Token Rotation Explained for Backend Developers
Learn how refresh token rotation works, why reuse detection matters, and how backend teams can design safer token refresh, logout, and revocation flows.
Lesson · Authentication · Intermediate
SameSite Cookies Explained for Backend Developers
Learn how SameSite cookies affect browser authentication, CSRF risk, cross-site requests, OAuth redirects, iframes, and backend cookie design.
Lesson · Authentication · Intermediate
Secure HTTP Headers Explained for Backend Developers
Learn practical secure HTTP headers for backend apps, including HSTS, CSP, X-Content-Type-Options, frame protection, referrer policy, and cookie-related limits.
Lesson · Authentication · Beginner
Session Fixation Explained for Backend Developers
Learn what session fixation is, how it affects web authentication, why session rotation matters, and how backend teams can prevent it.
Lesson · Java Collections · Beginner
TreeMap vs HashMap in Java
Compare TreeMap and HashMap in Java by key ordering, lookup complexity, range queries, null handling, memory overhead, and backend use cases.
Lesson · Backend Security · Advanced
Webhook Signature Verification Explained
Learn how webhook signature verification works, including HMAC headers, raw request bodies, timestamps, replay protection, secret rotation, and safe failures.
Lesson · Authentication · Advanced
API Gateway Explained
Learn what an API gateway does in backend architecture, including routing, authentication, rate limiting, observability, and tradeoffs.
Lesson · System Design · Advanced
Background Jobs Explained
Learn how background jobs work in backend systems, including queues, workers, retries, scheduling, idempotency, and monitoring.
Lesson · Authentication · Beginner
Authorization vs Authentication
Compare authentication and authorization in backend systems, including identity checks, permissions, roles, scopes, sessions, tokens, and API enforcement.
Lesson · System Design · Advanced
Caching Strategies Explained
Learn common backend caching strategies, including cache-aside, write-through, write-behind, TTLs, invalidation, and cache stampede risks.
Lesson · System Design · Intermediate
Circuit Breaker Pattern Explained
Learn how the circuit breaker pattern protects backend services from cascading failures, with closed, open, and half-open states.
Lesson · Authentication · Intermediate
CORS Explained for Backend Developers
Learn how CORS works for backend APIs, including origins, preflight requests, credentials, allowed headers, cookies, security limits, and common mistakes.
Lesson · Production Database Engineering · Advanced
Database Sharding Explained
Learn what database sharding is, when backend systems need it, how shard keys work, and what tradeoffs sharding creates.
Lesson · Production Database Engineering · Beginner
Database Transactions Explained
Learn what database transactions are, why ACID matters, how commits and rollbacks work, and what backend developers should know.
Lesson · System Design · Intermediate
Distributed Locks Explained
Learn what distributed locks are, when backend systems use them, why they are risky, and what safer alternatives to consider.
Lesson · System Design · Beginner
Eventual Consistency Explained
Learn what eventual consistency means in distributed systems, why stale reads happen, and how backend teams design around them.
Lesson · Authentication · Beginner
JWT Claims Explained
Learn common JWT claims for backend authentication, including sub, iss, aud, exp, nbf, iat, jti, scopes, roles, tenant context, and validation mistakes.
Lesson · System Design · Advanced
Load Balancing Explained
Learn how load balancing distributes traffic across backend servers, including algorithms, health checks, sticky sessions, and tradeoffs.
Lesson · System Design · Beginner
Message Queues Explained
Learn how message queues work in backend systems, including producers, consumers, retries, dead-letter queues, ordering, and idempotency.
Lesson · Authentication · Beginner
OAuth 2.0 vs OpenID Connect
Compare OAuth 2.0 and OpenID Connect for backend developers, including authorization, login, ID tokens, access tokens, scopes, and common mistakes.
Lesson · Authentication · Advanced
REST API Error Handling Best Practices
Learn practical REST API error handling patterns, including status codes, stable error codes, field errors, request IDs, and safe messages.
Lesson · API Design · Intermediate
Retry Patterns Explained
Learn safe backend retry patterns, including exponential backoff, jitter, retry budgets, idempotency, and when not to retry.
Lesson · API Design · Advanced
Webhooks Explained
Learn how webhooks work in backend systems, including event delivery, signatures, retries, idempotency, and common design mistakes.
Lesson · API Design · Beginner
API Versioning Explained
Learn practical API versioning strategies, including URL versions, header versions, backward compatibility, deprecation, and migration plans.
Lesson · Java Collections · Beginner
Binary Search Explained
Learn how binary search works, when it applies, common off-by-one mistakes, and how to implement iterative binary search in Java.
Lesson · Production Database Engineering · Beginner
Database Indexes Explained
Learn how database indexes work, why they speed up reads, when they slow down writes, and how backend developers should choose indexes.
Lesson · Production Database Engineering · Beginner
Optimistic Locking Explained
Learn how optimistic locking prevents lost updates in backend systems using version columns, compare-and-swap updates, and 409 conflicts.
Lesson · Backend Security · Advanced
Rate Limiting in APIs Explained
Learn how API rate limiting works, including fixed windows, sliding windows, token buckets, 429 responses, headers, and backend tradeoffs.
Lesson · Java Collections · Intermediate
Top K Elements Explained
Learn common ways to solve top K elements problems with sorting, heaps, and Java PriorityQueue, including complexity tradeoffs.
Lesson · Java Collections · Beginner
Time Complexity of Java Collections
A practical reference for Java collection time complexity, including ArrayList, LinkedList, HashMap, TreeMap, HashSet, and PriorityQueue.
Lesson · Authentication · Intermediate
CSRF vs XSS: Key Differences for Backend Developers
Compare CSRF and XSS attacks for backend developers, including how they work, why cookies and tokens matter, and practical defenses.
Lesson · Authentication · Beginner
OAuth 2.0 Explained for Backend Developers
A backend-focused OAuth 2.0 guide covering roles, authorization code flow, PKCE, scopes, tokens, client credentials, and common mistakes.
Lesson · Authentication · Beginner
Access Token vs Refresh Token
Compare access tokens and refresh tokens in backend authentication, including lifetime, storage, rotation, revocation, and security tradeoffs.
Lesson · API Design · Advanced
Pagination Strategies for REST APIs
Compare offset, cursor, and keyset pagination for REST APIs, including tradeoffs, response shapes, sorting, and backend performance.
Lesson · API Design · Intermediate
Idempotency in APIs Explained
Learn what idempotency means in API design, why retries create duplicate actions, and how idempotency keys protect backend workflows.
Lesson · Authentication · Advanced
REST API Status Codes Explained
Understand the HTTP status codes backend developers use most often in REST APIs, including 200, 201, 400, 401, 404, 409, and 500.
Lesson · Java Collections · Beginner
ConcurrentHashMap Explained
A practical explanation of ConcurrentHashMap in Java, including thread safety, atomic methods, iteration behavior, and common mistakes.
Lesson · Java Collections · Beginner
HashMap Load Factor Explained
Learn what HashMap load factor means in Java, how it affects resizing, memory usage, collision risk, and lookup performance.
Lesson · Java Collections · Advanced
ArrayList vs LinkedList in Java
Compare ArrayList and LinkedList in Java by access patterns, insertion cost, memory overhead, and practical backend usage.
Lesson · Java Collections · Beginner
Big-O Notation Explained for Backend Developers
Learn Big-O notation with practical backend examples, including arrays, hash maps, sorting, nested loops, and database-like thinking.
Lesson · Authentication · Beginner
JWT vs Session Authentication: Practical Backend Tradeoffs
Understand JWT and server-side session authentication, including storage, revocation, scaling, security risks, and common backend use cases.
Lesson · API Design · Beginner
REST vs RPC: How to Choose an API Style
Compare REST and RPC API styles through resources, actions, payload design, caching, versioning, and backend team workflows.
Lesson · Java Collections · Intermediate
Java PriorityQueue Explained with Practical Examples
Learn how Java PriorityQueue works, when to use it, how ordering is defined, and common pitfalls around iteration and custom comparators.
Lesson · Java Collections · Advanced
HashMap vs Hashtable in Java: Key Differences
Compare HashMap and Hashtable in Java, including synchronization, null keys, performance, legacy status, and modern alternatives.
No lessons match those filters.
Try a broader course or clear the search phrase.