Most senior backend prep plans are book lists. This isn’t one. It’s a structure for allocating the ~120 hours you actually have, across the four surfaces a senior loop tests — with an opinion on where those hours are well spent and where they’re wasted.
Who this is for
A mid-to-senior backend engineer (IC3 → IC4, L4 → L5, SDE II → SDE III) targeting senior IC roles at product companies and comparable scale-ups. You’ve shipped real systems, you’ve owned something in production, and you can solve a medium Leetcode problem cold within 25 minutes. This is not a start-from-zero plan.
Company-specialized prep (Meta, Google, Amazon) specializes from this plan, not the other way around. Those specializations live separately and focus on the signal-specific ritual each company layers on top of the generic loop.
What this plan assumes
- Baseline. Mediums cold. 3+ years backend experience. One domain you can talk about without notes.
- Time commitment. ~120 hours total across ~12 weeks at ~10 hrs/week. Scales linearly — 6 weeks at 20 hrs/wk is the same plan, compressed. 24 weeks at 5 hrs/wk is the same plan, stretched. Do not compress below 6 weeks.
- Scope. Four surfaces a senior backend loop tests: coding, system design, behavioral, deep-dive. Covered in detail below.
- Out of scope. Frontend-heavy loops, ML/AI-heavy loops (see the AI-system design pieces in the system design category), kernel/embedded specializations, and anything resembling new-grad fundamentals.
One assumption worth naming explicitly: this is a plan to pass a strong senior loop, not to become a better engineer. The two overlap but they are not identical, and conflating them is how people end up spending three months on material that doesn’t move the loop needle. Keep the goal clean.
The four surfaces
Before the phases, the shape of what you’re preparing for.
| Surface | Rounds | Duration | Weight at senior |
|---|---|---|---|
| Coding | 2 | 45 min | Baseline gate |
| System design | 1–2 | 45–60 min | High |
| Behavioral / leadership | 1 | 45 min | Rising |
| Deep-dive / past projects | 1 | 45–60 min | High, underprepared |
The two most underprepared surfaces at senior level are behavioral and deep-dive. That’s where the cheapest wins are, and where strong candidates with weak prep still get down-leveled.
The plan
Five phases. Phase 0 is diagnosis. Phases 1–3 are the work. Phase 4 is the taper. Each phase ends with a milestone — if you can’t meet it, don’t advance.
Phase 0: Diagnose and scope (~1 week, ~8–10 hours)
You are buying information about yourself, not producing output.
- Take one mock of each surface. Not to pass. To measure. Record them.
- Self-assess. Against the Phase 0 row of the milestones table below.
- Lock targets. Companies, level, timeline. Don’t start Phase 1 with these still floating.
- Outline the story bank. 10 titles, one line each — no writing yet. Cover leadership, ambiguity, conflict, failure, scope, influence without authority.
- Outline the project briefs. Pick 2–3 projects for the deep-dive round. One line each at this stage.
Milestone: you can name your weakest surface, your strongest story, and your targeted companies and level, without hedging.
Phase 1: Foundations (~3–4 weeks, ~10 hrs/week)
Rebuild the base across all four surfaces in parallel. Breadth first, depth later.
Coding. Work a pattern list, not a problem list. The goal is recognition, not recall. A strong senior solves a new medium in 20 minutes because they saw the pattern in the first 60 seconds, not because they’ve seen the problem before. NeetCode 150 or equivalent is the right length — long enough to cover patterns, short enough to finish.
System design. Internalize a structure. Clarify → Estimate → API → Data → Deep dive → Failure modes. Not because the interview follows exactly this order, but because having a default structure frees working memory for the question itself. Read the published walkthroughs in this category — they model the structure.
Behavioral. Outline 8–10 stories. One page each, structured but not scripted. The stories are raw material; the delivery comes later.
Deep-dive. Write a 1-page brief for each of your 2–3 chosen projects. Structure: scope, architecture, tradeoffs, what you specifically did, measurable impact. The “what you specifically did” line is where most people’s briefs fall apart and where interviewers probe hardest.
Milestone: solve a new medium by pattern in 20 minutes. Structure any system design answer cold. Tell any story at 3-minute length. Defend any project brief out loud without re-reading it.
Phase 2: Depth (~3–4 weeks, ~10 hrs/week)
Narrow. Deepen. The first phase was breadth insurance; this one buys quality.
Coding. Add selected hards — only on patterns that gated you in Phase 1 mocks. Do not grind hards uniformly. A 400-problem Leetcode count is almost always a signal of avoidance: the candidate is collecting solved problems instead of working the patterns they’re weak on.
System design. Three canonical walkthroughs cold, end to end, with a timer. The published walkthroughs in this category — ad click aggregation, RAG system, URL shortener, chat system, and news feed — are the baseline set. You should be able to produce each from memory at whiteboard quality.
Behavioral. Narrow from 10 stories to 6. Refine each to two lengths: a 90-second version and a 3-minute version. Senior interviewers will ask for both, often in the same round. Delivery matters as much as content — record yourself, watch it, iterate. This step is the one most people skip and most regret skipping.
Deep-dive. One full mock per project brief. The gap between having a written brief and defending it live under adversarial questioning is wider than almost anyone expects. The questions that crack a brief are not “what did you build” but “what would you do differently” and “why not the obvious alternative.” Prepare for those.
Milestone: ~70% mock pass rate across all four surfaces. Not 100%. 70%.
Phase 3: Integration and mocks (~2–3 weeks, ~12 hrs/week)
Stop studying. Start performing.
- Weekly cadence. Minimum 4 coding mocks, 2 system design mocks, 1 deep-dive mock. Behavioral mocks are easy to forget; schedule them.
- Mock sources. Pramp and interviewing.io for free peer mocks. Paid services (Karat, Prepfully, Meetapro) for calibrated senior-level feedback. Peer network — friends at target companies — for the highest-signal, hardest-to-schedule version.
- Record every mock. Review within 24 hours. The correction loop is where the gains live; one reviewed mock is worth three unreviewed ones.
- Regression test. A fix on Monday that’s gone by Friday is a fake fix. Re-mock every weak spot at least twice.
Milestone: three consecutive passing mocks per surface, with different interviewers.
Phase 4: Onsite week (~1 week)
Taper volume. Do not introduce new material. The week before an onsite is the wrong time to try something new.
- Daily warm-up. One medium, one 15-minute system design outline. That’s it. 45 minutes, not 4 hours.
- Review, don’t rewrite. Re-read your top 6 stories and your project briefs. Do not revise them. Revision this late erodes delivery.
- Logistics. Sleep, food, commute, rest day the day before. This is a performance round, not a study round.
- Mental frame. You’ve done the work. Your job on the day is to show up and access it.
Milestone: walk in rested, on-pattern, and calm. The prep work is done.
Milestones by phase
| Phase | Coding | System Design | Behavioral | Deep-dive |
|---|---|---|---|---|
| 0 | Solve a medium in 25 min | Name 3 tradeoffs unprompted | 10-story outline exists | 3 project outlines exist |
| 1 | Medium by pattern in 20 min | Structure any SD answer cold | 8–10 stories at 3-min | 2–3 one-page briefs |
| 2 | Hards selectively | 3 canonical walkthroughs cold | Top 6 stories at 90-sec + 3-min | 1 mock per project |
| 3 | ~70% mock pass | ~70% mock pass | Consistent delivery | ~70% mock pass |
| 4 | Maintain, don’t extend | Maintain, don’t extend | Re-read, don’t rewrite | Re-read, don’t rewrite |
A red-flag checklist: if you cannot meet the milestone for a phase, back up a phase rather than advance. Most loop failures trace back to someone advancing phases early because the calendar said to.
Resources by surface
Grouped by surface rather than by phase, because you’ll revisit each across multiple phases.
Coding
- A pattern list (NeetCode 150 or equivalent). Why this, not alternatives: pattern-first ordering trains recognition. LeetCode Top 100 trains recall of specific problems, which is the wrong skill — you won’t see those exact problems in a senior loop.
- LeetCode company-tagged problems. Only if you’re targeting a specific company and already through a pattern list.
- Cracking the Coding Interview. A reference, not cover-to-cover reading. Use it for specific topics you’re gating on — the “Moderate” section’s reasoning templates are its most useful content.
- Skip: generic “top 1000 Leetcode problems” lists, problem-hoarding Discord servers, any resource that rewards volume over review.
System design
- Alex Xu, System Design Interview Vol 1 & 2. Why this: the most accurate signal-to-effort ratio of any system design resource. Covers ~80% of the questions that actually get asked. Read both volumes cover to cover — they’re short enough.
- ByteByteGo. For questions not in Xu. Paid, high signal.
- The published walkthroughs in this category. They model the answer structure you’ll use in every question.
- Designing Data-Intensive Applications (Kleppmann). Optional at senior. Required at staff+. If you have 120 hours and you’re at senior, it is not the best return on your time; it is, however, the best return on your career.
Behavioral
- Skip the generic interview books. STAR templates memorized to the word produce scripted-sounding answers that interviewers have heard before and grade down. Structure your stories, don’t script them.
- Build a story bank. A story bank piece is in our career-development backlog; in the meantime, the structure that works: title, 1-sentence context, the challenge, what you did specifically, the measurable outcome, what you learned.
- Company-specific signal decoding. Each major company has a handful of signals they grade on (Meta has six, Amazon has its leadership principles, etc). Company-specific prep pieces are on the roadmap; for now, the signal lists are public and worth reading in full for any company you interview at.
Deep-dive
This is the surface with the thinnest external material. Most generic prep doesn’t cover it at all; the material that exists treats it as a subset of behavioral, which it isn’t.
- The Staff Engineer’s Path (Tanya Reilly). Why this: the chapters on scope, influence, and the difference between what you did and what you were responsible for map directly onto what the deep-dive round probes. Read chapters 2, 4, and 7.
- Architecture Decision Record format. Use it as the template for writing up your own projects. The ADR structure — context, decision, consequences — is the same structure interviewers will probe.
- Your own documentation. Design docs, RFCs, and postmortems you wrote at previous jobs are the highest-signal source material for this round. Re-read them; they will surprise you.
What to cut if time is short
Every prep plan survives first contact with reality for about two weeks. Here is how to compress without gutting it.
At 6 weeks. Phase 0 in 2 days. Phases 1 and 2 combined into 3 weeks of aggressive work. Phase 3 at 2 weeks. Phase 4 at 1 week. Same structure, twice the per-week load. Do not skip Phase 0 — diagnosis is the highest-return hour in the entire plan.
At 3 weeks. Speed run. Pick your weakest surface from Phase 0. Ignore others for two weeks; the others get maintenance only (one rep per week). Week 3 is mocks-only across all surfaces. Expect lower pass rates; the plan is triage, not optimization.
Never cut regardless of timeline.
- Deep-dive preparation. The single most underprepared surface; the first one to cut for most candidates, and the one most responsible for level downgrades.
- The behavioral story bank. Skippable until you need it, then unskippable.
- Phase 0 diagnosis. Prep without measurement is prep without feedback.
Cut without guilt.
- Reading any 400+ page book cover-to-cover. Use books as references.
- Collecting Leetcode problems you won’t actually solve. A bookmarked problem is a future debt, not a present asset.
- Rewriting your stories past the third revision. Revisions after three erode delivery more than they improve content.
A contrarian note worth stating explicitly: most senior candidates over-prep coding and under-prep deep-dive. If you have to cut something, cut the 200th medium before you cut the second project brief. The marginal return on problem 200 is close to zero; the marginal return on a well-prepared project brief is an entire level-fit decision.
Common failure modes
Five patterns that show up in loop debriefs with disproportionate frequency.
- Problem hoarding. Solving without reviewing. Counting problems solved instead of patterns mastered. A candidate who has solved 400 problems and reviewed 20 is weaker than one who has solved 60 and reviewed all 60.
- Behavioral template vomit. Reciting STAR-structured stories so smoothly they sound rehearsed. Interviewers grade rehearsed answers as “low authenticity signal,” which is not the signal you want.
- Single-mock bias. One mock with one interviewer giving one piece of feedback is a sample size of one. Do not rewrite your entire system design structure based on it. Wait for the third consistent data point.
- Over-scoping system design. Trying to cover every topic shallowly instead of committing to 2–3 deep dives on the ones that matter. Senior interviewers grade depth, not breadth.
- Deep-dive ambiguity. “We designed X, then the team shipped Y.” Without a clear answer to “what did you specifically do,” you are asking the interviewer to grade the team, not you. They will grade you down.
After you pass
- Take 1–2 weeks off before onboarding. You earned it; you will need it.
- Negotiate. The gap between accepting the first number and the third counter-offer is usually 10–25% at senior. This is not our pillar but it is free money.
- Your first year is the promo cycle. The framing you’ll want is in the career-development pillar, particularly around aligning projects with the level you’re trying to reach.
This plan is deliberately structured to be compressible, skippable in parts, and opinionated about what doesn’t make the cut. If it matches your situation, use it straight. If it doesn’t, adapt the phases — the structure holds across most senior backend loops even when the calendar doesn’t.