System Design Interview Prep Plan: A 2, 4 and 8 Week Schedule (2026)

Picture a candidate with three weeks and a list of thirty lessons. She reads one a day, understands each, and has never drawn a design under a timer. In the room the first diagram takes ten minutes, and the interviewer is still waiting for requirements.

The gap is not knowledge. It is the schedule. Reading is easy to schedule, so it takes every hour. The skills the round scores (drawing from memory, talking while drawing, finishing on time) get none.

This capstone is a schedule that fixes the ratio. It covers four plan lengths, the lesson order for each, a daily rhythm, a review routine and the final-week checklists. The mock interview practice guide owns the drill routine and the scoring rubric, so every mock below points there. Employer facts were checked on October 24, 2026.

Which Level Are You Preparing For?#

Level decides how much of the round you must drive, so it decides what to practise. The framework lesson sets out who drives at each level. The last column below is this plan’s judgement.

Now pick a track. Count how many rows are true for you today. Two or more means choose the longer plan in the next section.

How Many Weeks Do You Have?#

Hours are announced assumptions, not research. Assume a working engineer with a full-time job.

3 days  x 5 h  = 15 h
2 weeks x 12 h = 24 h
4 weeks x 8 h  = 32 h
8 weeks x 6 h  = 48 h

What to Read, in What Order#

Read components before the problems that use them. A feed design is easier once caching and fan-out are familiar. Each lesson shows the time in minutes printed on its own page. Each list below is added to the one before it, so the 8-week plan includes all three.

In the 2-week core

• Building blocks: Framework (20 min), estimation (20 min), blocks (35 min), caching (30 min), load balancers (30 min)
• Data and messaging: SQL vs NoSQL (45 min), CAP (30 min), sharding (25 min), events (35 min), delivery (30 min)
• Classic problems: URL shortener (35 min), news feed (40 min), chat (40 min)
• Reliability: Failure modes (30 min)

Added at 4 weeks

• Data and messaging: Consistent hashing (25 min), Kafka vs RabbitMQ (35 min)
• Classic problems: Rate limiter (40 min), notifications (40 min), file storage (40 min)
• Reliability: Follow-ups (30 min)
• AI systems: LLM design (35 min)

Added at 8 weeks

• Building blocks: Rate limiting (35 min), CDNs and object storage (40 min), API gateways (35 min), scaling (40 min)
• Data and messaging: Monolith vs microservices (35 min), ordering (25 min)
• Classic problems: Crawler (40 min), typeahead (35 min), video (45 min), ride sharing (45 min)
• AI systems: AI gateway (35 min), agents (35 min)

Three names need a gloss: shardingSplitting one database's data across several machines by a key, a CDNContent delivery network: servers near users that cache copies of files and consistent hashingA way of spreading keys over machines so adding one machine moves few keys. Add the minutes (all in the table’s own numbers):

2 weeks: 445 min (14 lessons)
4 weeks: 445 + 245 = 690 min
8 weeks: 690 + 445 = 1,135 min

The 3-day path is a subset: framework, estimation, blocks, caching, URL shortener, chat and failure modes, 20 + 20 + 35 + 30 + 35 + 40 + 30 = 210 minutes. Each problem also has a follow-ups lesson (linked from the problem). Read those only for problems you will likely be asked.

The Daily Rhythm: Learn, Draw, Mock, Review#

Every session has the same four beats. Close the lesson, then draw the design from memory: that step, not the reading, is the practice. Retrieval practice means pulling an answer out of memory instead of looking at it again.

Assume 60 minutes on weekdays and 180 on the weekend (8 hours in all):

Learn:  5 x 30 + 40 = 190 min
Draw:   5 x 20 + 30 = 130 min
Review: 5 x 10 + 20 + 15 = 85 min
Mock:   45 + 30 = 75 min
Total:  480 min = 8 h

That answers the prediction: learning is 190 of 480 minutes, call it 40%. A lesson longer than 30 minutes spills into the draw block; finish the drawing on Saturday. For the mock itself (how to run it, how to score it), follow the mock interview practice guide.

The Week-by-Week Schedules#

The 4-week plan below is the default. Its four weeks have one focus each, and a mock every Sunday.

Reading in that table: 170 + 230 + 195 + 95 = 690 minutes (the 4-week total above) against 4 x 190 = 760 learn minutes, so 70 are spare. Mock 1 is cold on purpose: a weak result in week 1 tells you where to spend the next three weeks.

