Concept
HTTP Semantics
Status codes, methods, caching headers, and response meaning for backend APIs.
Use this map to connect games to the backend ideas they teach, then revisit weak concepts from your local review history.
Concept progress and weak spots are stored locally in this browser.
No local review items yet. Missed game decisions will appear here.
Practice recent review items as a short local session.
Each concept links to games, learning objectives, common mistakes, and local review items.
Concept
Status codes, methods, caching headers, and response meaning for backend APIs.
Concept
Resource naming, HTTP methods, route parameters, nested resources, and readable API contracts.
Concept
Authentication, authorization, sessions, token scope, CSRF, and object-level access checks.
Concept
Browser cross-origin read permissions, preflight requests, credentials, exposed headers, and cache variation.
Concept
Signature verification, replay protection, delivery retries, idempotency, and safe partner integrations.
Concept
Single-column indexes, composite indexes, leftmost prefix rules, covering indexes, and write overhead.
Concept
Atomic writes, isolation anomalies, locks, uniqueness constraints, and invariant protection.
Concept
Expand-contract releases, backfills, dual writes, rollback safety, and zero-downtime database changes.
Concept
Cache hits, misses, LRU eviction, TTL, stale data, cache warming, and hit-rate thinking.
Concept
Token buckets, quotas, fair usage, cost-based limits, retry storms, and abuse protection.
Concept
Round robin, weighted routing, least connections, health checks, overload, and horizontal scaling.
Concept
Producers, consumers, queue depth, retries, backoff, visibility timeout, dead-letter queues, and poison messages.
Concept
Stable operation keys, request fingerprints, stored results, duplicate prevention, and retry-safe side effects.
Concept
Metrics, logs, traces, alerts, service-level symptoms, and high-signal debugging during incidents.
Concept
Failure isolation, graceful degradation, retries, overload protection, observability, queues, and recovery behavior.
Concept
Open, half-open, and closed states; timeouts, fallback behavior, failure classification, and dependency isolation.
Concept
Outbox relays, delivery guarantees, idempotent consumers, dead-letter recovery, and saga compensation.
Concept
Partition tradeoffs, replica consistency, recovery objectives, deadlocks, and transaction isolation.
Concept
Memory visibility, synchronization, executor capacity, cancellation, virtual threads, and structured task lifecycles.
Concept
Container artifact integrity, Kubernetes workload identity, resource capacity, rollouts, observability, and incident recovery.
Concept
Cache-Control, validators, conditional requests, shared caches, CDN layers, and invalidation propagation.
Concept
Authorization Code, PKCE, state, redirect URI validation, and secure token exchange.
Concept
Single-use reset tokens, expiry, hashed storage, session revocation, and enumeration-resistant responses.
Concept
Monotonic stacks, interval merging, and heap selection patterns for backend problem solving.
Concept
Breadth-first and depth-first traversal, visited timing, frontier order, and path selection.
Concept
Bit arrays, hash count, expected capacity, false-positive rates, and probabilistic membership checks.
Concept
Telemetry quality, alert routing, incident roles, mitigation, and evidence-led recovery.
Concept
Runtime evidence, heap and native memory, garbage collectors, compilation, warmup, and capacity.
The same 15 games are preserved; the concept map simply gives them a study structure.
Inspect authentication scenarios and choose safe backend decisions for tokens, scopes, sessions, CSRF, and object-level authorization.
Tune Bloom-filter capacity, hash count, verification, saturation, and deletion behavior without introducing false negatives.
Predict cache hits and misses as requests flow through an LRU cache, then experiment with TTL behavior and stale data tradeoffs.
Diagnose dependency failures and choose circuit breaker, timeout, fallback, retry, half-open, and bulkhead strategies that reduce blast radius.
Guide browser API requests through CORS decisions covering origins, preflight, credentials, exposed headers, and cache safety.
Build, attest, and promote one minimal immutable container artifact.
Connect durability, MVCC, plan evidence, and connection budgets.
Recover pool, lock, replication, and failover incidents without losing business truth.
Propagate deadlines, cancellation, bulkheads, and bounded fallbacks across dependency failure windows.
Design REST-style methods and routes for product requirements such as creating users, updating email, searching products, and nested comments.
Read waits-for cycles, choose safe victims, retry complete transactions, and prevent recurring deadlocks.
Classify failures, bound retries, quarantine poison messages, and replay dead-letter work with approval and idempotency.
Trace producer, broker, consumer, acknowledgment, crash, and redelivery boundaries to name the real delivery guarantee.
Follow validators through browser, CDN, and origin while handling 304 responses, representation variants, purge, and bounded staleness.
Practice event boundaries, CloudEvents envelopes, semantic compatibility, and safe schema evolution.
Recover event systems through ambiguous publication, backlog control, and business reconciliation.
Bound executor admission, compose failures, and stop work after deadlines.
Choose BFS or DFS, place visited checks, handle cycles, and cover disconnected graph components.
Choose browser and shared-cache policies for public, personalized, validated, and variant API responses.
Choose the correct HTTP status code for realistic backend scenarios and learn the response semantics behind each answer.
Diagnose retry scenarios and choose safe idempotency behavior for payments, emails, imports, orders, PUT updates, and scarce inventory.
Build duplicate-safe consumers with scoped event identity, database constraints, and atomic business mutations.
Choose composite and partial indexes while accounting for MVCC churn, bloat, and partition lifecycle.
Protect Java visibility, compound invariants, atomic updates, and lock ordering.
Read unified GC evidence and compare G1 and ZGC through controlled, reversible service experiments.
Separate retained heap, allocation churn, metaspace, stacks, direct buffers, RSS, and container memory pressure.
Control partition keys, consumer rebalances, ordering gaps, and hot-partition recovery.
Correlate thread dumps, safepoints, CPU, JFR, dependencies, and container evidence into bounded JVM hypotheses.
Measure JIT compilation, code cache, warmup, AOT training, and capacity with explicit guardrails and rollback.
Preserve serving capacity through scheduling, autoscaling, disruption, and rollout changes.
Recover workload failures using controller, Pod, probe, dependency, and business evidence.
Connect Deployments, Services, configuration, identity, probes, and termination.
Route simulated traffic across backend servers using round robin, weighted round robin, least connections, and random strategies.
Tune workers, retries, and dead-letter behavior while jobs move through an async queue with failures and poison messages.
Trace Authorization Code flow failures across state, PKCE, redirect URI, token exchange, and session boundaries.
Recover a transactional outbox relay across commit, publish-confirm, duplicate delivery, and poison-event failure windows.
Control queue growth, adaptive concurrency, health probes, and priority-aware load shedding during overload.
Triage production incidents by choosing useful metrics, logs, traces, queue signals, database evidence, request ids, and alerting strategies.
Choose explicit consistency or availability behavior for concrete network-partition scenarios.
Secure account recovery against enumeration, token theft, replay, concurrent use, and stale sessions.
Recognize monotonic-stack, interval-merge, heap, and probabilistic membership signals from problem constraints.
Investigate PostgreSQL query plans, cardinality gaps, scan choices, join amplification, and rollout evidence.
Choose rate limiting designs for realistic backend traffic patterns, from public APIs and login endpoints to queues, webhooks, and retry storms.
Route reads across primary and replicas while respecting lag, freshness contracts, failover, and workload isolation.
Coordinate durable Saga state, local transactions, compensations, timeouts, and manual recovery.
Translate RPO and RTO into backup, point-in-time recovery, restore testing, and isolation decisions.
Choose safe zero-downtime database migration steps for expanding schemas, backfilling data, rolling out indexes, enforcing constraints, and recovering from failures.
Triage blocking chains, slow-query regressions, expand-contract changes, and resource-safe database rollouts.
Direct incident response with RED, USE, service-level indicators, burn rates, and explicit recovery criteria.
Place Spring transactions, JPA fetch plans, rollback rules, and validated configuration at production boundaries.
Sequence Spring Security, health probes, PostgreSQL Testcontainers, mitigation, and incident recovery.
Design Spring controllers, validation, service delegation, and safe Problem Details responses.
Choose the best database index for simplified schemas and queries while learning full scans, covering indexes, sort avoidance, and composite order.
Route SLO alerts, assign incident roles, mitigate reversibly, and verify recovery with durable evidence.
Build trustworthy Spring telemetry contracts with explicit ownership, bounded cardinality, and evidence-quality checks.
Build a bounded telemetry path for structured logs, trace context, sampling, batching, and safe attributes.
Defend database invariants from concurrent requests by choosing transactions, locks, constraints, snapshot reads, and optimistic concurrency.
Operate virtual threads, structured child tasks, scoped context, and pinning evidence.
Investigate webhook requests and choose safe handling for signatures, replay windows, retries, idempotency, and durable acknowledgement.