Final Readiness Checklist

You are ready for the interviews you’re targeting only when every box below is honestly checked. This is binary, not aspirational.

Algorithmic Solving

  • Solve LeetCode Easy in <12 minutes (90% success rate over 50 recent problems)
  • Solve LeetCode Medium in 25–35 minutes (75% success rate over 100 recent problems)
  • Solve LeetCode Hard in 45–60 minutes (50% success rate over 50 recent problems)
  • Recognize the pattern within 2 minutes of reading any LeetCode Medium
  • Derive a non-trivial optimization without seeing it before, on at least 30 unfamiliar problems

Brute Force & Optimization

  • Can state the brute force in <2 minutes for any unseen problem
  • Can compute brute force complexity correctly without aid
  • Can derive optimal complexity from constraints alone
  • Have written brute-force-comparator tests for at least 10 problems

Correctness & Proofs

  • Can state DP recurrences with base cases and evaluation order on the spot
  • Can produce an exchange argument for at least 5 greedy problems
  • Can produce a counterexample to a wrong greedy in <5 minutes
  • Have proved correctness for at least 20 different solutions (greedy, DP, graph)

Code Quality

  • Can write binary search, BFS, DFS, union-find, topological sort, and Dijkstra from scratch error-free in <10 minutes each
  • Code passes the self-review checklist on every solve
  • No off-by-one bugs in 10 consecutive binary search problems
  • No mutable default argument / shared-state bugs in 10 consecutive recursion problems

Testing

  • Run the universal edge-case checklist as reflex on every problem
  • Have written stress-test verifiers for at least 5 problems
  • Catch your own bugs before submission on 80%+ of problems
  • Property-based tested at least 3 implementations

Patterns

  • All 28 patterns in phase-02-patterns/ — recognize signals in <2 minutes
  • Have solved at least 5 problems per pattern
  • Can explain when each pattern does not apply
  • Can produce a clean template for each pattern from memory

Data Structures

  • Internal representation, complexity, and memory behavior of all foundation DS in phase-01-foundations/
  • Can choose between hashmap / sorted array / heap / BST given access patterns
  • Can implement segment tree, Fenwick tree, trie, LRU cache from scratch
  • Understand iterator invalidation, hash collision behavior, and resize cost in your primary language

Graph Algorithms

  • BFS, DFS, Dijkstra, topological sort, union-find — implement from scratch in <10 minutes each
  • Recognize when 0-1 BFS, Bellman-Ford, or A* is the right choice
  • Can model a word problem as a graph (nodes + edges + weight) in <3 minutes
  • Have completed all 9 product-style labs in phase-04-graphs/labs/

Dynamic Programming

  • Can derive state + transition + base case for unseen DP problems
  • Have completed brute-force → memo → tabulated → space-optimized for at least 15 problems
  • Recognize 1D / 2D / interval / tree / digit / bitmask / knapsack signals
  • Can articulate why greedy fails for a given DP problem

Language & Runtime

  • Read your primary language’s track in phase-09-language-runtime/ end to end
  • Can explain stack vs heap, scope/lifetime, value vs reference semantics fluently
  • Can explain GC / ownership behavior of your language
  • Can explain hash collision and resize behavior of your language’s hashmap
  • Have used the language’s profiler at least once on real code

Concurrency

  • Can identify race conditions and deadlocks in code review
  • Have implemented thread pool, rate limiter, and bounded blocking queue from scratch
  • Can articulate memory visibility / happens-before in your language
  • Have used the race detector / equivalent at least once

Practical Engineering

  • Completed at least 12 of the 23 labs in phase-08-practical-engineering/
  • Can answer all 13 standard follow-ups (10M users, distributed, concurrency, race testing, metrics, logging, debugging, partial failure, memory leaks, extensibility, backpressure, retries, deduplication) on demand
  • Can sketch a small system (LRU cache, rate limiter, autocomplete) on a whiteboard in 30 minutes

Communication

  • Restate every problem before coding
  • Ask 3+ clarifying questions per problem
  • Narrate intent at decision points (not low-level mechanics)
  • Recover from mistakes without flustering
  • Handle hints gracefully and integrate them
  • Close every solve with a clean summary

Mock Interview Performance

Failure Analysis

  • Maintain a failure log per FAILURE_ANALYSIS.md
  • Top 3 personal failure categories identified
  • At least 2 weeks of focused drilling on top failure category complete
  • Re-test results show measurable improvement

Spaced Repetition

  • Active spaced repetition rotation per SPACED_REPETITION.md
  • At least 50 problems graduated to Tier 6
  • No overdue reviews more than 1 week old

Recovery & Stuck Protocol

  • Never go silent for >60 seconds in a mock
  • Use the stuck protocol explicitly when stuck
  • Recover from a wrong direction in <3 minutes
  • Ask for hints professionally without losing composure

Production Awareness

  • Can extend any solved problem with: scale to 10M, make distributed, handle partial failure, add observability
  • Can articulate tradeoffs (memory vs latency, consistency vs availability, accuracy vs speed)

Targeted Roles

Beyond the universal checklist, additional criteria by role:

FAANG / Big Tech

  • All universal items
  • mock-05 + mock-06 passed twice with different problems

Infrastructure / Backend / Platform

  • All universal items
  • mock-08 + mock-10 passed
  • All Phase 8 labs complete

Distributed Systems

  • All universal items
  • mock-08 + mock-10 + mock-11 passed
  • Phase 8 + Phase 4 (graph) labs complete

Compiler / Runtime

  • All universal items
  • mock-09 passed twice
  • Phase 9 fully complete for primary language
  • Phase 3 (advanced DS) labs complete

Quant / HFT

Senior / Staff / Principal Practical

  • All universal items
  • mock-07 + mock-08 passed twice each
  • All Phase 8 labs complete with full follow-up answers
  • Code quality bar unwaveringly met

Competitive Programming

Honesty Test

For every checked box, ask: “Could I do this right now, cold, with no warm-up?”

If the answer is “after I review my notes” — uncheck it. Notes don’t come into the interview.

If the answer is “if I had a good day” — uncheck it. Interview days are sometimes bad days.

Honesty here is the difference between feeling ready and being ready.