Fairplay Interview Prep
Module 15

The interview playbook

Modules 01–14 gave you the knowledge. This one turns it into performance: how interviews probe projects, how to structure answers, ready-made stories from real things that happened in your code, exactly how to talk about the numbers, how to extend your projects in a system-design round, and a rapid-fire drill to run until the answers come out without thinking.

P1P2P3· about 2 hours, then practice

By the end you can

  • Deliver a pitch tailored to the role you're interviewing for.
  • Answer any "why" question with the what → why → trade-off → evidence shape.
  • Tell at least eight true STAR stories about bugs, decisions and misses.
  • Talk about every number with the right confidence: measured, designed or planned.
  • Extend Fairplay in a system-design round (scale, multi-region, new features).
  • Survive a 40-question rapid-fire round.

1. How interviewers probe a project

Almost every project discussion follows the same funnel. Knowing it means you're never surprised:

 1. "Tell me about a project."            → your pitch (30 s, then pause)
 2. "Tell me more about X."               → one component, one level deeper
 3. "Why did you do it that way?"         → the decision and the alternative you rejected
 4. "What happens if ...?"                → failure modes, concurrency, scale
 5. "How do you know it works?"           → tests, measurements, numbers
 6. "What would you do differently?"      → limitations and next steps, honestly

Most candidates prepare level 1 and stall at level 3. You've prepared every level: each module's Q&A is organised from Basic (levels 1–2) to Curveball (levels 4–6).

The two-level answer

Answer in one or two sentences first, then offer depth: "...so I lock the participants in sorted order. Want me to go into why the ordering matters?" It keeps you concise, lets the interviewer steer, and signals that there's more underneath. Long monologues are the most common way good candidates lose interviews.

2. Answer shapes

For technical "why" questions: what, why, trade-off, evidence

StepExample: "Why Redis for the leaderboard?"
What"Ranks come from a Redis sorted set, while PostgreSQL stays the source of truth."
Why"Rank is 'how many players are ahead of me'. In SQL that's a count over everyone ahead, O(N). A sorted set's skip list answers it in O(log N)."
Trade-off"Now I have two stores to keep consistent. I only update Redis after the database commits, and rebuild it from PostgreSQL at startup. The gap is that an in-memory event can be lost on a crash, which an outbox would close."
Evidence"On a million players, p95 went from 18 seconds to 63 milliseconds, measured with k6."

For behavioural questions: STAR

Situation (one sentence of context) → Task (what you had to achieve) → Action (what you did, with specifics; this should be the longest part) → Result (what happened, ideally with a number, plus what you learned).

3. Lead with the right project for the role

RoleLead withEmphasise
Java / backend engineerArenaREST design, transactions and locking, JWT and refresh rotation, Redis consistency, tests against real PostgreSQL, the benchmark
Data / streaming / platformTelemetryKafka partitioning, Kafka Streams windows and state, exactly-once with the sequence proof, the chaos test, lag and failover analysis
AI / LLM engineerJudgeThe hand-written agent loop, guarded tools, structured output, caching layout, routing, the deterministic policy, evaluation design, resilience. And the honest status of the numbers
Generalist / new gradThe whole platform (module 01 pitch)How three services fit together, contracts, defence in depth, testing discipline, honesty about results

Rehearse all the pitches in module 01, section 8. Then pick the opening project for this interview the night before.

4. Your STAR story bank

These all actually happened in your projects. Learn the skeleton of each; pick 2–3 for any "tell me about a time..." question. Mapping: a bug you found (d, e, f, h, l), a hard technical problem (a, f), a time you disagreed with a requirement (a, j), a failure (b, c), a trade-off (j, k).

(a) The repartition trap: Telemetry Hard problem

S: The detector had to aggregate about 24,000 events per second in hopping windows. T: The specification's code grouped the output of my parse processor for the windows. A: I noticed that KStream#process marks its output as possibly key-changing, so Kafka Streams would insert two internal repartition topics and push every event through the broker twice more. I re-parsed the raw stream with key-preserving mapValues and the same pure parser, so both paths accept identical records, and added a topology-shape test plus an end-to-end test so nobody "fixes" it back. I kept one explicit, named repartition for flags, which are rare. R: No window repartition topics; the broker carries each event once. I documented it as a deliberate departure from the spec. Lesson: read what the framework infers from your code, not just what the code says.