The other lengths:

Mocks: 2, 4, 4 and 7 for the four plans, with Mock 1 in week 1 and then weeks 3 to 8 for the 8-week plan. Run each on a problem you have not drawn in the last five days, or a new prompt from a peer. These counts are judgement.

When a Week Goes Wrong: Re-Plan Rules#

Plans slip. Decide the rule now, so a bad week does not become a rewrite. These rules are judgement.

The order of what to protect is: mocks, then drawing, then review, then new lessons.

Spaced Review: Why the Gaps Widen#

Two papers shape the review routine. Cepeda and colleagues pooled 839 assessments of distributed practice from 317 experiments in 184 articles, and found that the best gap between study sessions grew as the time until the test grew (Cepeda et al.).

Roediger and Karpicke had students read prose passages, then either restudy or take recall tests. Restudying won on a test 5 minutes later. Testing won after 2 days and 1 week, even though restudying left students more confident (Roediger and Karpicke).

The tracker sets the next date from your confidence score (judgement):

Drop any review that falls in the last 2 days. In a 2-week plan the ladder stops at day 7, which is one reason short plans retain less.

Problem Order, Easy to Hard#

Each problem below reuses an earlier one, so the order is part of the method. The “trains” column comes from the course’s own problem notes.

What Employers Say, as of 2026-10-24#

Employers publish little, and most of it is thin. The table holds only what each page states. For anything else, the honest label is varies by team.

Three details matter. Meta’s page says select roles include an authorised AI assistant, that candidates are expected to use it, and that no outside AI tools are authorised. It does not say which roles or levels this covers, and candidate accounts differ on whether a particular design round actually had the assistant, so confirm yours with the recruiter. An older Meta post (October 2022) calls the design round 45 minutes, systems or product (Meta), which fits the framework’s clock.

Reports are weaker than pages. 404 Media reported in July 2025 that Meta would let some coding candidates use an AI assistant (404 Media). In May 2026 Business Insider reported a Google pilot for junior and mid-level candidates on select US teams, in a code-comprehension round (Miami career center, summarising the report). Both concern coding rounds. Practise with and without an assistant, and ask for each round’s rules in writing.

The Last Week and the Day Before#

The day before is light: redraw two designs for 20 minutes each, rehearse the first minute (your opening questions), recite the five estimation numbers, pack, sleep. No new topics.

On the day, use time checks from the framework’s boxes: requirements done at minute 5, API at 12, a working design at 25, deep dives finished at 38, wrap-up at 43 (5 + 2 + 5 + 13 + 13 + 5, with 2 spare). Glance at a clock at each.

Practise the tool. If the round uses a text diagram format, such as MermaidA text format for diagrams: a few typed lines render as boxes and arrows (named on Meta’s page above), rehearse it:

flowchart LR
  C[Client] --> S[Service]
  S --> D[(Database)]
  S --> K[(Cache)]

Also test camera and audio the evening before, keep water in reach, and keep a visible clock. All of this is judgement, not an employer rule.

The One-Page Tracker#

One row per topic. Days count from day 0 of the plan. The rows below apply the score table: 1 means tomorrow, 2 in 3 days, 3 in 7, 4 in 14.

How Plans Fail, and What Saves You#

Do not follow this plan for a low-level or object-oriented design round, which the framework lesson excludes, or when a recruiter gives you a topic list. The list wins.

Two weeks versus eight weeks is a trade-off:

Recommendation: pick the shortest plan whose reading list fits with a week spare for review. For most working engineers that is 4 weeks. If you have 8, use the extra time for mocks and review, not for more resources.

Try It: Build Your Own 4-Week Schedule#

Evening 90: learn 40,
  draw 35, review 15
Sunday 120: mock 75,
  redraw 30, plan 15
Learn:  4 x 40 = 160
Draw:   4 x 35 + 30 = 170
Review: 4 x 15 + 15 = 75
Mock:   75
Week:   160+170+75+75 = 480
4 wks:  480 x 4 = 1,920 min
        = 32 h

Variations: mid-level drops Kafka vs RabbitMQ and the failure follow-ups. Senior is the plan above. Staff adds the LLM and AI gateway lessons and one mock on a deliberately vague prompt.

In One Picture#

Plan: shortest that fits + 1 week
Hours: learn 40%, rest drill
Daily: learn 30, draw 20,
  review 10
Weekly: one mock
Review: day 1, 3, 7, 14
Employers: only what pages say