Tech Interview Prep Checklist for Busy Engineers: An 8-Week Plan That Fits Around a Full-Time Job
Most interview prep advice online assumes you have forty hours a week to study. You do not. You have a day job, a standup you cannot miss, code reviews that pile up, a partner who deserves some attention, a workout you want to keep, and maybe a kid or two.
This guide is written for the working engineer. The math of it is specific: if you invest thirty minutes on a weekday and four to six hours over a weekend, you are putting in roughly eight to ten hours a week. That is enough to be loop-ready at a senior level in eight weeks, if you spend those hours well.
The plan below is calibrated for that schedule. It is explicit about priorities, ruthless about cutting scope, and honest about what you cannot accomplish on top of a job. You will not "cover everything." You will cover the right things.
Table of Contents
- The brutal math of prep while employed
- Thirty-minute daily plan
- The weekend deep-dive
- Biweekly mock interviews
- The eight-week schedule at a glance
- Week by week breakdown
- What to cut mercilessly
- Tools and resources that respect your time
- Managing burnout and day-job performance
- Negotiating time off and interview scheduling
- Self-audit: am I ready to apply?
- FAQ
- Conclusion
1. The Brutal Math of Prep While Employed
A realistic weekly budget:
- Weekdays: thirty minutes per day, five days a week = 2.5 hours
- Weekend: one focused block of four to six hours
- Total: 6.5 to 8.5 hours per week
Across eight weeks, that is fifty to seventy hours of prep. Not two hundred. Accept this upfront.
The implication: you cannot do both breadth and depth for every topic. You must prioritize. Most engineers over-index on LeetCode grinding and under-index on system design and behavioral stories. The plan below corrects this imbalance.
What fifty to seventy hours can realistically produce:
- Comfort with the top eight or nine algorithm patterns
- One hundred to one hundred fifty total LeetCode problems solved (not memorized)
- A working system design framework plus four to six concrete designs rehearsed
- Twelve to fifteen behavioral stories structured in STAR format
- Six to eight mock interviews completed
- A cleaned-up resume and two or three well-prepared company-specific narratives
That is more than enough to land offers at senior level at most companies, including FAANG, if you are already a competent engineer. It is not enough if you are entry-level with no data structures foundation — in that case, you need a longer plan.
2. Thirty-Minute Daily Plan
Thirty minutes is short. The discipline is: do not let it expand into ninety minutes some days and zero minutes others. Consistency beats intensity at this budget.
Fixed structure:
- Minute 0 to 5: warm-up. Skim a pattern or topic note. No new learning yet.
- Minute 5 to 25: focused work. One LeetCode problem (medium), or one system design concept, or two behavioral stories written out.
- Minute 25 to 30: log what you did, note what you got wrong, plan tomorrow.
Where to put the thirty minutes:
- Before work: highest completion rate, lowest interruption rate. If you can do this, do it.
- Lunch: okay, but risky — meetings eat lunches.
- After work: last-resort slot. Fatigue reduces learning speed by maybe twenty percent.
What not to do during this time:
- Watch YouTube interview prep videos (low density per minute)
- Read random Medium articles (low density per minute)
- Browse job listings (different task)
- Do "light review" for thirty minutes (too passive)
The thirty minutes should be uncomfortable — problem-solving or active recall, not passive reading.
3. The Weekend Deep-Dive
The weekend block is where volume happens. Four to six hours, in one or two sessions.
Template for a four-hour block:
- 0:00 to 0:45 — mock interview (either with a partner or timed self-mock)
- 0:45 to 1:00 — break, review mock notes
- 1:00 to 2:30 — system design study, one topic deep
- 2:30 to 2:45 — break
- 2:45 to 4:00 — five LeetCode problems by topic, timed
Template for a six-hour block (one weekend day):
- 0:00 to 1:00 — mock interview (live, with a peer)
- 1:00 to 1:30 — break, mock debrief notes
- 1:30 to 3:00 — system design: one primitive deep, one design end-to-end
- 3:00 to 3:30 — break (go outside; eat real food)
- 3:30 to 5:00 — LeetCode, four to six problems of varied pattern
- 5:00 to 5:30 — break
- 5:30 to 6:00 — behavioral storywork: write or refine two stories
Do not schedule deep-dive sessions on both Saturday and Sunday. One full day, one rest day. Recovery matters for retention.
4. Biweekly Mock Interviews
Mock interviews are the single highest-leverage activity. One mock is worth three hours of solo LeetCode. Budget one every two weeks at minimum.
Where to get mocks:
- A peer who is also interviewing (free, highest quality if they are serious)
- Pramp (free, variable quality)
- interviewing.io (paid, often high quality, anonymous)
- A current or former FAANG engineer from your network (most valuable, hardest to book)
Structure of a good mock:
- Forty-five minutes: real problem, timed, realistic interviewer behavior
- Fifteen minutes: debrief, where the interviewer gives you honest feedback
- Same-day written reflection: what you will change next time
Mock cadence across eight weeks:
- Weeks 1 and 2: one mock total (you are still learning; mocks before you have a base are frustrating)
- Weeks 3 to 6: one mock per week
- Weeks 7 and 8: two mocks per week (simulate loop pressure)
Keep a spreadsheet. Every mock: date, problem, areas you stumbled on, what you committed to change. Review it before each new mock.
5. The Eight-Week Schedule at a Glance
| Week | Weekday focus | Weekend focus | Mocks | | ---- | ------------------------------------ | ------------------------------------------------- | ----- | | 1 | Arrays, two pointers, sliding window | Base LeetCode grind, pattern notes | 0 | | 2 | Hashmaps, linked lists | Stacks and queues, base system design primitives | 1 | | 3 | Trees, recursion | Tree LeetCode, system design: API design | 1 | | 4 | Graphs (BFS, DFS) | Graph LeetCode, system design: caching and queues | 1 | | 5 | Dynamic programming basics | DP LeetCode, full system design: URL shortener | 1 | | 6 | DP advanced, binary search | Full system design: news feed, behavioral stories | 1 | | 7 | Review weak areas, behavioral | Two full mocks, refine stories, resume polish | 2 | | 8 | Taper; light review only | One mock, final system design, rest | 2 |
The "taper" in week eight is deliberate. Two days before your first real loop, stop hard problems. Do a light warm-up the morning of. Walk into the loop rested, not fried.
6. Week by Week Breakdown
Week 1: Foundation and patterns
Five thirty-minute sessions focus on:
- Array patterns: two pointers, sliding window
- Pattern notes: write your own one-page cheat sheet
Weekend (four hours):
- Twelve to fifteen easy-to-medium LeetCode problems, all array-pattern
- Set up your spreadsheet tracker
- Set up your IDE and account on mock platforms
No mock this week. Goal: get in the rhythm.
Week 2: Hashmaps, linked lists, stacks, queues
Weekday sessions:
- Two sessions on hashmap problems
- Two sessions on linked list problems (reverse, cycle, merge)
- One session on stack and queue problems
Weekend (five hours):
- Six LeetCode problems, mixed
- Read and internalize: system design primitives, load balancers, caches, CDNs
- Write rough outlines for three behavioral stories (STAR)
- One mock interview
Week 3: Trees and recursion
Weekday sessions:
- Tree traversal (in-order, pre-order, post-order, level-order)
- Tree construction and diff
- Path problems
Weekend:
- Six LeetCode tree problems
- System design: API design. Rate limiters, idempotency, pagination
- One mock interview
Week 4: Graphs
Weekday sessions:
- BFS and DFS
- Topological sort
- Shortest path (Dijkstra; skip Bellman-Ford unless you specifically need it)
- Union-find
Weekend:
- Six graph LeetCode problems
- System design: caching strategies, message queues, pub/sub
- One mock interview
Week 5: DP intro
Weekday sessions:
- Fibonacci and climbing stairs
- Coin change
- Longest common subsequence
- House robber
Weekend:
- Four medium DP problems
- Full system design walkthrough: URL shortener. Cover every section end to end.
- One mock interview (with a senior, ideally)
Week 6: Advanced DP, binary search, strings
Weekday sessions:
- DP on grids
- Binary search variants
- String pattern matching
Weekend:
- Six mixed problems
- Full system design: news feed or chat. Pick one and go deep.
- Write out the remaining behavioral stories. Aim for twelve to fifteen total.
- One mock
Week 7: Weak-area hammering
This is your "fix" week. By now your mocks should reveal two or three weak areas. Spend all thirty-minute weekday sessions on those weak areas.
Weekend (six hours):
- Two mocks on different days (ideally Saturday and Sunday)
- Resume revision
- Company research for first target companies
- Polish your four strongest behavioral stories to memorized-but-natural
Week 8: Taper and deploy
- Weekday sessions: thirty minutes, easy review only. No new problems.
- Weekend: one mock, one system design deep-dive, then rest.
- If you have your first loop this week, sleep nine hours the two nights before.
7. What to Cut Mercilessly
At fifty to seventy total hours, you cannot cover everything. Cut these:
- Hard and obscure graph algorithms: Floyd-Warshall, Tarjan's, Kosaraju's. Unless your target company is specifically known for asking them, skip.
- Segment trees, Fenwick trees. Niche; skip unless you have a target that asks them.
- Machine learning algorithms. Skip unless you are interviewing for ML roles.
- LRU cache implementation from scratch (you can skip the hand-coded version; understanding the data structure is enough).
- String algorithms beyond basic: KMP, Rabin-Karp, Aho-Corasick. Skip.
- Reading full algorithm textbooks. Use cheat sheets and problems.
- Watching full YouTube courses. Pick specific videos by topic.
- "Premium" LeetCode problems behind a paywall, unless the paywall is cheap for you — the free set is sufficient for eighty percent of what gets asked.
8. Tools and Resources That Respect Your Time
LeetCode: the standard. Use the "Top 150 Interview Questions" list; it is calibrated to what actually gets asked.
NeetCode: free, structured, excellent. Use the "Blind 75" list as a minimum baseline.
System Design Primer (GitHub): free, dense, well-organized. Your system design spine.
Designing Data-Intensive Applications (book): gold standard for system design depth. Do not read it cover to cover in eight weeks. Read chapters one, three, five, seven, and nine; skim the rest.
Grokking the System Design Interview: paid, good summaries, useful for the design framework.
interviewing.io: paid, real mocks from real FAANG engineers. One or two of these in the last two weeks is extremely high value.
Pramp: free, peer mocks. Good in the middle weeks.
Anki or similar spaced repetition: underrated. Put pattern identifications on cards ("I see sorted array plus target sum → two pointers").
Do not use tools outside this list unless you have a specific reason. Tool-hopping eats prep time.
9. Managing Burnout and Day-Job Performance
Eight weeks of doubled workload is hard. Warnings:
- Week four is the burnout cliff. If you feel it, skip one weekday session (not the weekend). Do not extend the plan; keep the end date.
- Do not take on high-ambition projects at work during prep weeks. Deliver solidly; avoid signing up for stretch work.
- Protect sleep harder than you protect prep time. A thirty-minute session after five hours of sleep is worse than skipping it.
- Tell at least one person. A partner, a close friend. Not your manager yet. Having one person who knows you are preparing and why reduces the pressure.
- Lock in recovery blocks. Two weeknights per week with zero prep. Use them.
Day job reality check:
If your job is crunching hard (release week, incident response, launch), compress the weekday sessions to fifteen minutes and protect the weekend block. Do not skip the weekend block. That is where your real gains are.
10. Negotiating Time Off and Interview Scheduling
Loops cluster. A typical candidate in 2026 ends up with three to six loops in a two- to three-week window, each taking four to six hours. You cannot hide this from your calendar.
Tactics:
- Take PTO in half days, not full days. Most loops are three to four hours, morning or afternoon. A half-day gives you room without a full day's optics.
- Cluster loops on the same week if possible. Recruiters are usually willing to adjust.
- Schedule loops on Tuesdays, Wednesdays, and Thursdays. Monday you are rusty; Friday interviewers are checked out.
- Avoid scheduling your top-choice company first. Get a warm-up loop in at a lower-priority company first. Your performance in loop three is better than loop one.
- Front-load recruiter screens. These are forty-five minutes, can be done at lunch, do not need PTO. Get all of them done before loops start.
11. Self-Audit: Am I Ready to Apply?
At end of week six, honestly ask:
- [ ] Can I solve a random medium LeetCode problem in thirty-five minutes, including testing?
- [ ] Can I design a URL shortener end to end in forty-five minutes, out loud, without notes?
- [ ] Do I have at least eight rehearsed behavioral stories covering conflict, failure, leadership, ambiguity, tight deadlines, disagreement with manager, and a cross-functional project?
- [ ] Is my resume calibrated for the target level?
- [ ] Have I had at least three mocks with honest feedback?
If you answer no to two or more: extend the prep plan by two weeks before applying widely. Apply to a couple of lower-priority warm-up companies to practice in production.
If you answer yes to all five: apply now. Waiting longer does not help.
12. FAQ
Is eight weeks actually enough if I have a full-time job? For a competent engineer in a steady job, yes. For someone who has never interviewed or has not touched data structures in five years, extend to twelve weeks.
Should I take a leave of absence or sabbatical to prep full-time? No. Full-time prep has diminishing returns after about four hours a day. The eight-week working-person plan often produces better results because of consistent retention.
Should I quit to prep full-time? No. Quitting signals desperation in offer negotiations and weakens your BATNA. Stay employed while you interview.
When should I update my resume? Week one. Not week seven. A resume that has marinated for six weeks and been reviewed by two peers is much better than a week-seven rush job.
How much does referral versus cold-apply matter? Referrals still help, but less than five years ago. A strong resume and strong interview performance both dominate referral status. Ask for referrals, but do not wait.
What if I fail an early loop? Normal. Most candidates fail one to three loops during their search. Debrief immediately, note what went wrong, apply to the next. The success rate trends up across loops due to practice.
Should I prep with another person? A partner helps for accountability and mocks. Do not sync your problem set with them; it is too easy to optimize for pattern recognition between the two of you rather than real problem-solving.
What about behavioral for non-management roles? Still critical. Amazon leadership principles, Meta "move fast" examples, Google "Googleyness." Write stories specific to each target.
How long between receiving an offer and deciding? Most offers have a one- to two-week decision window. Use it. Do not rush.
What if I only have four weeks, not eight? Focus on top twelve patterns, six core system designs, and eight behavioral stories. Cut DP advanced. Cut graph advanced. Accept that you are going for specific target companies rather than a broad search.
13. Conclusion
You do not have time to prepare perfectly. That is fine. Nobody does.
What you have time for is the right fifty to seventy hours, spent on the right topics, tracked honestly, and punctuated by real mocks. The eight-week plan in this guide is calibrated for exactly that budget. It has gotten employed engineers from zero to offer at FAANG and equivalents many times over.
Three habits, above all, determine success:
- Thirty minutes a day, every day. Not ninety one day and zero the next.
- A weekend block, protected fiercely from chores and social drift.
- Biweekly mocks, increasing to weekly in the back half.
Print the eight-week table. Stick it to the wall above your monitor. Check off each week as you go.
Good luck. You can do this around a full-time job. Many have. You will too.