(b) The experiment that didn't confirm my hypothesis: Telemetry Failure / honesty

S: I wanted to show exactly-once beats at-least-once under a node kill. T: Run both modes with the same seed and the same kill, and compare per-player duplicates. A: The exactly-once run was perfect, but at-least-once also showed zero duplicates. I checked the logged configuration to confirm the mode really changed, then reran with the state-store cache off, the worst case, and still got zero. R: I reported exactly that in the README instead of tuning until it "worked", with the likely explanation (the kill has to land in a tiny window) marked as unverified, and the proper fix: many automated kills or targeted fault injection. A negative-control test proves the checker can detect duplicates. Lesson: a surprising result is information, and reporting it honestly is part of the job.

(c) Missing the failover target: Telemetry Failure

S: The target was failover under 10 seconds after killing one of three detector instances. T: Measure it and meet it. A: I lowered the session timeout to the 6-second minimum and added standby replicas. The measured failover was 14.4 s. I read the survivors' logs and built a timeline: about 5 s to detect the dead member, then three back-to-back rebalances (task migration happens in steps, each triggering a follow-up rebalance) adding 8–9 s. I also saw lag peak near 380,000 because two instances had only about 5,000 events/s of headroom. R: I reported the miss with the root cause and concrete next steps (warm-up and probing tuning, the new rebalance protocol, static membership, more headroom). Lesson: the obvious knob (the timeout) wasn't the main cost; measuring found the real one.

(d) The app crashed on an empty database: Arena Bug

S: Running the full suite with Docker for the first time. T: Get everything green. A: Startup failed. The percentile service runs percentile_cont on ApplicationReadyEvent; with no eligible players it returns SQL NULL, and Spring's JdbcClient rejects a null result from an extractor, so the exception killed startup. I made the extractor return Optional and treat "no distribution yet" as null percentiles. R: Startup works on an empty database, and there's a test for it. Lesson: aggregates over empty sets return NULL, and startup hooks need to tolerate an empty world.

(e) Spring replaced my list instead of merging it: Arena Bug

S: No integration test could load the application context. T: Find out why. A: The test base class overrode only arena.accounts.services[0].password and [1].password. Spring Boot doesn't merge lists across property sources: the higher-priority source replaced the whole list, so the usernames became null and validation failed at startup. I repeated the usernames in the test properties, left a comment explaining why, and corrected the same snippet in the spec. R: All integration tests loaded. Lesson: know the property precedence rules; fail-fast validation turned a silent misconfiguration into a clear startup error.

(f) Concurrent duplicate matches returned 500: Arena Hard problem / bug

S: POST /matches is idempotent on externalId: a replay returns 200. T: Make it hold under concurrency, not just for sequential retries. A: Two identical requests could both pass the "already exists?" check; the loser then hit the unique constraint, and because PostgreSQL aborts a transaction on any error, I couldn't look up the winner inside it. I moved the work into a TransactionTemplate, caught DataIntegrityViolationException after rollback, fetched the winner's match and returned 200. R: Retries from Kafka's at-least-once bridge are safe even when they race, and there's a test. Lesson: check-then-act is never enough; the database constraint is the real guarantee, and you design around how your database reports violations.

(g) The order of two checks mattered: Arena refresh tokens Bug / security

S: Refresh tokens rotate, and reusing a revoked token revokes all of a player's tokens. T: Implement exactly the specified behaviour. A: I realised that if the reuse check ran before the expiry check, a user returning with an old, expired and already-rotated token would trigger mass revocation and be logged out everywhere for no reason. I reordered the checks (expired is a plain 401 first) and added a test. The revocation itself runs in a REQUIRES_NEW transaction so it survives the rollback caused by the 401. R: Reuse detection only fires on genuinely suspicious replays. Lesson: in security code the order of checks is behaviour. Be ready for the follow-up: "what if two refreshes with the same token arrive at once?" The honest answer is that the row isn't locked, so both can succeed, and the fix is a conditional UPDATE ... WHERE revoked_at IS NULL (module 16, section 2.1). Raising it yourself turns a weakness into a strength.

