Study roadmap · coding practice
A paced DSA roadmap with checkpoints
Pick a calendar track, learn high-return patterns, and mark a milestone only when its exit gate holds on unseen problems. Trackers below save progress in this browser. No plan guarantees an offer; this one builds evidence you control.
Roadmap journey
Choose a pace
8 / 16 / 24 week tracks.
Earn exit gates
Unseen problems, not vibes.
Use the checklists
Concepts + practice links.
Mix mocks later
After cores are stable.
Your control center
Choose a pace and earn each checkpoint
Calendar time is a planning aid. Mark a milestone complete only after its exit gate is true on unseen problems. The tracker saves progress in this browser.
Interactive preparation planner
Your FAANG DSA roadmap
Pick a sustainable pace, open a milestone, and mark it complete only after you can demonstrate every exit-gate skill. Calendar time organizes the work; evidence earns progress.
Choose your pace
Selected: 16-week standard. Switching pace changes the schedule, not your completed gates.
Eight evidence gates
Select any milestone to inspect its plan.
Set the baseline and interview operating system
Choose one interview language, measure your starting point, and make complexity analysis part of every solution.
What to master
- Language fluency: collections, sorting, comparators, recursion, and safe numeric types
- Big-O from code, constraints-to-complexity reasoning, and common memory costs
- The interview loop: clarify → brute force → bottleneck → invariant → code → test
Deliberate practice
- Run a four-problem diagnostic without notes: array, hash map, tree traversal, and graph traversal.
- Create a short error log with columns for recognition, correctness, implementation, and communication.
- Explain one brute-force solution and its optimized replacement aloud every day.
Open the relevant notes
Exit gate: demonstrate all three
- Derive time and auxiliary space complexity from a short implementation without guessing.
- Write and test BFS, DFS, binary search, and a frequency map in your chosen language.
- Complete a 45-minute medium problem while narrating trade-offs and edge cases.
Readiness rule: completing this planner is evidence of structured preparation, not a job guarantee. Keep measuring performance with unseen problems, realistic mocks, and honest error reviews.
The complete practice path
DSA mastery checklist
The eight milestones above plan your calendar; this detailed checklist tracks the exact concepts and problems. Open one phase at a time, read the linked SwadhyAI notes, solve through the verified LeetCode links, and save each checkpoint locally in this browser.
Detailed practice checklist
22 phases · 157 placements · 146 unique problems
Track Not started → Solved with help → Independent → Re-solved. Progress is shared across revisit placements of the same LeetCode problem, and review dates follow spaced reconstruction.
Searches phase titles, descriptions, note titles, problem names, patterns, and aliases.
Show
01Basics0 of 6 independent/re-solved
Build the vocabulary and cost model used by every later solution.
Read our notes first
Time & Space Complexity
Arrays
Strings
Math & Bit Manipulation
HashMap
HashSet
01bPrefix Sums, Subarrays & Matrices0 of 7 independent/re-solved
Build prefix information early—these patterns show up constantly before advanced structures.
Read our notes first
Maximum Subarray
mediumKadane / prefix~25 minSubarray Sum Equals K
mediumPrefix + hash map~30 minProduct of Array Except Self
mediumPrefix / suffix~30 minContiguous Array
mediumPrefix + hash map~35 minSet Matrix Zeroes
mediumMatrix marking~25 minSpiral Matrix
mediumMatrix traversal~30 minRotate Image
mediumMatrix transform~25 min
02Two Pointers & Sliding Window0 of 8 independent/re-solved
Control ordered pointer movement and maintain a precise invariant over a contiguous range.
Read our notes first
Two Sum
mediumValid Palindrome
mediumRemove Duplicates from Sorted Array
mediumContainer With Most Water
medium3Sum
mediumLongest Substring Without Repeating Characters
mediumMinimum Window Substring
mediumPermutation in String
medium
03Stack & Queue0 of 8 independent/re-solved
Use processing order as state: LIFO, FIFO, monotonic candidates, and deque windows.
Read our notes first
Valid Parentheses
mediumMin Stack
mediumDaily Temperatures
mediumNext Greater Element
mediumUses Next Greater Element I as the canonical introduction.
Largest Rectangle in Histogram
mediumSliding Window Maximum
mediumImplement Queue using Stacks
mediumImplement Stack using Queues
medium
04Binary Search0 of 7 independent/re-solved
Search values, boundaries, rotated order, and monotone answer spaces without off-by-one guessing.
Read our notes first
Binary Search
mediumSearch in Rotated Sorted Array
mediumFind Peak Element
mediumFirst & Last Position
mediumKoko Eating Bananas
mediumCapacity To Ship Packages
mediumMedian of Two Sorted Arrays
medium
05Linked List0 of 8 independent/re-solved
Reason about node identity, pointer ownership, fast/slow movement, and cache composition.
Read our notes first
Reverse Linked List
mediumMiddle of Linked List
mediumLinked List Cycle
mediumMerge Two Sorted Lists
mediumRemove Nth Node From End
mediumReorder List
mediumLRU Cache
mediumCopy List with Random Pointer
medium
06Trees0 of 9 independent/re-solved
Define recursive return contracts, choose traversal order intentionally, and combine subtree facts.
Read our notes first
Maximum Depth
mediumLevel Order Traversal
mediumDiameter of Binary Tree
mediumBalanced Binary Tree
mediumLowest Common Ancestor
mediumPath Sum
mediumBinary Tree Maximum Path Sum
mediumSerialize & Deserialize Binary Tree
medium
07Binary Search Tree0 of 5 independent/re-solved
08Heap / Priority Queue0 of 6 independent/re-solved
Maintain the next best candidate without repeatedly sorting the entire working set.
Read our notes first
Kth Largest Element
mediumTop K Frequent Elements
mediumMerge K Sorted Lists
mediumFind Median from Data Stream
mediumTask Scheduler
mediumMeeting Rooms II
mediumLeetCode Premium may be required.
09Intervals0 of 5 independent/re-solved
Sort and reason about overlap, boundaries, resource concurrency, and complement gaps.
Read our notes first
Merge Intervals
mediumInsert Interval
mediumNon-overlapping Intervals
mediumMeeting Rooms
mediumLeetCode Premium may be required.
Employee Free Time
mediumLeetCode Premium may be required.
10Backtracking0 of 10 independent/re-solved
Explore a decision tree with explicit choose, prune, explore, and restore semantics.
Read our notes first
Subsets
mediumSubsets II
mediumPermutations
mediumPermutations II
mediumCombination Sum
mediumCombination Sum II
mediumLetter Combinations
mediumPalindrome Partitioning
mediumN Queens
mediumWord Search
medium
11Graphs (BFS / DFS)0 of 8 independent/re-solved
Model vertices and edges, then control discovery, visited state, and component traversal.
Read our notes first
Number of Islands
mediumBFS/DFSClone Graph
mediumBFS/DFSFlood Fill
easyDFSRotting Oranges
mediumMulti-source BFSIs Graph Bipartite?
mediumBFS/DFS coloringGraph Valid Tree
mediumDFS + edge countLeetCode Premium may be required.
Pacific Atlantic Water Flow
mediumMulti-source DFSSurrounded Regions
mediumBoundary DFS
12Topological Sort0 of 3 independent/re-solved
Order dependency graphs with indegrees or DFS finishing state, and reject cycles.
Read our notes first
Course Schedule
mediumTopological sortRevisit specifically through the topological-order invariant.
Alien Dictionary
mediumTopological sortLeetCode Premium may be required.
Parallel Courses
mediumTopological sortLeetCode Premium may be required.
13Shortest Path0 of 5 independent/re-solved
Choose the path algorithm from weight, state, and relaxation contracts—not from habit.
Read our notes first
Network Delay Time
mediumDijkstraPath With Minimum Effort
mediumDijkstra / binary searchCheapest Flights Within K Stops
mediumBellman–Ford / state DijkstraSwim in Rising Water
mediumDijkstra / binary search + BFSPath With Maximum Probability
mediumDijkstra on probabilities
14Union Find (DSU) & MST0 of 5 independent/re-solved
Maintain dynamic connectivity with path compression, union by size, and Kruskal ordering.
Read our notes first
Number of Connected Components
mediumDSULeetCode Premium may be required.
Redundant Connection
mediumDSUAccounts Merge
mediumDSUNumber of Provinces
mediumDSU / DFSMinimum Cost to Connect Points
mediumMST (Kruskal/Prim)Official LeetCode title: Min Cost to Connect All Points. Classic Kruskal/Prim MST.
15Trie0 of 4 independent/re-solved
Share prefixes for search, wildcard traversal, word grids, and maximum-XOR bit tries.
Read our notes first
Implement Trie
mediumDesign Add and Search Words
mediumWord Search II
mediumMaximum XOR of Two Numbers
medium
16Dynamic Programming (1D)0 of 8 independent/re-solved
Make the state represent the smallest prefix or scalar history that determines the future.
Read our notes first
Climbing Stairs
mediumHouse Robber
mediumHouse Robber II
mediumCoin Change
mediumPerfect Squares
mediumDecode Ways
mediumLongest Increasing Subsequence
mediumPartition Equal Subset Sum
medium
17Dynamic Programming (2D)0 of 8 independent/re-solved
Use two-dimensional state for grids, paired prefixes, intervals, and multi-choice histories.
Read our notes first
Unique Paths
mediumMinimum Path Sum
mediumLongest Common Subsequence
mediumEdit Distance
mediumDistinct Subsequences
mediumInterleaving String
mediumTarget Sum
mediumBurst Balloons
medium
18Greedy0 of 7 independent/re-solved
19Advanced Data Structures0 of 6 independent/re-solved
Learn the operation contract first; use representative problems only where they accurately exercise the concept.
Read our notes first
Monotonic Stack
RevisitMonotonic stackRepresentative practice: Daily Temperatures.
Listed again for spaced reconstruction, not as new checklist volume. Status syncs with the earlier placement of this problem.
Monotonic Queue
RevisitMonotonic dequeRepresentative practice: Sliding Window Maximum.
Listed again for spaced reconstruction, not as new checklist volume. Status syncs with the earlier placement of this problem.
Difference Array
Difference arrayRepresentative practice: Corporate Flight Bookings.
Fenwick Tree (BIT)
Fenwick / BITRepresentative practice: Range Sum Query – Mutable.
Segment Tree
RevisitSegment treeSame Range Sum Query – Mutable problem as Fenwick; compare contracts, not problem count.
Listed again for spaced reconstruction, not as new checklist volume. Status syncs with the earlier placement of this problem.
Sparse Table
Sparse tableConcept checkpoint: static idempotent range queries; no exact canonical LeetCode problem is implied.
20Hard Re-solves and Stretch Problems0 of 18 independent/re-solved
Explicit spaced re-solves of high-signal problems plus stretch problems—after the core phases are stable.
Read our notes first
Trapping Rain Water
mediumFirst Missing Positive
mediumWord Ladder
mediumWord Ladder II
mediumRegular Expression Matching
mediumWildcard Matching
mediumText Justification
mediumLFU Cache
mediumAll O(1) Data Structure
mediumThe official LeetCode title is All O`one Data Structure.
Minimum Window Substring
RevisitmediumRevisit under hard-phase interview conditions.
Listed again for spaced reconstruction, not as new checklist volume. Status syncs with the earlier placement of this problem.
Median of Two Sorted Arrays
RevisitmediumRevisit under hard-phase interview conditions.
Listed again for spaced reconstruction, not as new checklist volume. Status syncs with the earlier placement of this problem.
Merge K Sorted Lists
RevisitmediumRevisit under hard-phase interview conditions.
Listed again for spaced reconstruction, not as new checklist volume. Status syncs with the earlier placement of this problem.
Binary Tree Maximum Path Sum
RevisitmediumRevisit under hard-phase interview conditions.
Listed again for spaced reconstruction, not as new checklist volume. Status syncs with the earlier placement of this problem.
Serialize & Deserialize Binary Tree
RevisitmediumRevisit under hard-phase interview conditions.
Listed again for spaced reconstruction, not as new checklist volume. Status syncs with the earlier placement of this problem.
Find Median from Data Stream
RevisitmediumRevisit under hard-phase interview conditions.
Listed again for spaced reconstruction, not as new checklist volume. Status syncs with the earlier placement of this problem.
Bus Routes
mediumSliding Window Maximum
RevisitmediumRevisit under hard-phase interview conditions.
Listed again for spaced reconstruction, not as new checklist volume. Status syncs with the earlier placement of this problem.
Largest Rectangle in Histogram
RevisitmediumRevisit under hard-phase interview conditions.
Listed again for spaced reconstruction, not as new checklist volume. Status syncs with the earlier placement of this problem.
RRevision & Interview Simulation0 of 6 independent/re-solved
Use curated lists as coverage audits, then convert knowledge into timed, verbal, unseen performance.
Read our notes first
Blind 75
NeetCode 150
Grind 169
LeetCode Top Interview 150
100+ Timed Mock Interviews
Treat 100+ as a long-horizon target; feedback quality and realism matter more than raw volume.
Company Tagged Questions (Google, Meta, Amazon, Apple, Microsoft, Netflix)
Day zero
Take a 90-minute diagnostic before making a schedule
- 1In 10 minutes, estimate the complexity budget for five input sizes and explain your choices.
- 2In 20 minutes, solve one unseen easy array or string problem and test it.
- 3In 35 minutes, solve one unseen medium involving hashing, two pointers, or a tree.
- 4In 15 minutes, re-explain the medium solution as if an interviewer had joined after you finished.
- 5In 10 minutes, label every delay: concept, pattern recognition, syntax, debugging, or communication.
Pick the track from evidence
Foundation · 24 weeks: syntax or easy problems are still inconsistent; 6–8 focused hours/week.
Balanced · 16 weeks: easy problems are comfortable but medium recognition varies; 10–12 focused hours/week.
Sprint · 8 weeks: core topics were learned before and the need is structured revision; 18–22 hours/week.
A slower plan completed consistently beats an accelerated plan that converts sleep into low-quality repetitions.
The curriculum
Eight preparation milestones, each with an observable exit gate
Week labels below use the recommended 16-week track; the planner remaps them for the other paces.
Calibrate and become language-fluent
Recommended pace: Week 1
Objective: Remove syntax friction, measure the real baseline, and learn to reason from constraints before choosing an algorithm.
Learn and connect
Deliberate practice
- →Choose one interview language: Java or Python, and prepare trusted templates for input, sorting, maps, sets, queues, heaps, and graph adjacency lists.
- →Estimate the viable complexity from n before solving: n around 20 suggests exponential search; n around 10⁵ usually demands O(n log n) or better.
- →Solve a small diagnostic set without notes, then classify every miss as knowledge, recognition, implementation, or verification.
Exit gate
- Explain time and auxiliary space for a loop, nested loop, sort, hash lookup, recursion, and graph traversal.
- Write and test two easy solutions in 20 minutes each without fighting language syntax.
- State input assumptions, edge cases, and one correctness invariant aloud.
Master arrays, hashing, and string patterns
Recommended pace: Weeks 2–3
Objective: Build the highest-return interview toolkit: counting, indexing, prefix information, ordered scans, and contiguous ranges.
Learn and connect
Deliberate practice
- →Cover frequency maps, complement lookup, deduplication, prefix sums, interval merging, two-sum families, fixed/variable windows, and palindrome scans.
- →For every solution, name what the map key means or what the current window guarantees; this sentence is the core invariant.
- →Re-solve misses from a blank editor after 1, 3, 7, and 21 days instead of immediately rereading the answer.
Exit gate
- Recognize the likely pattern from constraints and problem wording before writing code.
- Solve four representative unseen medium problems in 30–35 minutes each with complete edge-case tests.
- Explain when sorting plus a scan is preferable to extra hash-table memory.
Control linear structures and search boundaries
Recommended pace: Weeks 4–5
Objective: Make pointer rewiring, LIFO/FIFO state, monotonic structures, and binary-search contracts feel mechanical.
Learn and connect
Deliberate practice
- →Draw node identities before reversing, merging, deleting, or detecting a cycle; values alone do not describe pointer correctness.
- →Practice bracket parsing, next-greater-element monotonic stacks, queue-based level processing, and deque windows.
- →Write lower-bound, upper-bound, rotated-array, and binary-search-on-answer variants from an explicit interval invariant.
Exit gate
- Reverse and merge linked lists without losing a node, then dry-run empty, one-node, and two-node cases.
- Choose stack, queue, deque, or heap based on the order in which work must leave the structure.
- Implement binary search without guessing whether the final answer is left, right, or mid.
Think recursively with trees, BSTs, heaps, and tries
Recommended pace: Weeks 6–7
Objective: Learn to define what each recursive call returns and to select structures by ordering, hierarchy, and prefix requirements.
Deliberate practice
- →Cover recursive and iterative DFS, level-order BFS, height/diameter, path sums, lowest common ancestor, validation, serialization, and reconstruction.
- →Practice top-k, running median, k-way merge, and scheduling problems with explicit heap-entry semantics and tie handling.
- →Contrast BST ordering, heap partial ordering, and trie prefix sharing; each supports a different query contract.
Exit gate
- Say the recursive function contract before its base case and combine step.
- Derive preorder, inorder, postorder, and level order without memorized problem-specific code.
- Recognize when a heap reduces repeated global selection from O(n) to O(log n).
Model relationships with graphs and DSU
Recommended pace: Weeks 8–10
Objective: Translate real-world relationships into vertices and edges, then select traversal, ordering, connectivity, or shortest-path machinery.
Deliberate practice
- →Build adjacency lists for directed, undirected, weighted, and implicit graphs; define exactly when a node becomes visited.
- →Cover islands/components, bipartite tests, topological ordering, multi-source BFS, Dijkstra, and union-find connectivity.
- →Separate path existence, minimum hops, minimum weighted cost, cycle detection, and dependency ordering. They are different contracts.
Exit gate
- State traversal cost as O(V + E) for adjacency lists and explain what V and E mean in the problem.
- Choose BFS, DFS, topological sort, Dijkstra, Bellman–Ford, or DSU from edge and query properties.
- Avoid duplicate work by defending visited timing and stale-priority-queue handling.
Turn exhaustive search into backtracking, greedy, or DP
Recommended pace: Weeks 11–13
Objective: Start from the decision tree, identify repeated states or safe irreversible choices, and justify the optimization.
Deliberate practice
- →Generate subsets, permutations, combinations, constrained boards, and word searches using choose → explore → unchoose.
- →For DP, write state meaning, transition, base cases, evaluation order, answer location, and complexity before implementation.
- →For greedy, supply an exchange, stays-ahead, or cut-style argument, or search for a counterexample before trusting the choice.
Exit gate
- Transform a brute recursive recurrence into memoization and bottom-up tabulation without changing its semantics.
- Distinguish 0/1 from unbounded choices through loop direction and state transitions.
- Explain why a pruning rule or greedy choice cannot remove the optimal answer.
Integrate patterns with mixed sets and selective advanced DSA
Recommended pace: Week 14
Objective: Stop practicing by chapter. Diagnose the pattern from an unseen problem and add advanced tools only where the target role benefits.
Deliberate practice
- →Run 70–90 minute mixed sets with no pattern label, no autocomplete dependency, and a written postmortem.
- →Study bitmasks, KMP, DSU, tries, segment trees, advanced DP, or flows selectively: after the core patterns are reliable.
- →Maintain a small error portfolio: one minimal example for every recurring boundary, overflow, state, or data-structure mistake.
Exit gate
- Solve at least 70% of a representative unseen medium set within time while communicating cleanly.
- Recover from a wrong first approach by using constraints and counterexamples instead of freezing.
- Explain why an advanced structure is necessary rather than using it because it is familiar.
Simulate the real loop and convert readiness into interviews
Recommended pace: Weeks 15–16
Objective: Make performance repeatable under observation, close communication gaps, and prepare the non-DSA lanes of the hiring loop.
Deliberate practice
- →Complete 6–10 realistic mocks: shared editor, 45 minutes, clarification, verbal reasoning, runnable code, tests, and follow-ups.
- →Alternate interviewer and candidate roles with a peer; evaluating another solution exposes gaps that solo solving hides.
- →In parallel, prepare behavioral stories, role-relevant CS fundamentals, system design when appropriate, résumé evidence, and company-specific format research.
Exit gate
- Earn consistent “hire” signals across at least four recent mocks from more than one interviewer.
- Finish with tested code and a complexity summary rather than stopping when the core idea appears.
- Have interview logistics, questions for the interviewer, and concise impact stories ready.
Retention over volume
Use a three-pass problem system
Pass 1 · Discover
Attempt for 20–25 focused minutes. If blocked, take the smallest useful hint, not the full solution. Finish by writing the invariant and complexity.
Pass 2 · Reconstruct
One to three days later, solve from a blank file. Explain why the rejected approaches fail and test the boundary that broke the first attempt.
Pass 3 · Simulate
Seven to twenty-one days later, solve under interview time while speaking. A problem counts as retained only if no memory cue is required.
Pattern-recognition signal map
These signals generate hypotheses, not guarantees. Confirm the invariant against examples and constraints.
| Problem signal | First hypothesis | Invariant to defend |
|---|---|---|
| Sorted input or monotone feasibility | Binary search / search on answer | Discarded half cannot contain the boundary |
| Pair/triple relation in ordered data | Two pointers | Pointer movement eliminates impossible pairs |
| Longest/shortest valid contiguous range | Sliding window | The maintained window satisfies a precise condition |
| Counts, complements, membership, deduplication | Hash map or set | Stored keys summarize exactly the processed prefix |
| Repeated min/max, top-k, next event | Heap / priority queue | The root is the next globally eligible candidate |
| Dependencies, reachability, components, routes | Graph traversal | Visited/frontier state represents discovered work |
| Enumerate constrained choices | Backtracking | The path contains exactly the decisions made so far |
| Optimal/counting result with repeated subproblems | Dynamic programming | Each state stores one complete future-equivalence class |
A repeatable 100-minute study block
Recall
Re-derive yesterday’s invariant or template without opening notes.
Unseen solve
Clarify, derive, code, and test one appropriately difficult problem.
Postmortem
Compare approaches; capture the first wrong assumption and smallest decisive hint.
Reconstruction
Re-code a due problem from the spaced-review queue.
Plan
Schedule the next review and choose tomorrow’s skill gap.
The weekly feedback loop
Learn one cluster, mix new problems with scheduled re-solves, and keep difficulty near the edge of independence.
Run an unlabeled mixed set. Measure recognition time, implementation time, bugs, and test coverage separately.
Complete one mock or contest-style set, then spend at least as long on the postmortem as on the score.
Review the error portfolio, reduce next week to the top two weaknesses, and protect recovery time.
Inside the interview
Use the CLARITY execution protocol
A strong solution is observable reasoning plus correct code. This sequence keeps both visible.
Clarify
Inputs, outputs, mutation, duplicates, invalid cases.
Limits
Use n, value ranges, memory, and call frequency to bound complexity.
Alternatives
State brute force first; identify its repeated work or bottleneck.
Reason
Choose the structure and say the invariant or proof idea.
Implement
Write small logical blocks with names that expose state meaning.
Test
Dry-run normal, boundary, adversarial, and overflow-sensitive cases.
Yield summary
Restate complexity, trade-offs, and the next optimization.
Typical 45-minute allocation: 0–5 clarify · 5–12 approaches and proof · 12–32 implementation · 32–40 tests · 40–45 follow-ups. Adapt when the interviewer redirects you.
Readiness scorecard: apply on evidence, not emotion
| Dimension | Green-light evidence |
|---|---|
| Recognition | Name a plausible pattern and key invariant within 5–8 minutes of an unseen problem. |
| Correctness | Handle empty, singleton, duplicate, boundary, overflow, and disconnected cases without interviewer rescue. |
| Coding | Produce readable, executable code in one chosen language with stable templates and meaningful names. |
| Complexity | Derive time and space from actual operations, including recursion depth and data-structure growth. |
| Communication | Clarify, compare approaches, narrate decisions, accept hints, and summarize trade-offs without a monologue. |
| Consistency | Receive positive signals in four recent, realistic mocks, not just on previously seen problems. |
Do not wait for perfection. Start applications while finishing the mock milestone; hiring timelines themselves create useful repetition.
Run four preparation lanes in parallel
Coding · primary
DSA recognition, correctness, implementation, testing, and communication.
Behavioral
Prepare concise STAR stories for impact, conflict, failure, leadership, ambiguity, and learning.
Role fundamentals
Add OS, databases, networking, language/runtime depth, or system design according to level and role.
Opportunity pipeline
Build evidence-rich résumé bullets, referrals, applications, recruiter follow-ups, and company-specific loop notes.
When interviews are scheduled
The final 14-day taper
Days 14–10
Run two full mocks. Patch only the top two repeated failure classes; keep spaced review active.
Days 9–6
Use role-relevant mixed sets and rehearse behavioral stories. Verify the actual interview format and tools.
Days 5–3
Complete the final two or three mocks. Practice opening clarification and closing complexity summaries.
Day 2
Review templates, invariants, error portfolio, résumé, and logistics. No new advanced chapter.
Day 1
One easy warm-up, light recall, equipment check, normal food, movement, and adequate sleep.
Interview day
Warm up briefly, arrive early, externalize assumptions, collaborate, and treat hints as information, not failure.
Failure modes that feel productive
- ×Grinding hundreds of labeled problems while recognition remains untested.
- ×Reading a solution, understanding it, and counting that as the ability to reconstruct it.
- ×Jumping to hard problems before medium implementation and communication are reliable.
- ×Changing languages or resource lists whenever practice becomes uncomfortable.
- ×Ignoring tests, overflow, recursion depth, Unicode, or mutability because the happy path passed.
- ×Doing only solo practice and discovering communication gaps in the real interview.
Recovery protocol after a bad week
- 1.Reduce scope to the single failure class with the highest recurrence.
- 2.Revisit one canonical explanation and two representative examples, never an entire resource library.
- 3.Reconstruct three due problems from blank files and verbalize their invariants.
- 4.Run a short mixed check. If the same miss remains, get targeted peer feedback.
- 5.Resume the roadmap from the exit gate, not from the date printed on the calendar.
Roadmap FAQ
How many problems are enough?+
Use problem counts only to plan your week; advance by the exit gates. Every track should combine unseen problems, blank-file spaced re-solves, mixed sets, and realistic mocks. A smaller set reconstructed independently beats a larger set remembered from solutions.
Should I use Java or Python?+
Use the language in which you can reason, implement, and debug most reliably. Java offers explicit types and strong standard collections; Python is concise. Both are fully capable interview languages: avoid switching mid-plan without a role-specific reason.
What should I do after 20 minutes stuck?+
Write the exact missing fact. Take a progressive hint about the pattern or invariant, continue the implementation, then schedule a blank-file reconstruction. Passive solution reading is the last resort.
Do I need many hard problems?+
Most candidates gain more from reliable easy/medium execution and mixed recognition. Use hard problems selectively to stretch decomposition, advanced roles, or a demonstrated company need.
Is DSA preparation enough to crack a FAANG-style loop?+
No. Coding is one major lane. Behavioral evaluation, role fundamentals, system design, résumé evidence, and the opportunity pipeline also affect the result; their weight varies by role and level.
Start with one measured action today
Take the diagnostic, select the honest pace in the tracker, and complete Milestone 1’s first study block. Momentum starts smaller than motivation expects.