BackendDrills resources
Study paths for Java, engineers, leads and architects
Choose one main path. Spend about 30–45 minutes per session; repeat or split sessions when a concept is new. This is guided practice, not a promise to complete 1008 scenarios in two weeks.
How to use every session
- Read the free guide and check its version assumptions.
- Write a prediction, then attempt the selected drill before viewing the debrief.
- Produce the stated test, diagram or review note in your own words.
- Revisit a weak explanation after a few sessions and apply it to another workload.
All plan outlines and readings are public. Three complete drills are free; full-edition links require verified access. Open the interactive plan to track completion in this browser →.
14-session engineering core · 14 sessions
Follow the sessions in order, then choose an optional path. A session can take more than one day; the goal is better reasoning, not finishing all 1008 drills in two weeks.
Prerequisite: Basic programming, HTTP and SQL. Java examples assume familiarity with Java syntax; use the free readings first when a concept is new.
Session 1: Start with evidence and ownership
Separate the symptom, the resource boundary and the property that must remain true.
Produce: An evidence ledger: facts, one competing explanation and a test that would change your mind.
Free reading: Diagnosing HikariCP connection pool exhaustion
- The database is quiet. The pool is full. · Complete free drill
Session 2: Get values and Java 8 pipelines right
Review numeric representation, stream lifetime and the difference between data and a computation over data.
Produce: Two boundary tests: one for a decimal value and one for a reused pipeline.
Free reading: Java 8 streams: lifetime, duplicate keys and safe collection
- Decimal money changes after a round trip · Full edition drill
- Stream reuse fails on the second query · Full edition drill
Session 3: Trace Spring transaction boundaries
Draw the entry point, proxy and commit boundary before choosing propagation or rollback behavior.
Produce: A call-path sketch and a test that checks committed rows after failure.
Free reading: Why Spring @Transactional fails on self-invocation
- The rollback that never happened. · Complete free drill
- The exception was thrown. The data committed. · Full edition drill
Session 4: Protect SQL correctness and query shape
Distinguish a concurrency invariant from a fetch-shape problem; choose the right evidence for each.
Produce: One two-transaction test and one query-count or row-volume check.
Free reading: SQL transactions: prove the invariant with two sessions
- Two orders buy the last item. · Full edition drill
- The endpoint that runs 101 queries. · Full edition drill
Session 5: Define API outcomes, retries and deadlines
Separate transport failure from a known business outcome and give every retry an identity and time budget.
Produce: An API contract covering success, rejection, uncertain completion and retry.
Free reading: API retries: identity, deadlines and uncertain outcomes
- The double-click becomes a double charge. · Full edition drill
- A timeout outlives the caller's deadline · Full edition drill
Session 6: Build tests that can reject a bad change
Test real transaction and failure windows rather than relying only on mocks or a successful response.
Produce: A regression test plan with controlled concurrency and a response lost after commit.
Free reading: Backend testing: target the failure window, not just the happy path
- A mocked repository hides a uniqueness race · Full edition drill
- A fault test fails before the important window · Full edition drill
Session 7: Checkpoint: explain before reopening the answer
Revisit the database and API boundaries from memory. Consult the debrief only after writing your explanation.
Produce: Two corrected explanations and one specific gap to revisit after several sessions.
Free reading: Backend testing: target the failure window, not just the happy path
- Two orders buy the last item. · Full edition drill
- The double-click becomes a double charge. · Full edition drill
Session 8: Budget concurrency and Java 21 resources
Identify the executor, cancellation owner and scarce resource before changing the threading model.
Produce: A resource budget and a cancellation test with an explicit Java version note.
Free reading: Debugging Java 21 virtual-thread pinning
- Async work has nowhere to run. · Full edition drill
- More threads. The same throughput. · Full edition drill
Session 9: Make messaging and replay accountable
Locate the gap between a durable business effect and acknowledgment; distinguish publishing from consuming.
Produce: A failure-window diagram and a replay test that inspects authoritative effects.
Free reading: Handling duplicate Kafka messages without duplicate business effects
- One event. Two shipments. · Complete free drill
- The order exists. The event does not. · Full edition drill
Session 10: Use caching and signals to recover safely
Relate load, cache expiry and queueing to customer outcomes; avoid diagnosing from an average alone.
Produce: A bounded load experiment with latency distribution, correctness and stop criteria.
Free reading: Diagnosing HikariCP connection pool exhaustion
- The cache expires. The database melts. · Full edition drill
- The average hides the slow customers · Full edition drill
Session 11: Enforce authorization across every path
Distinguish login from permission to use a particular object, including cache-hit and direct API paths.
Produce: A two-user negative-test matrix for reads, updates and cached responses.
Free reading: API authorization: check owner, action and every access path
- A cache hit returns another tenant’s data. · Full edition drill
- Changing a resource ID exposes another user's record · Full edition drill
Session 12: Review readiness, shutdown and rollout
Treat process health, admission, draining and schema compatibility as different deployment contracts.
Produce: A rollout checklist with in-flight work, drain deadline and rollback conditions.
Free reading: Cloud rollouts: readiness, draining and compatible rollback
- Shutdown drops in-flight requests · Full edition drill
- An application rollback cannot read the migrated schema · Full edition drill
Session 13: Choose code and service boundaries deliberately
Use a pattern to separate a concrete responsibility, then check whether service boundaries provide useful ownership.
Produce: A design note explaining the invariant, rejected alternative and the cost of the abstraction.
Free reading: Design patterns in practice: responsibility, state and trade-offs
- Strategy selection leaks between requests · Full edition drill
- A modular monolith becomes a distributed monolith · Full edition drill
Session 14: Capstone: capacity, consistency and recovery
Connect workload assumptions, downstream demand and restore evidence; revisit one weak decision from the core path.
Produce: A short architecture decision record with capacity assumptions, consistency needs, acceptance test and recovery gate.
Free reading: System design: workload, consistency and recovery before diagrams
- Capacity planning ignores fan-out · Full edition drill
- Backup success does not prove recovery · Full edition drill
Software engineer · 14 sessions
A broad route through data, APIs, testing, web clients, concurrency, security, cloud and design. Java concurrency examples can be translated to your stack.
Prerequisite: Basic programming, HTTP and SQL; core session 1 if incident practice is new.
Session 1: Start with evidence and ownership
Separate the symptom, the resource boundary and the property that must remain true.
Produce: An evidence ledger: facts, one competing explanation and a test that would change your mind.
Free reading: Diagnosing HikariCP connection pool exhaustion
- The database is quiet. The pool is full. · Complete free drill
Session 2: Protect SQL correctness and query shape
Distinguish a concurrency invariant from a fetch-shape problem; choose the right evidence for each.
Produce: One two-transaction test and one query-count or row-volume check.
Free reading: SQL transactions: prove the invariant with two sessions
- Two orders buy the last item. · Full edition drill
- The endpoint that runs 101 queries. · Full edition drill
Session 3: Define API outcomes, retries and deadlines
Separate transport failure from a known business outcome and give every retry an identity and time budget.
Produce: An API contract covering success, rejection, uncertain completion and retry.
Free reading: API retries: identity, deadlines and uncertain outcomes
- The double-click becomes a double charge. · Full edition drill
- A timeout outlives the caller's deadline · Full edition drill
Session 4: Web/client integration
Keep request identity and permission consistent between browser and API.
Produce: A client state diagram covering stale responses and uncertain write outcomes.
Free reading: Browser request races: stale reads and uncertain submits
- An older response overwrites a newer search · Full edition drill
- Error pages erase a completed submit · Full edition drill
Session 5: Build tests that can reject a bad change
Test real transaction and failure windows rather than relying only on mocks or a successful response.
Produce: A regression test plan with controlled concurrency and a response lost after commit.
Free reading: Backend testing: target the failure window, not just the happy path
- A mocked repository hides a uniqueness race · Full edition drill
- A fault test fails before the important window · Full edition drill
Session 6: Budget concurrency and Java 21 resources
Identify the executor, cancellation owner and scarce resource before changing the threading model.
Produce: A resource budget and a cancellation test with an explicit Java version note.
Free reading: Debugging Java 21 virtual-thread pinning
- Async work has nowhere to run. · Full edition drill
- More threads. The same throughput. · Full edition drill
Session 7: Make messaging and replay accountable
Locate the gap between a durable business effect and acknowledgment; distinguish publishing from consuming.
Produce: A failure-window diagram and a replay test that inspects authoritative effects.
Free reading: Handling duplicate Kafka messages without duplicate business effects
- One event. Two shipments. · Complete free drill
- The order exists. The event does not. · Full edition drill
Session 8: Use caching and signals to recover safely
Relate load, cache expiry and queueing to customer outcomes; avoid diagnosing from an average alone.
Produce: A bounded load experiment with latency distribution, correctness and stop criteria.
Free reading: Diagnosing HikariCP connection pool exhaustion
- The cache expires. The database melts. · Full edition drill
- The average hides the slow customers · Full edition drill
Session 9: Enforce authorization across every path
Distinguish login from permission to use a particular object, including cache-hit and direct API paths.
Produce: A two-user negative-test matrix for reads, updates and cached responses.
Free reading: API authorization: check owner, action and every access path
- A cache hit returns another tenant’s data. · Full edition drill
- Changing a resource ID exposes another user's record · Full edition drill
Session 10: Review readiness, shutdown and rollout
Treat process health, admission, draining and schema compatibility as different deployment contracts.
Produce: A rollout checklist with in-flight work, drain deadline and rollback conditions.
Free reading: Cloud rollouts: readiness, draining and compatible rollback
- Shutdown drops in-flight requests · Full edition drill
- An application rollback cannot read the migrated schema · Full edition drill
Session 11: Choose code and service boundaries deliberately
Use a pattern to separate a concrete responsibility, then check whether service boundaries provide useful ownership.
Produce: A design note explaining the invariant, rejected alternative and the cost of the abstraction.
Free reading: Design patterns in practice: responsibility, state and trade-offs
- Strategy selection leaks between requests · Full edition drill
- A modular monolith becomes a distributed monolith · Full edition drill
Session 12: Capstone: capacity, consistency and recovery
Connect workload assumptions, downstream demand and restore evidence; revisit one weak decision from the core path.
Produce: A short architecture decision record with capacity assumptions, consistency needs, acceptance test and recovery gate.
Free reading: System design: workload, consistency and recovery before diagrams
- Capacity planning ignores fan-out · Full edition drill
- Backup success does not prove recovery · Full edition drill
Session 13: Data pipeline integrity
Define version ordering and compare derived state with its source.
Produce: A source-version, replay and reconciliation contract with a deletion check.
Free reading: Data pipelines: source versions, replay and reconciliation
- CDC updates arrive out of order · Full edition drill
- The inventory cannot explain its balance · Full edition drill
Session 14: AI integration safety
Apply existing permission and test boundaries to model and tool workflows.
Produce: A tool-permission matrix and a held-out evaluation that checks effects and provenance.
Free reading: Defending RAG applications against prompt injection
- Assistant tools trust a model-supplied owner ID · Full edition drill
- Evaluation scores hide dataset leakage · Full edition drill
Java backend engineer · 15 sessions
A practical Java emphasis with explicit Java 8 and Java 21 sessions, while retaining security, cloud, testing and architecture.
Prerequisite: Basic Java collections, lambdas, HTTP, SQL and Spring beans.
Session 1: Start with evidence and ownership
Separate the symptom, the resource boundary and the property that must remain true.
Produce: An evidence ledger: facts, one competing explanation and a test that would change your mind.
Free reading: Diagnosing HikariCP connection pool exhaustion
- The database is quiet. The pool is full. · Complete free drill
Session 2: Get values and Java 8 pipelines right
Review numeric representation, stream lifetime and the difference between data and a computation over data.
Produce: Two boundary tests: one for a decimal value and one for a reused pipeline.
Free reading: Java 8 streams: lifetime, duplicate keys and safe collection
- Decimal money changes after a round trip · Full edition drill
- Stream reuse fails on the second query · Full edition drill
Session 3: Trace Spring transaction boundaries
Draw the entry point, proxy and commit boundary before choosing propagation or rollback behavior.
Produce: A call-path sketch and a test that checks committed rows after failure.
Free reading: Why Spring @Transactional fails on self-invocation
- The rollback that never happened. · Complete free drill
- The exception was thrown. The data committed. · Full edition drill
Session 4: Protect SQL correctness and query shape
Distinguish a concurrency invariant from a fetch-shape problem; choose the right evidence for each.
Produce: One two-transaction test and one query-count or row-volume check.
Free reading: SQL transactions: prove the invariant with two sessions
- Two orders buy the last item. · Full edition drill
- The endpoint that runs 101 queries. · Full edition drill
Session 5: Define API outcomes, retries and deadlines
Separate transport failure from a known business outcome and give every retry an identity and time budget.
Produce: An API contract covering success, rejection, uncertain completion and retry.
Free reading: API retries: identity, deadlines and uncertain outcomes
- The double-click becomes a double charge. · Full edition drill
- A timeout outlives the caller's deadline · Full edition drill
Session 6: Build tests that can reject a bad change
Test real transaction and failure windows rather than relying only on mocks or a successful response.
Produce: A regression test plan with controlled concurrency and a response lost after commit.
Free reading: Backend testing: target the failure window, not just the happy path
- A mocked repository hides a uniqueness race · Full edition drill
- A fault test fails before the important window · Full edition drill
Session 7: Budget concurrency and Java 21 resources
Identify the executor, cancellation owner and scarce resource before changing the threading model.
Produce: A resource budget and a cancellation test with an explicit Java version note.
Free reading: Debugging Java 21 virtual-thread pinning
- Async work has nowhere to run. · Full edition drill
- More threads. The same throughput. · Full edition drill
Session 8: Make messaging and replay accountable
Locate the gap between a durable business effect and acknowledgment; distinguish publishing from consuming.
Produce: A failure-window diagram and a replay test that inspects authoritative effects.
Free reading: Handling duplicate Kafka messages without duplicate business effects
- One event. Two shipments. · Complete free drill
- The order exists. The event does not. · Full edition drill
Session 9: Use caching and signals to recover safely
Relate load, cache expiry and queueing to customer outcomes; avoid diagnosing from an average alone.
Produce: A bounded load experiment with latency distribution, correctness and stop criteria.
Free reading: Diagnosing HikariCP connection pool exhaustion
- The cache expires. The database melts. · Full edition drill
- The average hides the slow customers · Full edition drill
Session 10: Enforce authorization across every path
Distinguish login from permission to use a particular object, including cache-hit and direct API paths.
Produce: A two-user negative-test matrix for reads, updates and cached responses.
Free reading: API authorization: check owner, action and every access path
- A cache hit returns another tenant’s data. · Full edition drill
- Changing a resource ID exposes another user's record · Full edition drill
Session 11: Review readiness, shutdown and rollout
Treat process health, admission, draining and schema compatibility as different deployment contracts.
Produce: A rollout checklist with in-flight work, drain deadline and rollback conditions.
Free reading: Cloud rollouts: readiness, draining and compatible rollback
- Shutdown drops in-flight requests · Full edition drill
- An application rollback cannot read the migrated schema · Full edition drill
Session 12: Choose code and service boundaries deliberately
Use a pattern to separate a concrete responsibility, then check whether service boundaries provide useful ownership.
Produce: A design note explaining the invariant, rejected alternative and the cost of the abstraction.
Free reading: Design patterns in practice: responsibility, state and trade-offs
- Strategy selection leaks between requests · Full edition drill
- A modular monolith becomes a distributed monolith · Full edition drill
Session 13: Java 8: collector contracts and asynchronous continuations
Explain merge semantics and continuation execution before introducing parallel work.
Produce: Compare sequential and asynchronous behavior, then write a version-specific resource test.
Free reading: Java 8 streams: lifetime, duplicate keys and safe collection
- Duplicate keys abort a collector · Full edition drill
- thenApply blocks the completion thread · Full edition drill
Session 14: Java 21: virtual threads and monitor boundaries
Distinguish Java 21 behavior from newer JDK changes; identify the actual scarce resource.
Produce: A Java 21-specific experiment comparing waiting, monitor ownership and carrier availability.
Free reading: Debugging Java 21 virtual-thread pinning
- Virtual threads pin carriers inside a monitor · Full edition drill
Session 15: Capstone: capacity, consistency and recovery
Connect workload assumptions, downstream demand and restore evidence; revisit one weak decision from the core path.
Produce: A short architecture decision record with capacity assumptions, consistency needs, acceptance test and recovery gate.
Free reading: System design: workload, consistency and recovery before diagrams
- Capacity planning ignores fan-out · Full edition drill
- Backup success does not prove recovery · Full edition drill
Engineering lead · 8 sessions
Practice review gates, test ownership, incident handoffs and operational decisions. Explain who acts and what evidence permits the next step.
Prerequisite: Core path or equivalent experience with API, database, deployment and permission boundaries.
Session 1: Build tests that can reject a bad change
Test real transaction and failure windows rather than relying only on mocks or a successful response.
Produce: A regression test plan with controlled concurrency and a response lost after commit.
Free reading: Backend testing: target the failure window, not just the happy path
- A mocked repository hides a uniqueness race · Full edition drill
- A fault test fails before the important window · Full edition drill
Session 2: Enforce authorization across every path
Distinguish login from permission to use a particular object, including cache-hit and direct API paths.
Produce: A two-user negative-test matrix for reads, updates and cached responses.
Free reading: API authorization: check owner, action and every access path
- A cache hit returns another tenant’s data. · Full edition drill
- Changing a resource ID exposes another user's record · Full edition drill
Session 3: Review readiness, shutdown and rollout
Treat process health, admission, draining and schema compatibility as different deployment contracts.
Produce: A rollout checklist with in-flight work, drain deadline and rollback conditions.
Free reading: Cloud rollouts: readiness, draining and compatible rollback
- Shutdown drops in-flight requests · Full edition drill
- An application rollback cannot read the migrated schema · Full edition drill
Session 4: Choose code and service boundaries deliberately
Use a pattern to separate a concrete responsibility, then check whether service boundaries provide useful ownership.
Produce: A design note explaining the invariant, rejected alternative and the cost of the abstraction.
Free reading: Design patterns in practice: responsibility, state and trade-offs
- Strategy selection leaks between requests · Full edition drill
- A modular monolith becomes a distributed monolith · Full edition drill
Session 5: Capstone: capacity, consistency and recovery
Connect workload assumptions, downstream demand and restore evidence; revisit one weak decision from the core path.
Produce: A short architecture decision record with capacity assumptions, consistency needs, acceptance test and recovery gate.
Free reading: System design: workload, consistency and recovery before diagrams
- Capacity planning ignores fan-out · Full edition drill
- Backup success does not prove recovery · Full edition drill
Session 6: Review a change with a comparable canary
Identify whether the evidence supports expanding a deployment.
Produce: An acceptance gate comparing like traffic, correctness and a rollback trigger.
Free reading: Backend testing: target the failure window, not just the happy path
- A canary compares traffic with different mixes — implementation review · Full edition drill
Session 7: Give flaky tests an owner and exit condition
Keep temporary exceptions from silently becoming the test strategy.
Produce: A quarantine record with owner, diagnostic evidence and reinstatement criteria.
Free reading: Backend testing: target the failure window, not just the happy path
- A flaky test quarantine has no owner — implementation review · Full edition drill
Session 8: Hand off an incident with uncertain outcomes
Preserve business uncertainty instead of converting every failure into a retry.
Produce: A handoff separating known effects, uncertain effects, actions and next owners.
Free reading: API retries: identity, deadlines and uncertain outcomes
- Circuit breaker errors erase an uncertain result — recovery exercise · Full edition drill
Software architect · 8 sessions
Work from constraints to capacity, ownership, consistency, migration and recovery. Keep cloud and cybersecurity decisions explicit.
Prerequisite: Core path or equivalent experience with transactions, retries, replay and service operations.
Session 1: Define API outcomes, retries and deadlines
Separate transport failure from a known business outcome and give every retry an identity and time budget.
Produce: An API contract covering success, rejection, uncertain completion and retry.
Free reading: API retries: identity, deadlines and uncertain outcomes
- The double-click becomes a double charge. · Full edition drill
- A timeout outlives the caller's deadline · Full edition drill
Session 2: Enforce authorization across every path
Distinguish login from permission to use a particular object, including cache-hit and direct API paths.
Produce: A two-user negative-test matrix for reads, updates and cached responses.
Free reading: API authorization: check owner, action and every access path
- A cache hit returns another tenant’s data. · Full edition drill
- Changing a resource ID exposes another user's record · Full edition drill
Session 3: Review readiness, shutdown and rollout
Treat process health, admission, draining and schema compatibility as different deployment contracts.
Produce: A rollout checklist with in-flight work, drain deadline and rollback conditions.
Free reading: Cloud rollouts: readiness, draining and compatible rollback
- Shutdown drops in-flight requests · Full edition drill
- An application rollback cannot read the migrated schema · Full edition drill
Session 4: Choose code and service boundaries deliberately
Use a pattern to separate a concrete responsibility, then check whether service boundaries provide useful ownership.
Produce: A design note explaining the invariant, rejected alternative and the cost of the abstraction.
Free reading: Design patterns in practice: responsibility, state and trade-offs
- Strategy selection leaks between requests · Full edition drill
- A modular monolith becomes a distributed monolith · Full edition drill
Session 5: Capstone: capacity, consistency and recovery
Connect workload assumptions, downstream demand and restore evidence; revisit one weak decision from the core path.
Produce: A short architecture decision record with capacity assumptions, consistency needs, acceptance test and recovery gate.
Free reading: System design: workload, consistency and recovery before diagrams
- Capacity planning ignores fan-out · Full edition drill
- Backup success does not prove recovery · Full edition drill
Session 6: CQRS: own the lag window
Decide where eventual consistency is acceptable and who resolves stalled views.
Produce: A read-after-write contract and stale-projection detection gate.
Free reading: System design: workload, consistency and recovery before diagrams
- CQRS adds an untracked lag window — architecture trade-off · Full edition drill
Session 7: Active-active: establish write ownership
Check which invariants survive concurrent regional writes.
Produce: A conflict-resolution ADR with recovery authority and rejected alternatives.
Free reading: System design: workload, consistency and recovery before diagrams
- Active-active writes create conflicting ownership — recovery exercise · Full edition drill
Session 8: Strangler migration: one authoritative operation
Prevent a transitional architecture from executing one intent twice.
Produce: A migration map with routing ownership, reconciliation and rollback boundary.
Free reading: Cloud rollouts: readiness, draining and compatible rollback
- Strangler migration routes one operation twice — recovery exercise · Full edition drill
Optional specializations after your main path
Web/client integration
Prerequisite: API contracts and authorization
Produce: A client state diagram covering stale responses and uncertain write outcomes.
- An older response overwrites a newer search · Full edition drill
- Error pages erase a completed submit · Full edition drill
Data pipeline integrity
Prerequisite: SQL, event replay and recovery
Produce: A source-version, replay and reconciliation contract with a deletion check.
- CDC updates arrive out of order · Full edition drill
- The inventory cannot explain its balance · Full edition drill
AI integration safety
Prerequisite: API contracts, testing and authorization
Produce: A tool-permission matrix and a held-out evaluation that checks effects and provenance.
- Assistant tools trust a model-supplied owner ID · Full edition drill
- Evaluation scores hide dataset leakage · Full edition drill