(h) 100% coverage, but the app couldn't start: Telemetry verifier Bug

S: The verifier module had 100% line coverage. T: Run it for real. A: It failed at startup: VerifierRunner had a public constructor and a package-private one (with a Clock, for tests), and Spring can't choose between two constructors. Unit tests built it with new, so they never saw it. I added @Autowired to the public constructor and a VerifierContextTest that starts the whole context. R: Fixed, and wiring is now tested. Lesson: "coverage only says a line ran". Keep at least one test that starts the real application.

(i) Three JVMs froze the laptop: Telemetry Ops

S: Running three detector replicas plus Kafka and Grafana in Docker Desktop. T: Keep the stack stable for 5-minute measured runs. A: The machine stalled. Each JVM, with no container limit, sized its heap at 75% of the whole Docker VM, so together they over-committed memory. I added mem_limit: 1g per app container so the container-aware JVM sizes its heap from 1 GB. R: Stable runs. Lesson: always give JVM containers explicit limits; ergonomics follow the limit you set, or the host's if you don't.

(j) An ambiguous requirement: the Judge's confidence rule Disagreement / judgement

S: The spec said to escalate to the stronger model when confidence < 0.85. T: Implement routing that saves cost without hurting quality. A: The prompt defines confidence as the probability of cheating, so a confident CLEAR is about 0.05. Read literally, every CLEAR and WATCH would escalate, which defeats the cost goal. I implemented certainty = max(c, 1 − c) < 0.85, marked it // DECISION: in code, explained it in the README, flagged it as an open question for the owner, and kept it a one-line switch so the evaluation can compare both readings. R: Routing that matches the intent, with the decision transparent and reversible. Lesson: when a requirement contradicts its own goal, don't silently pick; decide, document, make it testable and escalate.

(k) Retry amplification: the Judge Trade-off

S: Calls to the Claude API need retries, a circuit breaker and a rate limiter. T: Make outages safe without making them worse. A: The SDK retries by default; stacking my Resilience4j retry on top would multiply attempts against a struggling provider and hide them from my breaker and metrics. I set the SDK's maxRetries(0), composed retry, breaker and limiter with retry outermost, classified exceptions (5xx and I/O open the breaker; 400/401/429 don't), and let the Kafka error handler hold flags during long outages. R: ResilienceIT shows 20 of 20 flags judged through a 20-second outage, none dead-lettered. Lesson: retry in one place, and classify failures carefully.

(l) A test that broke with the calendar: Arena Bug

