TL;DR: For most working engineers with solid-but-rusty fundamentals, 6 to 8 weeks at 1.5 to 2 hours a day is the honest number. Senior engineers who've done this before need 4 to 6 weeks; new grads need 8 to 12; career switchers should plan on 4 to 6 months because they're building fundamentals, not just interview skills. But calendar time is the wrong unit: readiness is measured in milestones (fundamentals from memory, pattern recognition, timed execution, passing mocks), and you're ready when you hit the milestones, whether that takes you five weeks or eleven.
"How long do I need?" is the first question every candidate asks, and most answers you'll find are either uselessly wide ("2 weeks to 6 months!") or suspiciously precise ("exactly 90 days"). Having sat on the hiring side at Meta and Microsoft, I can tell you why the honest answer varies: the candidates who failed after three months of grinding and the ones who passed after five focused weeks were not separated by hours logged. They were separated by what those hours built. So let's do this properly: first what actually determines your timeline, then real numbers by situation, then how to know you're ready.
The four variables that set your timeline
- Where your fundamentals are. If you can implement a hash map's collision handling, BFS on a graph, and recursion with confidence, you're prepping for interviews. If any of those are shaky, you're first studying computer science, and that's the difference between weeks and months.
- Hours per day, and their consistency. Ninety minutes daily beats six weekend hours, every time. Retention decays fast in the early weeks; daily contact is what makes patterns stick. Weekend-only prep roughly doubles your calendar time.
- How recently you last interviewed. Interview skill is perishable but rebuildable. If you passed loops three years ago, you're restoring a skill, which is far faster than building one.
- Your target bar. A FAANG loop with four coding rounds needs deeper pattern coverage than a startup's single practical round. Aim your prep at the hardest loop on your list.
Measure milestones, not hours
Before the timelines, here's the measuring stick they're based on. You're ready when you can do all four of these, not when a calendar says so:
- M1, Fundamentals: implement the core data structures and traversals from memory: hash maps, linked lists, BFS/DFS, binary search, basic recursion.
- M2, Recognition: given a random problem statement, name the likely pattern and its tell within two minutes, for the ~20 most common patterns. This is the milestone that actually predicts offers, and it's the entire argument of Why Is LeetCode So Hard?
- M3, Timed execution: solve two unseen mediums in 45 minutes while talking, most of the time.
- M4, Mock-passing: pass two consecutive realistic mock interviews with someone who won't flatter you.
Every timeline below is just an estimate of how long each situation takes to hit all four.
Honest timelines by situation
Senior engineer who has passed loops before: 4 to 6 weeks
You're at M1 already; your job is restoring M2 and M3. Two weeks of pattern review (you'll be surprised how much comes back, and how much is new: monotonic stack barely existed in interviews a decade ago), two to three weeks of timed mediums in your weak patterns, one week of mocks. The trap for seniors is skipping straight to hard problems out of pride; rebuild recognition on mediums first, because that's what your loop actually tests.
Working engineer, solid fundamentals but rusty: 6 to 8 weeks
The modal reader of this post. You use arrays and hash maps daily but haven't reversed a linked list since college. Weeks 1 to 4: work through patterns in sequence, one pattern block at a time, writing down each pattern's tell as you finish it. Weeks 5 to 6: mixed timed practice, where you no longer know which pattern is coming, because that's the skill the interview tests. Weeks 7 to 8: mocks and your failure list. At 1.5 to 2 hours a day that's roughly 100 to 150 well-chosen problems, and how many you actually need is its own post.
New grad or early-career: 8 to 12 weeks
You have the theory from coursework but not the recognition or the speed. Weeks 1 to 2 hammer M1 honestly (implement, don't just review). Weeks 3 to 8: the same pattern sequence as above, but expect each pattern to take longer to stick, and that's normal, not a bad sign. Weeks 9 to 12: timed mixed practice and mocks, plus behavioral prep, which new grads chronically underweight.
Career switcher or bootcamp grad: 4 to 6 months
I won't sugarcoat this one. You're building M1 from scratch, and M1 is the slow part: data structures need to be instinct before pattern prep pays off. Months 1 to 2: fundamentals only. Months 3 to 4: patterns in sequence, slowly. Months 5 to 6: timed practice and mocks. Anyone selling you "bootcamp to FAANG in 6 weeks" is selling something. The good news: this timeline works, consistently, for people who respect it.
Structure beats willpower over these timelines. Grokking the Coding Interview is a ~90-hour curriculum, which maps almost exactly onto the 6-to-8-week track at 2 hours a day: all 42 patterns (32 common + 10 advanced), 300+ problems in sequence, and graded self-tests to check the milestones, for a one-time $79.
Can you compress it?
Two weeks? You can't complete prep, but you can triage. Skip fundamentals review entirely (you can't fix them in two weeks anyway), drill the six highest-frequency patterns (sliding window, two pointers, tree BFS/DFS, graph traversal, intervals, top-K), do only mediums, and spend the last three days on mocks. You're playing probabilities, and honest framing matters: you're hoping the loop draws from the patterns you covered.
One month? Genuinely workable for the rusty-engineer profile if you go pattern-first and accept less depth: a focused 75-problem list is the right tool, not a 300-problem course. That's precisely the situation Grokking 75 was built for, and the full comparison of short-timeline lists is in Blind 75 vs NeetCode 150 vs Grokking 75.
One warning about the other direction: more time is not automatically better. Past about four months of active prep, most candidates plateau and start forgetting early material while polishing late material. If your timeline is long, delay the start rather than stretching the prep thin.
The last two weeks, whatever your timeline
The endgame is the same for everyone, and skipping it is the most common way good preparation fails to convert:
- Shift from learning to reviewing. No new patterns in the final two weeks. Re-solve your failure list from scratch; skim your pattern-tell notes daily (this is where written material beats video, since you can review 42 pattern summaries in an afternoon).
- Mock like it's real. Two or three full mock interviews with a person, timed, talking throughout. The first one will be humbling. That's the point, and it's why it can't be your real first loop.
- Practice the talk track. Restating the problem, stating the brute force, naming the pattern, justifying complexity. Interviewers grade the reasoning; silent perfect code scores worse than narrated good code.
The takeaway
Six to eight weeks for most working engineers, four to six if you've done it before, eight to twelve as a new grad, four to six months as a switcher, all at 1.5 to 2 focused hours a day. But hold the milestones, not the calendar: fundamentals from memory, tells named in two minutes, two timed mediums in 45 while talking, two clean mocks. When those are true, you're ready, and no amount of extra grinding adds much after that.
Start your timeline today: Grokking the Coding Interview covers all 42 patterns with 300+ sequenced problems ($79, lifetime access). On the one-month track? Grokking 75 is the compressed 6-week plan built for exactly that.
FAQs
Is 1 month enough to prepare for coding interviews? For a working engineer with solid fundamentals: yes, with a pattern-first 75-problem plan and mocks in the final week. For a new grad: tight but possible if fundamentals are genuinely strong. For a career switcher: no, and scheduling interviews anyway usually burns a company's 6-to-12-month cooldown window on an unready attempt.
Can I prepare for a coding interview in 2 weeks? You can triage, not prepare: the six highest-frequency patterns, mediums only, three days of mocks at the end. It's a probability play. If you have any ability to push the interview out even two weeks, push it.
How many hours a day should I study? 1.5 to 2 focused hours daily is the sweet spot for retention while working full-time. Under an hour a day, roughly double the calendar estimates. Marathon weekends are the least effective schedule per hour spent, because recognition is built by frequency, not volume.
Does FAANG prep take longer than prep for other companies? Mostly in depth, not kind. The same milestones apply, but FAANG loops draw from a wider pattern pool and enforce time pressure more strictly, so expect the upper end of your situation's range, plus non-negotiable mock practice. For senior roles, add separate system design prep, which is its own timeline entirely.
I'm a senior engineer. Do I really need weeks of prep? Seniority in the job and readiness for the interview format are different skills, and loops calibrate expectations up with your level. Four to six weeks restores recognition and speed. The most common senior failure mode isn't rusty coding, it's arriving unprepared out of principle ("I do this daily"), and interviewers can't score principle.