Plan: Senior Backend Software Engineer Interview Prep

This is a checklist, not an essay. Print it, copy it into your notes app, and check things off. Every item is either a concrete task with a done-state or a link to the resource that covers it.

Who this is for

Backend software engineers targeting senior IC roles, including:

• Google L5
• Meta E5
• Amazon L6
• Senior SWE at Stripe, Datadog, Airbnb, and similar companies

You’ve shipped production systems, led projects across teams, and can solve a medium LeetCode without warming up. You have roughly 12 weeks and ~10–15 hours/week.

This guide is intentionally interview-focused and company-agnostic at its core. Company-specific calibration layers on top once targets are locked. Every recommendation is optimized for interview performance and signal generation.

What gets senior candidates rejected

Coding gets you in the door — it doesn’t get you the offer. At mid-level, coding is often the primary differentiator. At senior, it’s usually table stakes: pass the bar and it barely differentiates. The actual down-level and reject signals at senior are:

• Architecture reasoning. Can’t articulate why this design over the alternatives. Names components but can’t defend tradeoffs or explain what breaks under 10× load.
• Ownership scope. Stories describe work at L4 scope — individual execution, no cross-team impact, no ambiguity navigated.
• Tradeoff articulation. Gives textbook answers (“use Kafka”) without naming the cost, the constraint that forced the choice, or what they considered and rejected.
• Leadership signal. No evidence of influencing without authority, mentoring, or driving alignment when stakeholders disagreed.
• Project depth. Can’t explain their own system two levels deeper than the overview. “The team built it” is the kiss of death in a deep-dive.

Many strong engineers fail senior loops not because they lack the skills, but because they fail to make those skills visible. The senior loop is designed to surface these gaps — every track below maps directly to at least one of them.

Make seniority audible.

Senior interview rubric

What interviewers actually score. This varies by company but the axes are consistent:

The rubric is your mock feedback template. After every mock, score yourself 1–4 on each dimension. Two consecutive 3+ scores across the board is a strong signal that you’re approaching interview readiness.

What senior interviewers are looking for

Six questions every round is designed to answer:

• Can you solve problems under time pressure?
• Can you make tradeoffs and defend them?
• Can you drive through ambiguity without being told what to do?
• Can you influence others and lead without authority?
• Can you explain systems you’ve built in depth?
• Can we trust you to independently own large pieces of a distributed system?

Everything in this guide exists to strengthen one or more of these signals.

The four pillars

At mid-level, coding is 50%+ of prep time. At senior, redistribute — system design and project deep dive are where offers are won or lost. The plan below reflects this shift.

Company calibration

Senior loops are not the same across companies. Calibrate your time allocation:

How to use this: In week 0, identify your targets. Shift time toward the differentiator column. A candidate prepping for Amazon who spends 50% on coding and 10% on BQ has the allocation backwards.

System design: what you need

The full curriculum is in Plan: 9-Week System Design Interview Prep. Here’s what the senior SD round actually tests and how it differs from mid-level:

Mid-level SD asks: can you draw a reasonable architecture? Senior SD asks: can you drive the conversation, identify the hard sub-problem, defend your choices, and discuss what changes at 10–100× scale?

The senior signals in system design:

1. Requirement scoping. You ask the right clarifying questions before drawing anything. You identify the 1–2 constraints that shape the design (consistency vs. availability, write-heavy vs. read-heavy, cost sensitivity).
2. Tradeoff articulation. Every major component choice comes with: what you considered, why you picked this one, what you’re sacrificing.
3. Depth on demand. When the interviewer pushes on one component, you can go 2–3 levels deeper — data model, access patterns, failure modes, operational cost.
4. Evolution thinking. You discuss what changes as scale grows, what you’d build in v1 vs. v2, what you’d revisit if the product requirements shift.
5. Operational thinking. You address how to detect failures, deploy safely, define SLOs, set up alerting, and debug production issues. Candidates who draw architectures but can’t discuss observability, canary deploys, backpressure, or rollback get flagged as lacking production depth.