S: TokenServiceTest started failing without any code change. T: Find out why. A: The test issued tokens with a fixed clock set to a date that had since passed, but the JWT decoder validated expiry against the system clock, so the "fresh" token now looked expired. I gave the decoder's timestamp validator the test's fixed clock. R: The test is deterministic again. (Be precise if asked: that test passes alone; the full suite hasn't been re-run since the fix.) Lesson: injecting a Clock only works if every time-dependent component uses it, including library ones.

5. Talking about numbers: measured, designed, planned

Use three words precisely, and interviewers will trust every number you give:

ClaimStatusHow to say it
Redis p95 63.5 ms vs PostgreSQL 18.0 s on 1M playersMeasured"Measured with k6, 200 virtual users, one machine with the load generator on it, third of three runs."
~24,900 events/s, recall 100% (50/50), FPR 0.11%Measured"One 5-minute run, seed 42, 1,000 players. The one false positive was a genuinely excellent PRO player, exactly the case the Judge exists for."
0 lost, 0 duplicated across a mid-run kill (7,466,329 events)Measured"Verified per player against the simulator's manifest, with a negative control proving the check can fail."
Failover 14.4 sMeasured, missed (< 10 s)"I missed that target. Here's the timeline and what I'd change."
Exactly-once beats at-least-onceNot shown"My comparison didn't show a difference; here's why that might be and how I'd test it properly."
Test counts and coverageMeasured"Telemetry 269 unit + 17 integration; the Judge's modules 96–97% coverage; Arena 71 tests at 89.6%, with one small fix since that run."
Judge: 20/20 flags through an injected outageMeasured"Fault-injection test with WireMock."
Judge precision, recall, cost saving, latencyPlanned (imaginary placeholders)"Not measured yet. The harness is built and tested; the dataset needs an API key and a special Telemetry run. Here's how it'll be measured."
Judge request shape accepted by the real APIDesigned, unverified"Modelled in WireMock stubs; the one live smoke test is the next thing to run."
All three projects working together end to endDesigned and tested hop by hop, never run live together"Each hop is tested against real infrastructure or a faithful stub; the first live run of the whole chain needs an API key and is my next step."
Broker fault toleranceNot covered"Single broker, replication factor 1 locally. I tested consumer failure, not broker failure."
Never do this

Never quote the Judge's 96.6% precision, 84.8% cost reduction or 6.1 s latency as results. They are explicitly labelled "optimal imaginary values" in the README. If an interviewer read your README, they will check. If they didn't, you'd be building on sand. Saying "not measured yet, and here's exactly how I'll measure it" is a strong answer.

6. "Did you use AI tools to build this?"

Expect this question, especially for the Judge. Your project folders contain specification documents and assistant working notes (CLAUDE.md, handoff.md), which suggests AI-assisted development. Whatever your actual process was, the right approach is the same: answer plainly and truthfully, then show ownership. Interviewers increasingly accept AI-assisted work. What they reject is a candidate who can't explain their own code, or who hides how it was made.

A useful structure, adapted to what you really did:

  1. State it plainly: which tools you used and for what.
  2. Show where your judgement went: the requirements and specs, the decisions (the DECISION: comments), what you verified by running and measuring, what you rejected or corrected.
  3. Prove understanding: offer to walk through any part in depth. That is exactly what these 15 modules prepare you for.
One honest framing (adjust it to the truth)

"Yes, I used an AI coding assistant heavily, the way many teams do now. I wrote detailed specifications, reviewed the output, ran everything, and made the calls where the spec was wrong or ambiguous, like the repartition fix and the confidence rule. I measured the results myself and reported the misses. Pick any file and I'll walk you through it."

Then the most important part: make that last sentence true. Before interviews, open the key files listed in module 01, section 3, and make sure you can explain each one line by line.

7. Per-project deep-dive drills

Ten hard follow-ups per project, with the module that holds the full answer. Practise answering each in under a minute.

Arena

  1. Why lock participants in sorted order? (06)
  2. Why TransactionTemplate in recordMatch? (07)
  3. How does refresh-token reuse detection work? Why REQUIRES_NEW? What about two concurrent refreshes? (05, 07, 16)
  4. How is Redis kept consistent? What can still go wrong? (08)
  5. Why is the database rank O(N), and why did k6 see 15 s vs 1.5 s server-side? (06)
  6. Is the trigger enough to make the audit log tamper-proof? (06)
  7. Why COLLATE "C"? (06, 08)
  8. 401 vs 403, 409 vs 422 in your API? (04)
  9. Why HS256 and not RS256? (05)
  10. What would you add next? (outbox, rate limiting, Kafka events) (08, 05)

Telemetry

  1. Why key by player id, and why 6 partitions? (09)
  2. Why hopping windows of 5 s / 1 s with 2 s grace? (10)
  3. The repartition trap. (10)
  4. How does exactly_once_v2 work? (10)
  5. How did you prove no loss or duplication? (10)
  6. Why did failover take 14.4 s? (10)
  7. Why parse in the topology instead of using a deserialization handler? (10)
  8. Why must consumers use read_committed? (09)
  9. How does the bridge decide retry vs DLT? (09, 12)
  10. How does the detector avoid reading the ground truth? (10)

Judge

  1. Walk through the agent loop and its limits. (11)
  2. How does the tool guard work? Why errors as results? (11)
  3. How is the output guaranteed valid? (11)
  4. Caching layout: what breaks the cache? (11)
  5. Why route Haiku to Sonnet, and why a fresh conversation? (11)
  6. The symmetric confidence decision. (11, 15)
  7. Decorator order and maxRetries(0). (12)
  8. What happens during a 10-minute Claude outage? (12)
  9. How would you evaluate it? Precision vs recall? (11)
  10. What's measured, and what isn't? (15)

Cross-cutting

  1. Why three services, not one? (01)
  2. What stops an innocent ban? (01)
  3. At-least-once plus idempotency: where? (09, 12)
  4. Why Testcontainers? (13)
  5. Why inject a Clock? (02)
  6. Virtual threads: where, and why the semaphore? (02)
  7. Records: where and why? (02)
  8. Boot 4 differences you hit. (03)
  9. Your Dockerfile and Compose setup. (14)
  10. Percentiles, metrics and dashboards. (14)

8. System-design extensions

Many interviews end with "how would you scale this?" or a classic design question that your projects already answer. Use this skeleton: requirements and numbers → high-level boxes → data model → the hard part → scaling → failure modes → trade-offs.

"Design a global game leaderboard" (you've built one)

"Scale Fairplay to 10 million players and 1 million events per second"

PartChanges
KafkaA multi-broker cluster, RF 3, min.insync.replicas=2; plan partition counts up front (for example 60–120) since adding them later remaps keys; Avro/Protobuf with a schema registry; tiered storage for retention
DetectorMore instances (up to the partition count); keep repartition topics off the hot path; tune RocksDB and the cache; standby replicas; faster rebalancing settings; per-tier thresholds to cut false positives
JudgeThroughput is bounded by LLM rate limits and cost: prioritise flags by score, add a budget guard, batch offline evaluation (Batch API), keep cheap pre-checks first; scale consumers up to partitions; human-review tooling for the review queue
ArenaStateless app instances behind a load balancer; PostgreSQL read replicas, then sharding by player id; connection pooling with PgBouncer; an outbox to Kafka for domain events (other services subscribe instead of polling); rate limiting at a gateway; RS256 tokens from a central auth service
ObservabilityDistributed tracing across HTTP and Kafka (trace ids in headers); SLOs and alerts on lag, DLT growth, breaker state, p99 latency

"Design a real-time fraud or cheat detection system"

That's Telemetry plus the Judge: keyed event stream → stateful windowed features → cheap rules flag candidates → enrichment by join → de-duplication → an expensive second stage (an ML model or LLM) only on candidates → a deterministic policy → action with an audit trail and appeals; ground truth kept separate for evaluation; precision prioritised over recall where false positives hurt people.

"Design a rate limiter"

Connect to what you know: a token bucket (like Resilience4j's limiter: N permits per period), or a sliding window in Redis using a sorted set of request timestamps per client (ZADD now, ZREMRANGEBYSCORE older than the window, ZCARD to count), done atomically in a Lua script, returning 429 with Retry-After. It's also the first item on Arena's "what's next" list.

9. Questions to ask the interviewer

10. Red flags to avoid

Don't saySay instead
"Kafka guarantees exactly-once.""Exactly-once within Kafka read-process-write via transactions; at-least-once plus idempotency at the boundaries."
"JWTs are encrypted.""Signed, not encrypted; the payload is readable."
"Redis is always in sync with the database.""Updated after commit; eventual, with known gaps and a rebuild."
"100% coverage, so it's bug-free.""Coverage says a line ran; here's how I test behaviour and wiring."
"The Judge has 96.6% precision.""Not measured yet; here's the evaluation design."
"I used Spring because it's popular.""Spring gave me DI, transaction management and security integration; here's where it mattered."
Blaming the tool: "Kafka was being weird.""The rebalance protocol migrates tasks in steps; here's the timeline from the logs."
A three-minute monologueThe two-level answer: short, then offer depth.

11. The rapid-fire drill (40 questions)

Answer each out loud in one or two sentences, then open it to check. Tick the box when it comes instantly. Run the whole drill on the morning of the interview.

1. What is a record? Java

An immutable data carrier with a generated constructor, accessors, equals, hashCode and toString; validate in the compact constructor.

2. equals/hashCode contract? Java

Equal objects must have equal hash codes; hash collections rely on it.

3. Why BigDecimal for money? Java

Exact decimal arithmetic with explicit rounding; double can't represent most decimals exactly. Compare with compareTo.

4. volatile vs AtomicLong? Java

volatile gives visibility only; AtomicLong gives atomic read-modify-write.

5. Virtual threads: when useful? Java

Many concurrent blocking I/O tasks; not CPU-bound work. Bound downstream concurrency with a Semaphore.

6. Why inject a Clock? Java

Deterministic, testable time logic.

7. What does a sealed interface give you? Java

A closed set of subtypes, so exhaustive switches with no default.

8. IoC / DI in one line? Spring

The container builds objects and injects their dependencies, through constructors in my code.

9. Why doesn't @Transactional work on self-invocation? Spring

It's proxy-based; an internal call bypasses the proxy.

10. What does @TransactionalEventListener(AFTER_COMMIT) do? Spring

Runs the listener only if and after the transaction commits.

11. Property precedence: env var or YAML? Spring

The environment variable wins over packaged YAML.

12. 401 vs 403? REST

Not authenticated vs authenticated but not allowed.

13. How is POST /matches idempotent? REST

The externalId idempotency key plus a UNIQUE constraint; 201 on create, 200 on replay.

14. What is ProblemDetail? REST

The RFC 9457 standard JSON error body; Arena adds a stable code.

15. bcrypt vs SHA-256? Security

bcrypt is salted and deliberately slow for passwords; SHA-256 is fine for high-entropy random tokens.

16. Why is CSRF off? Security

A bearer header and a stateless API: no ambient cookie credential.

17. Refresh reuse detection? Security

A revoked token presented again revokes all of the player's tokens (REQUIRES_NEW) and returns 401 REFRESH_TOKEN_REUSED.

18. PostgreSQL's default isolation level? DB

Read Committed.

19. How do you prevent deadlocks? DB

Acquire locks in a consistent global order (sorted UUIDs).

20. Optimistic vs pessimistic locking? DB

Version check at write (fail and retry) vs row lock at read (wait).

21. What is the N+1 problem? DB

One query for N rows plus one per row for a lazy association; fix with join fetch or projections.

22. Why ddl-auto: validate? DB

Flyway owns the schema; Hibernate only checks the mappings.

23. ZREVRANK complexity? Redis

O(log N), from a skip list with spans.

24. What is the dual-write problem? Redis

Two systems with no shared transaction; one can succeed while the other fails.

25. Transactional outbox? Redis

Write the event in the same database transaction; a relay publishes it at least once to idempotent consumers.

26. Kafka ordering guarantee? Kafka

Per partition; key by entity.

27. Max useful consumers in a group? Kafka

The number of partitions.

28. Idempotent producer prevents? Kafka

Duplicates from the producer's own retries (producer id plus sequence).

29. read_committed? Kafka

Skip records from aborted transactions; read up to the last stable offset.

30. Compaction keeps? Kafka

At least the latest value per key; tombstones delete keys.

31. KStream vs KTable? Streams

Independent events vs latest value per key.

32. When does Streams repartition? Streams

A stateful op or join after a possibly key-changing step (map, selectKey, process).

33. How is state fault-tolerant? Streams

Changelog topics plus standby replicas.

34. How did you prove exactly-once? Streams

Per-player seq vs manifest finalSeq; 7,466,329 = 7,466,329, 0 dup, 0 gaps; a negative control.

35. Who executes a tool call? LLM

My code; the model only requests it.

36. What breaks prompt caching? LLM

Any change in the prefix before the breakpoint (tools, system, rulebook).

37. "Model recommends, code acts" means? LLM

A pure DecisionPolicy maps the verdict to one action; auto-ban only at ≥ 0.90 without review.

38. Circuit breaker states? Resilience

Closed → open (fail fast) → half-open (trial calls) → closed or open again.

39. Decorator order? Resilience

Retry outermost, then circuit breaker, then rate limiter, then the call.

40. Surefire vs Failsafe? Testing

*Test in the test phase vs *IT in integration-test and verify.

12. A 45-minute mock interview you can run

  1. 0–5 min: "Tell me about yourself and a project." (Pitch, 2-minute version.)
  2. 5–20 min: The interviewer picks one project and runs the funnel (levels 2–6) using the deep-dive drill list above.
  3. 20–30 min: Technology probe. Five random questions from any module's Q&A (Intermediate and Deep).
  4. 30–40 min: System design: "Scale Fairplay to 10 million players" or "Design a leaderboard".
  5. 40–45 min: Behavioural: two STAR stories ("a bug you found", "a time you missed a goal"), then your questions.

Score yourself (1–5) on: concise first answers; correct terminology; a concrete example from your code in every answer; trade-offs named unprompted; numbers stated with their status. Anything under 4: reread that module's cheat sheet and repeat.

13. Checklists

The week before

  • Finish every module's quiz with no wrong answers.
  • Tick at least 80% of all "I can answer this out loud" boxes (progress shows on the start page).
  • Record yourself giving all three pitches; listen back once.
  • Re-run ./mvnw verify in Arena so "all green" is true again.
  • If you can, do the first live end-to-end run (the Judge README's "Run the whole system" order: Arena, Telemetry with ARENA_ENABLED=true, the Judge with an API key, then the simulation). If you can't, be ready to say it hasn't been done.
  • Bring up each stack once with docker compose up; take screenshots of Swagger UI and the Grafana dashboard to show if asked.
  • Open the key files listed in module 01, section 3, and explain each aloud.

The morning of

  • Read the role-specific project's cheat sheets.
  • Run the 40-question rapid-fire drill once.
  • Re-read section 5 (numbers) and section 10 (red flags).
  • Choose the 3 STAR stories you'll use most.
  • Prepare 2 questions to ask.
  • Remember the two-level answer: short first, then offer depth.

14. The numbers card (all measured unless marked)

Arena

  • 18 endpoints; 3 roles; access token 15 min, refresh 7 d; bcrypt cost 10; service-ban floor 0.80.
  • k6, 1,000,000 players, 200 VUs, 60 s after a 15 s warm-up: Redis p50 33.07 ms, p95 63.53 ms, p99 90.21 ms, 5,764 req/s vs DB p50 15.62 s, p95 18.01 s, p99 29.39 s, 12.6 req/s. Server-side means: 2.9 ms vs 1.54 s.
  • Redis rebuild of 1M players: 22.6 s. Hikari pool: 20.
  • 71 tests, 89.6% line coverage (gate 85%); re-run pending after a small fix.

Telemetry

  • 1,000 players (5% cheaters, 2% pros), seed 42, 5 min, 3 detectors × 2 threads, 6 partitions.
  • ~24,900 events/s produced; 7,466,329 events; 7,503 malformed injected; 0 failed sends.
  • Recall 100% (50/50); FPR 0.11% (1 of 950: a PRO player at score 0.538); median latency AIMBOT 3.9 s, SPEEDHACK 0.9 s.
  • Exactly-once: 0 lost, 0 duplicated, 1,000/1,000 players pass. At-least-once: also 0 (comparison inconclusive).
  • Failover 14.4 s (target < 10 s, missed); lag peak ~380,000; ~2 min to drain.
  • 269 unit + 17 integration tests; coverage 100 / 99.2 / 100 / 100%.

Judge

  • Limits: 6 turns, 8 tool calls, 1,500 tokens; auto-ban ≥ 0.90; escalate when certainty < 0.85; 4 tools.
  • Resilience: retry 4 attempts (1 s ×2, ±50%, cap 20 s); breaker 20 / 10 / 50% / 30 s / 3; limiter 120 per minute; Kafka retry every 5 s, forever.
  • Measured: 20/20 flags judged through a 20 s outage, none dead-lettered. Tests: 194 + 77 + 12 IT + 105 + 1 IT; coverage 97.2 / 96.9 / 96.2%.
  • Not measured: precision, recall, cost, latency (imaginary placeholders). The live smoke test has not been run.
Last word

Confidence in an interview doesn't come from knowing everything. It comes from knowing exactly what you know: what you built, why, what you measured, and where the edges are. You now have all four. Go through the modules, tick the boxes, say it out loud, and you'll walk in ready.

Saved in this browser.