TL;DR: Four weeks is enough for a working engineer with solid-but-rusty fundamentals, if the month is structured: Weeks 1-2 install the core patterns in blocks, Week 3 shifts to mixed timed practice, Week 4 is mocks and review, and nothing new enters in the final five days. Budget 1.5 to 2 focused hours a day (roughly 100 problems total, quality over count), write down each pattern's tell as you go, and keep a failure list from day one, because Week 4 runs on it. If you're a new grad or career switcher, this plan is too compressed: use the honest timelines by situation instead.
Our timeline guide answers "how long do I need?"; this post answers the follow-up everyone asks next: "fine, I have four weeks, what exactly do I do each day?" Below is the plan I'd hand a working engineer who uses code daily but hasn't reversed a linked list since college, calibrated to the milestones that actually measure readiness (recognition, timed execution, mock-passing) rather than to a problem counter.
Ground rules before day one: 1.5 to 2 hours daily beats weekend marathons (recognition is built by frequency); every pattern block ends with writing its tell in your own words; every problem you fail or misdiagnose goes on a failure list; and the plan tracks the field guide's pattern order, because the sequence is designed so each family reuses the previous one's machinery.
Week 1: arrays and the linear patterns
The goal: the highest-frequency patterns installed as templates, not memories.
- Days 1-2: Two pointers. Converging, reader-writer, two-sequence. 5 problems total, then write the tell.
- Days 3-4: Sliding window. Fixed then variable, ending with Longest Substring Without Repeating Characters. 5 problems, write the tell.
- Day 5: hashing + prefix sums. Two Sum family, Subarray Sum Equals K. 3 problems.
- Day 6: fast & slow pointers + linked-list reversal. 4 problems.
- Day 7: rest or catch-up. Protect this; retention needs it.
Weekly output: ~17 problems, 4 tells written, failure list started.
Week 2: trees, graphs, and the sorted-world patterns
- Days 8-9: tree DFS, then tree BFS. Depth/diameter/path-sum, then level-order family. 6 problems.
- Days 10-11: graph BFS/DFS on grids (Number of Islands, Rotting Oranges) plus topological sort (Course Schedule). 5 problems.
- Day 12: merge intervals. The sweep, Meeting Rooms II with its heap. 4 problems.
- Day 13: Top-K / heaps + binary search variants. 4 problems.
- Day 14: rest, plus a 20-minute read-through of every tell you've written.
Weekly output: ~19 problems, 8 tells total. You now hold the patterns that cover the bulk of real loops; the map of what you've skipped (DP depth, backtracking, monotonic stack) is deliberate triage for a 4-week window, with one exception: if you're targeting a company that leans on a specific family (Meta's tiers, Amazon's), swap it into Day 13.
Week 3: the shift from learning to performing
This is the week most self-directed plans skip, and it's the one that decides the loop.
- Days 15-16: mixed sets, untimed but diagnosed. 4 problems a day from any pattern, and you must name the pattern and its tell out loud before coding. Wrong diagnosis? Failure list, even if you then solved it.
- Days 17-19: timed pairs. Two unseen mediums, 45 minutes, talking aloud the entire time, no pause. One pair per day, then 30 minutes reviewing what the timer exposed. This simulates the Meta-style speed bar, which is the strictest you'll face.
- Day 20: first full mock with a human who won't flatter you (a peer, a platform, anyone adversarial). Expect it to be humbling; that's its job, three weeks before it counts.
- Day 21: rest, plus failure-list re-solves (every item from Week 1 gets re-solved from scratch today).
Week 4: mocks, review, and the taper
- Days 22-23: timed pairs, again. By now diagnosis should feel mechanical on most problems; where it doesn't, that pattern gets one targeted block of 2 problems, and that's the only new material allowed this week.
- Day 24: second full mock. You want two clean mocks before the real loop; this is checkpoint one of two.
- Days 25-26: failure list, nothing else. Re-solve everything still on it from scratch. Your failure list is the most personalized prep material that exists; two full days on it outperforms any 20 new problems.
- Day 27: third mock (the second "clean" one, ideally), plus 30 minutes skimming all your written tells, which at this point is your personal cheat sheet.
- Day 28: taper. One easy problem for confidence, tells skim, logistics check, sleep. No mediums, no hards, no doom-scrolling of interview horror stories.
If you fall behind (life happens): cut problems, never structure. Three problems per block instead of five keeps the plan intact; skipping Week 3's timed work to "finish coverage" is how well-covered candidates fail loops. And if the interview moves up on you mid-plan, compress by dropping Week 2's Day 13 and one mock, not by skipping the taper.
Want the problem selection done for you? This plan's structure maps directly onto Grokking 75: 75 problems, pattern-ordered, with a built-in schedule, the same philosophy with the curation pre-done. More runway than a month? Grokking the Coding Interview is the full 42-pattern, 300+ problem version ($79, lifetime).
The takeaway
A month is enough when every week has a different job: install (1), extend (2), perform (3), polish (4). The plan's non-negotiables are the ones that feel skippable on a busy Tuesday: writing the tells, keeping the failure list, starting timed work in Week 3 rather than "when I'm ready," and tapering instead of cramming. Follow the structure, respect the rest days, and walk in with the two things loops actually test: recognition that fires fast, and a talk track that runs while you code.
FAQs
Is 4 weeks really enough to prepare for coding interviews? For a working engineer with solid fundamentals: yes, with structure, and this plan is that structure. For new grads (need 8 to 12 weeks) or career switchers (4 to 6 months), no; compressing further trades away exactly the milestones that predict passing. The timelines by situation are here.
How many problems does this plan cover? Roughly 100: ~36 in pattern blocks across Weeks 1-2, ~30 in mixed and timed work in Week 3, and ~30 re-solves and targeted reps in Week 4. That's deliberately below the "grind 200 in a month" plans, because count was never the variable that mattered.
What if I only have 2 hours on weekends and 45 minutes on weekdays? Keep the weekday sessions for single problems plus tell-review, and move timed pairs and mocks to weekends. It stretches the plan to 5 to 6 weeks, which beats a rushed 4. Frequency matters more than session length; zero-days are the real enemy.
Which patterns does this plan deliberately skip? Deep DP, backtracking beyond basics, and the specialty families (monotonic stack gets cut only reluctantly; add it back if your target company favors it). A 4-week window buys the high-frequency core plus performance skills, not comprehensive coverage: know the trade you're making and where the full map lives.
When should I schedule the actual interview? For days 29 to 35 if you control the date: right after the taper, while the tells are hot. Avoid scheduling mid-plan "to lock myself in": interviewing at Week 2's readiness burns a 6-to-12-month company cooldown on a version of you that Week 4 would embarrass.