Follow the 9-week SD plan (weeks 1–9 in this schedule). Its vocabulary → walkthroughs → infrastructure → mocks arc is designed for exactly this level.

Project deep dive: the 4th pillar

Many senior loops include an explicit deep-dive round — and even when they don’t, BQ interviewers will probe your projects at depth. This is where the most down-leveling happens because candidates don’t prepare it deliberately.

Selection (week 0)

Pick 2–3 projects. Selection criteria:

• You made the key technical decisions (not inherited, not the team’s).
• The project had ambiguity — you shaped the problem, not just solved it.
• You can explain the architecture 3 levels deep.
• The outcome was measurable (latency, cost, reliability, revenue).
• At least one project involved cross-team coordination or influence.

Red flags in project selection:

• A project where “the team” did everything and you can’t name your decisions.
• A project that was well-defined when handed to you — no ambiguity navigated.
• A project older than 3 years (details fade; interviewers can tell).

Narrative structure (weeks 1–4)

For each project, write a one-page brief:

• Context (1–2 sentences): what existed before, why change was needed.
• Your role: what was your scope vs. the team’s. Name what you owned.
• Architecture: draw it. Label the components you chose.
• Key decisions: 2–3 forks in the road. For each: what you considered, what you chose, why, and what you’d do differently now.
• Outcome: numbers. Before/after. Business impact if possible.
• Business context: why this mattered now, why the company invested N engineers, what constraint or opportunity drove the timeline. Senior scope is technical decision × business constraint.
• What you’d change: required. This signals self-awareness and senior judgment. “Nothing” is a red flag.

Follow-up preparation (weeks 5–8)

Interviewers will probe. Prepare for these exact questions:

• “Why not [obvious alternative]?” — for each key decision.
• “What would break at 10× scale?” — for your architecture.
• “What was the hardest part?” — and it shouldn’t be “it was technically hard”; it should be a coordination, tradeoff, or ambiguity problem.
• “What would you do differently?” — with a real answer, not false modesty.
• “How did you handle disagreement?” — at least one project needs this.
• “Walk me through the data model / the failure modes / the deployment / the migration strategy.”

Red flags interviewers notice

• Can’t go deeper than the overview: “we used Kafka” but can’t explain the consumer group strategy, partition key design, or retry semantics.
• Takes credit for team work without naming specific decisions.
• No self-criticism — “it all went well” signals lack of reflection.
• Architecture description doesn’t match resume bullet scope.

AI-era senior expectations

As of mid-2026, AI coding assistants are changing what “senior” means in interviews and on the job. Two ways this shows up:

In the loop: A growing number of companies (Shopify, Canva, some Meta/Google pilots) now include an AI-assisted coding round. You code with an assistant while the interviewer grades how you direct, verify, and correct it. See Guide: The AI-Native Coding Interview.

In expectations: Senior engineers are expected to ship faster with AI tools. The bar for “what counts as senior output” is rising. Interviewers increasingly ask: “How do you use AI in your workflow?” and judge whether you’re above the tooling curve. Having a crisp answer — what you delegate, what you verify, where you draw the line — is now a soft BQ signal.

Week 0: Setup (one weekend)

• Lock targets: companies, level, earliest realistic onsite date.
• Take one baseline coding mock (timed, recorded). Score honestly.
• Attempt one system design question cold, 35 minutes, out loud. Note where you stalled.
• List 10 story titles from your last 3–4 years (one line each).
• Pick 2–3 deep-dive projects using the selection criteria above.
• Re-open your design docs, dashboards, tickets, and code for the projects you selected. Memory is not preparation — re-study the numbers, the alternatives you rejected, and the operational details you’ve forgotten.
• Do the resume checklist below.
• Check the company calibration table — shift your time allocation now.
• Book your first peer mock for week 4 (scheduling is the bottleneck).

Done when: you can name your weakest pillar without hedging, and your calendar has the week-4 mock on it.

Resume checklist

Your resume sets the menu for deep-dive and behavioral rounds — every line is a question you’re inviting.

Content:

• Every bullet: action verb + scale + measurable outcome (“Redesigned order pipeline handling 40K orders/day, cutting p99 latency 60%”).
• Numbers on everything that has one: QPS, data volume, latency, cost, team size, users.
• Senior signals present: led, owned, mentored, drove — at least one bullet per job showing scope beyond your own keyboard.
• Zero job-description bullets (“responsible for maintaining services”).
• Every technology listed is one you’ll happily be grilled on.
• The 2–3 deep-dive projects are the most prominent things on the page.

Mechanics:

• One page (two only if 10+ years and every line earns it).
• Tailored top-third per company: match the JD’s language.
• PDF, named firstname-lastname-senior-backend.pdf.

Review:

• One engineer at-or-above target level: “what level does this read as?”
• One recruiter/HM: “what would you ask me about?”
• If either answer surprises you, revise. Two passes max.

The 12-week plan

Coding: 80–120 problems, pattern-first

At senior level, coding is usually a threshold signal rather than the primary differentiator — you still need to clear a high bar, but it won’t win you the offer alone. The exact count depends on your starting point: 80 if you’ve been actively solving problems, closer to 120 if you’re rusty. Pattern recognition is the skill; speed comes from recognition. Rules: 25-minute timer; stuck at 25 → read solution, mark it, redo cold in 3 days.

• Week 1: read the FAANG coding guide. If targeting Amazon: read the L&M guide in week 2.

• Week 1 — Arrays & Hashing (8) + Two Pointers (4) · 12 problems

• Week 2 — Sliding Window (5) + Stack (5) · 10 problems

• Week 3 — Binary Search (6) + Linked List (5) · 11 problems

• Week 4 — Trees I (8) + Tries (3) · 11 problems

• Week 5 — Trees II (5) + Heap (5) · 10 problems

• Week 6 — Backtracking (6) + Graphs I (5) · 11 problems

• Week 7 — Graphs II (6) + Intervals (4) · 10 problems

• Week 8 — 1-D DP (10) · 10 problems

• Week 9 — 2-D DP (8) + Greedy (3) · 11 problems

• Week 10 — Math/Geometry (5) + Bit Manipulation (5) · 10 problems

• Week 11 — Company-tagged problems + weak pattern redo · 12 problems

• Week 12 — Full redo-list sweep · as needed

Total: ~80–120 + redos depending on your baseline. Fewer than the 150 at mid-level because senior time is redistributed to design and depth. Quality of review matters more than count. If you’re passing the week-6 gate comfortably, you can taper coding volume and reinvest in deep dive and SD.

• Week 6 gate: a never-seen medium solved in ≤ 22 minutes, narrating.
• Week 12 gate: redo list empty.

System design track

Follow Plan: 9-Week System Design Prep weeks 1–9 alongside the coding curriculum.

• Weeks 1–9: SD plan as written (~5 hrs/week).
• Keep the notebook habit: one tension + one trap per system.
• Weeks 10–12: SD converts to mocks only. No new reading.

Behavioral track

The senior BQ round grades scope, judgment, and reflection. Foundation reading (week 1): behavioral framework for senior+ and structuring leadership stories.

Build (weeks 1–4):

• Expand 10 titles into one-page outlines: context, challenge, what you did, outcome, what you’d do differently.
• Coverage check — at least one story each for: leadership, conflict, failure, ambiguity, influence without authority, scope/prioritization.

Refine (weeks 5–6):

• Cut to best 6 stories.
• Each story at 90 seconds and 3 minutes. Record yourself once per story.
• Decode target company signals (Meta’s six, Amazon LPs) and tag each story with 2–3 signals it serves.

Maintain (weeks 7–12):

• One story per day, out loud, rotating. Five minutes.
• After week 10: re-read only. Revision past third pass erodes delivery.

Project deep dive track

Build (weeks 1–4):

• Write the one-page brief for each of your 2–3 projects (structure above).
• Your resume bullets and these briefs must agree — check.
• Practice the 5-minute version and the 15-minute version of each.

Stress-test (weeks 5–8):

• For each project: answer every follow-up question in the list above, out loud, recorded.
• Have a peer ask “why not [obvious alternative]?” for every key decision.
• Practice the “3 levels deep” drill: overview → component → implementation detail. If you stall at level 2, you need to re-study your own system.

Polish (weeks 9–12):

• One deep-dive mock per project (use the mock schedule below).
• Calibrate: does your narrative match the level you’re targeting? A project described at L4 scope will down-level you.

AI coding track

• Week 8: read Guide: The AI-Native Coding Interview.
• Week 8: one practice session — build a small service end-to-end with your assistant, narrating prompts and rejections out loud.
• Week 9: second session focused on recovery — spot and fix AI-introduced bugs.
• Week 10: AI coding mock (schedule below).
• Confirm with your recruiter whether your loop includes this round.

Mock schedule

Mocks are the product; everything above is rehearsal inventory.

• Week 4: coding mock #1 — calibration, expect it rough.
• Week 5: BQ mock #1.
• Week 6: SD mock #1 + deep-dive mock #1.
• Week 7: coding mock #2 + BQ mock #2.
• Week 8: SD mock #2.
• Week 9: deep-dive mock #2 + BQ+coding combo.
• Week 10: BQ+SD combo + AI coding mock.
• Week 11: full loop simulation — simulate your target company’s actual format across 2–3 days:
  • Meta: coding ×2 + SD + BQ (with project discussion)
  • Amazon: coding (L&M) + SD + LP round ×2
  • Google: coding ×2 + SD + Googleyness/leadership
  • Stripe: coding + bug hunt + architecture + collaboration
• Week 12: taper. One medium + one 15-minute SD outline per day. Re-read stories and notebook. Sleep.

Rules:

• Record every mock; review within 24 hours.
• Score yourself on the rubric (6 dimensions, 1–4 each) after every mock.
• Re-test every fix in a later mock.
• Never rebuild your approach off one interviewer’s feedback. Wait for the same note twice.

The 12 weeks at a glance

Failure diagnosis

If you’re getting consistent feedback in mocks or actual loops, use this table to identify the root cause and redirect:

What to cut if time is short

6 weeks: Week 0 in two days. Coding compresses to ~75 highest-frequency problems (halve each week). SD plan runs its own 4-week compression. BQ: skip the 10-story phase — write your best 6 directly. Deep dive: write briefs immediately, skip the gradual build. Mocks: one of each format weeks 3–4, both combos week 5, loop simulation week 6. Cut reading before cutting mocks.

Never cut: the deep-dive project briefs (the most down-leveling surface), the resume review loop (two hours, gates everything), the combo mocks, the taper.

Cut without guilt: problem counts past 100, company-tagged grinding before patterns are done, any story revision past the third, new material in the final week.

Common failure modes

• The mid-level habit. Spends 60% of prep time on coding because it feels productive. Passes coding, gets down-leveled on design and depth. Senior prep is about redistribution, not more of the same.
• The mock procrastinator. “I’ll mock when I’m ready.” You get ready by mocking; week 4 is deliberately early and deliberately rough.
• The solo performer. Every track practiced silently. Every senior round is a conversation; if you only change one habit, narrate.
• The shallow deep-dive. “We built X” without being able to explain the partition strategy, the retry semantics, or why you chose this storage over that one. Interviewers notice immediately.
• The combo-blind candidate. Strong at each format, falls apart when the round switches modes at minute 20. Formats 5 and 6 on the mock schedule are the cheapest insurance.
• The resume amnesiac. A resume bullet they can’t defend. If it’s on the page, it’s in the deep-dive menu.

The north star

If you’re overwhelmed by this plan, remember the goal. By week 12, you should be able to:

• Solve a medium problem cleanly under pressure.
• Design a distributed system and defend its tradeoffs.
• Explain your projects three levels deep.
• Tell six stories that demonstrate senior scope.
• Make your ownership, judgment, and influence obvious to interviewers.

That’s what senior loops are trying to measure. Everything else is implementation detail.

After you pass

Take a week off. Negotiate (the first-number-to-third-counter gap at senior is real money). Then the career development pillar picks up — your first year defines the promo cycle.