Day 0 — 90-Day Coding Interview Prep Course Overview

90-Day Coding Interview Prep Course

Senior Engineer → Meta | Google | Netflix | OpenAI | Anthropic

Personalized for a Senior Data Engineer (16 years experience) targeting L5/E5+ equivalent roles at top-tier technology companies.

How this course works

This 90-day plan is structured around 30 minutes of focused daily practice. Each session follows a consistent rhythm:

Phase	Duration	Action
Read & Understand	5 minutes	Read the problem, identify constraints, think about edge cases
Code	20 minutes	Write your solution. If stuck after 10 min, look at hints then code
Review & Reflect	5 minutes	Compare with optimal solution, note the pattern, log any gaps

Four-phase structure

Phase	Days	Weeks	Focus
Phase 1: Foundation Refresh	1–21	1–3	Arrays, strings, linked lists, stacks — rebuild core pattern recognition
Phase 2: Intermediate Patterns	22–49	4–7	Trees, graphs, heaps, DP — master patterns that dominate senior interviews
Phase 3: Advanced & Company-Specific	50–70	8–10	Hard problems, data structure design, company-targeted practice
Phase 4: Simulation & Polish	71–90	11–13	Timed mocks, company-specific drills, gap-filling, final review

Company interview profiles

Each target company has distinct coding interview characteristics. This course maps every problem to the companies most likely to ask it.

Company	Coding rounds	Difficulty	Key characteristics
Meta (E5)	2 rounds (1 traditional + 1 AI-enabled)	Medium–Hard	No pure DP; arrays, trees, graphs. Meta‑tagged LeetCode is highly effective.
Google	1–2 problems in 45 min, plain editor	Medium–Hard	Heavy DS/algo focus. Communication matters as much as solution.
Netflix	Coding + mini system design hybrid	Medium	Practical twist; questions often evolve into scalability.
OpenAI	Practical coding, not pure LeetCode	Medium	Data structure design, debugging, caching; AI use prohibited.
Anthropic	CodeSignal OA (90 min) + live coding	Medium–Hard	Progressive builds (LRU Cache, KV store). Real‑world focus.

Sources (original PDF): hellointerview.com, beyz.ai, getsdeready.com, sundeepteki.org, igotanoffer.com, reddit.com/r/theprimeagen

Phase 1 — Foundation Refresh (Days 1–21 · Weeks 1–3)

Phase 1 rebuilds your muscle memory across the most fundamental data structures and patterns. These problems appear frequently at every target company and form the building blocks for harder problems in later phases.

Week 1: Arrays, strings & hashing (Days 1–7)

Day	Problem	LC #	Diff.	Pattern	Company tag	Time
1	Two Sum	1	Easy	Hash Map	All Companies	10m
2	Valid Anagram	242	Easy	Hashing / Sorting	Meta, Google	10m
3	Group Anagrams	49	Medium	Hash Map Grouping	Meta, Google	20m
4	Top K Frequent Elements	347	Medium	Heap / Bucket Sort	Meta, Google	20m
5	Product of Array Except Self	238	Medium	Prefix / Suffix	Google, Netflix	20m
6	Longest Consecutive Sequence	128	Medium	Hash Set	Google	20m
7	Review Day — Revisit unsolved + timed practice on Days 3–6	—	—	—	—	30m

Week 2: Two pointers, sliding window & binary search (Days 8–14)

Day	Problem	LC #	Diff.	Pattern	Company tag	Time
8	Valid Palindrome	125	Easy	Two Pointers	Meta	10m
9	3Sum	15	Medium	Two Pointers / Sort	Google, Meta	20m
10	Container With Most Water	11	Medium	Two Pointers	Google	20m
11	Best Time to Buy & Sell Stock	121	Easy	Sliding Window	All Companies	10m
12	Longest Substring Without Repeating Characters	3	Medium	Sliding Window	Meta, Netflix	20m
13	Binary Search + Search Insert Position	704 / 35	Easy	Binary Search	Google	15m
14	Review Day — Timed re‑solve of Week 2 mediums	—	—	—	—	30m

Week 3: Linked lists & stacks / queues (Days 15–21)

Day	Problem	LC #	Diff.	Pattern	Company tag	Time
15	Reverse Linked List	206	Easy	Linked List	Meta, Google	10m
16	Merge Two Sorted Lists	21	Easy	Linked List Merge	Meta	10m
17	Linked List Cycle + Cycle II	141 / 142	E/M	Fast / Slow Pointer	Google	15m
18	LRU Cache	146	Medium	Hash Map + DLL	Anthropic, Meta	25m
19	Min Stack	155	Medium	Stack Design	OpenAI	15m
20	Valid Parens + Min Remove Parens	20 / 1249	E/M	Stack	Meta	25m
21	Review + Phase 1 Assessment — Timed: 3 random problems	—	—	—	—	30m

Phase 2 — Intermediate Patterns (Days 22–49 · Weeks 4–7)

Phase 2 tackles the patterns that dominate senior‑level coding interviews: binary trees, graph traversals, heaps, and dynamic programming. These problems require deeper algorithmic thinking and are the core of Google and Meta interviews.

Week 4: Binary trees (Days 22–28)

Day	Problem	LC #	Diff.	Pattern	Company tag	Time
22	Invert Binary Tree	226	Easy	DFS	Google	10m
23	Maximum Depth of Binary Tree	104	Easy	DFS / BFS	Google	10m
24	Binary Tree Level Order Traversal	102	Medium	BFS	Meta, Google	20m
25	Binary Tree Vertical Order	314	Medium	BFS + Hash Map	Meta	20m
26	Lowest Common Ancestor	236	Medium	DFS	Meta, Google	20m
27	LCA of Binary Tree III	1650	Medium	Two Pointers on Tree	Meta	20m
28	Review Day — Revisit tree problems, focus on recursive patterns	—	—	—	—	30m

Week 5: Graphs — BFS / DFS (Days 29–35)

Day	Problem	LC #	Diff.	Pattern	Company tag	Time
29	Number of Islands	200	Medium	BFS / DFS Flood Fill	Google, Meta	20m
30	Clone Graph	133	Medium	BFS / DFS + Hash Map	Meta	20m
31	Course Schedule	207	Medium	Topological Sort	Google	20m
32	Course Schedule II	210	Medium	Topological Sort	Google	20m
33	Word Ladder	127	Hard	BFS	Google	25m
34	Accounts Merge	721	Medium	Union‑Find / DFS	Meta, Google	25m
35	Review Day — Graph traversal patterns + cycle detection	—	—	—	—	30m

Week 6: Heaps, intervals & greedy (Days 36–42)

Day	Problem	LC #	Diff.	Pattern	Company tag	Time
36	Kth Largest Element in Array	215	Medium	Heap / Quickselect	Meta, Google	20m
37	Find Median from Data Stream	295	Hard	Two Heaps	Meta, Google	25m
38	Merge Intervals	56	Medium	Sort + Sweep	Meta, Google, Netflix	20m
39	Meeting Rooms II	253	Medium	Heap / Sort	Google, Meta	20m
40	Task Scheduler	621	Medium	Greedy / Heap	Meta	20m
41	Non‑overlapping Intervals	435	Medium	Greedy	Google	20m
42	Review Day — Heap operations + interval merge pattern	—	—	—	—	30m

Week 7: Dynamic programming foundations (Days 43–49)

Day	Problem	LC #	Diff.	Pattern	Company tag	Time
43	Climbing Stairs	70	Easy	1D DP	Google	10m
44	House Robber	198	Medium	1D DP	Google	15m
45	Coin Change	322	Medium	DP	Google	20m
46	Longest Increasing Subsequence	300	Medium	DP / Binary Search	Google	20m
47	Unique Paths	62	Medium	2D DP	Google	15m
48	Word Break	139	Medium	DP + Trie / Hash	Google, Meta	25m
49	Review + Phase 2 Assessment — Timed: 3 random problems	—	—	—	—	30m

By the end of Phase 2, you should recognize tree/graph traversal patterns on sight, implement BFS/DFS without reference, and know when DP applies vs. greedy approaches.

Phase 3 — Advanced & company‑specific (Days 50–70 · Weeks 8–10)

Phase 3 elevates your preparation to interview‑level difficulty. You will tackle hard LeetCode problems, build practical data structures (critical for OpenAI and Anthropic), and practice company‑specific problem patterns.

Week 8: Advanced trees & graphs (Days 50–56)

Day	Problem	LC #	Diff.	Pattern	Company tag	Time
50	Serialize / Deserialize Binary Tree	297	Hard	BFS / DFS	Meta, Google	25m
51	Binary Tree Max Path Sum	124	Hard	DFS	Meta, Google	25m
52	Alien Dictionary	269	Hard	Topological Sort	Google	25m
53	Graph Valid Tree	261	Medium	Union‑Find	Google	20m
54	Minimum Height Trees	310	Medium	Topological / BFS	Google	25m
55	Network Delay Time	743	Medium	Dijkstra	Google	25m
56	Review Day — Hard tree/graph problems	—	—	—	—	30m

Week 9: Practical data structure design (Days 57–63) — OpenAI / Anthropic focus

Day	Problem	LC #	Diff.	Pattern	Company tag	Time
57	Design HashMap	706	Easy	Hash Design	OpenAI, Anthropic	15m
58	Snapshot Array	1146	Medium	Binary Search / Design	OpenAI	25m
59	Time Based Key‑Value Store	981	Medium	Binary Search / Design	OpenAI, Anthropic	25m
60	Key‑Value Store with TTL (custom)	—	Medium	Design	Anthropic	25m
61	Implement Trie	208	Medium	Trie	Google	20m
62	Design Twitter	355	Medium	OOP + Heap	Meta	25m
63	Review Day — Data structure design patterns	—	—	—	—	30m

OpenAI / Anthropic note: These companies test practical engineering over clever algorithms. Focus on clean API design, edge‑case handling, and the ability to extend your solution when requirements change mid‑interview. Anthropic’s CodeSignal OA builds progressively — each level adds complexity to the previous solution.

Week 10: Hard problems & mixed practice (Days 64–70)

Day	Problem	LC #	Diff.	Pattern	Company tag	Time
64	Basic Calculator II	227	Medium	Stack / Parsing	Meta	25m
65	Trapping Rain Water	42	Hard	Two Pointers / Stack	Google	25m
66	Median of Two Sorted Arrays	4	Hard	Binary Search	Google	25m
67	Regular Expression Matching	10	Hard	DP	Google	25m
68	Longest Valid Parentheses	32	Hard	Stack / DP	Meta	25m
69	Sliding Window Maximum	239	Hard	Monotonic Deque	Google	25m
70	Review + Phase 3 Assessment — Timed: 3 hard problems	—	—	—	—	30m

Phase 4 — Simulation & polish (Days 71–90 · Weeks 11–13)

The final phase focuses on timed, realistic mock sessions organized by target company. You will practice under interview conditions, identify and fill remaining gaps, and build the confidence needed for peak performance.

Week 11: Meta mock week (Days 71–77)

Day	Problem	LC #	Diff.	Pattern	Company tag	Time
71	Random Pick with Weight	528	Medium	Binary Search	Meta	20m
72	Subarray Sum Equals K	560	Medium	Prefix Sum / Hash	Meta	20m
73	Min Remove Valid Parens (re‑solve)	1249	Medium	Stack (timed)	Meta	15m
74	Nested List Weight Sum	339	Medium	DFS	Meta	15m
75	Dot Product of Sparse Vectors	1570	Medium	Hash / Two Pointer	Meta	15m
76	Full mock — 2 Meta problems in 40 min	—	Mixed	—	Meta	40m
77	Review — Analyze mock performance, revisit weak areas	—	Mixed	Review	Meta	30m

Week 12: Google & Netflix mock week (Days 78–84)

Day	Problem	LC #	Diff.	Pattern	Company tag	Time
78	Longest Palindromic Substring	5	Medium	DP / Expand	Google	20m
79	Decode Ways	91	Medium	DP	Google	20m
80	Search in Rotated Sorted Array	33	Medium	Binary Search	Google	20m
81	Number of Connected Components	323	Medium	Union‑Find	Google	20m
82	Rate Limiter (coding + design)	—	Medium	Design	Hybrid Netflix	25m
83	Full mock — 2 Google problems in 45 min	—	Mixed	Mock	Google	45m
84	Review — Revisit hardest unsolved problems	—	Mixed	Review	—	30m

Week 13: OpenAI & Anthropic mock + final review (Days 85–90)

Day	Problem	LC #	Diff.	Pattern	Company tag	Time
85	Progressive KV Store (Anthropic style)	—	Medium	Design / Build	Anthropic	30m
86	Version‑Controlled Data Structure	—	Medium	Design / Build	OpenAI	30m
87	Debug & Optimize Caching System	—	Medium	Debug / Design	OpenAI	30m
88	Full mock — 2 problems, 45 min (random)	—	Mixed	Mock	Random	45m
89	Full mock — 2 problems, 45 min (weakest topic)	—	Mixed	Mock	Weakest topic	45m
90	Final review — Top 10 hardest + personal cheat sheet	—	Mixed	Review	All Companies	30m

Day 90 final review checklist

• Re‑solve your top 10 hardest problems from the entire course (aim for < 15 min each).
• Create a 1‑page personal cheat sheet of patterns you still find tricky.
• Review all company‑specific tips (see below) for your upcoming interviews.
• Verify you can implement BFS, DFS, Union‑Find, LRU Cache, and Trie from memory.
• Practice explaining your approach out loud — communication is scored at every company.

Quick reference: pattern cheat sheet

The 15 most important coding patterns. For each problem, identify the pattern first — the implementation follows naturally.

Pattern	When to use	Template / key idea	Key problems
Two Pointers	Sorted array, pair finding, palindromes	(L = 0, R = n - 1); move based on comparison	LC 15, 11, 125, 42
Sliding Window	Contiguous subarray/substring optimization	Expand (R), shrink (L) when condition breaks	LC 3, 121, 239
Binary Search	Sorted data, min/max optimization	lo = 0, hi = n-1; shrink by half	LC 704, 33, 4
BFS	Shortest path, level‑order, layer‑by‑layer	Queue + visited set; process level by level	LC 102, 200, 127
DFS	Tree traversal, path finding, backtracking	Recursion or stack; base case + recurse	LC 104, 236, 124
Topological Sort	Dependency ordering, cycle detection in DAG	Kahn’s (BFS + indegree) or DFS post‑order	LC 207, 210, 269
Union‑Find	Connected components, grouping, equivalence	find() with path compression + union‑by‑rank	LC 721, 261, 323
Heap (Top K)	Kth largest/smallest, streaming median	Min‑heap of size K; or two heaps for median	LC 215, 295, 347
Prefix Sum	Subarray sum queries, range sums	prefix[i] = sum(arr[0:i]); range = p[j] - p[i]	LC 560, 238
Monotonic Stack	Next greater/smaller element, histograms	Stack maintains decreasing order; pop when violated	LC 42, 239, 32
Backtracking	Permutations, combinations, constraint satisfaction	Choose → Explore → Un‑choose; prune early	LC 46, 78, 51
DP (1D)	Optimal substructure + overlapping subproblems	dp[i] = f(dp[i-1], dp[i-2], …)	LC 70, 198, 322
DP (2D)	Grid paths, two‑string matching, knapsack	dp[i][j] = f(dp[i-1][j], dp[i][j-1], …)	LC 62, 10, 139
Trie	Prefix matching, autocomplete, word search	Node with children map + isEnd flag	LC 208, 211, 212
Hash Map Design	Custom data structures, LRU/LFU, versioning	Combine hash map + linked list / arrays	LC 146, 706, 981

Company‑specific tips

Tactical advice for each target company’s coding interviews. Adapt your approach to match what each company values most.

Meta (E5 Senior)

• Focus: arrays, strings, trees, graphs. No pure DP. 2 coding rounds (1 may be AI‑enabled).
• Meta‑tagged LeetCode questions are extremely predictive; the pool is well‑known.
• Speed matters — aim to solve mediums in 15–20 minutes with clean code.

Prep strategy

• Drill the top 50 Meta‑tagged LeetCode problems.
• Practice with LC 1249, 314, 227, 215, 1650.
• Talk through your approach before coding.
• Prioritize bug‑free first submissions.

Google

• Focus: heavy DS/algo — binary search, BFS/DFS, trees, heaps, DP, Union‑Find, tries, segment trees.
• You code in a plain text editor (no autocomplete). Communication and structured thinking are scored equally with correctness. 1–2 problems per 45‑minute round.

Prep strategy

• Practice coding without IDE features.
• Verbalize your thought process: state approach, discuss complexity, then code.
• Prepare for follow‑up optimizations on every problem.

Netflix

• Focus: medium LeetCode with a practical twist. Coding rounds carry less weight; system design is king.
• Questions often come in two parts and evolve into mini system designs. Expect scalability questions: “What if this needs to handle 10M users?”

Prep strategy

• For coding rounds, practice problems that bridge to system design (rate limiters, caches).
• Invest most prep time in system design.
• Show senior engineering judgment and trade‑off thinking.

OpenAI

• Focus: practical coding — data structures (SnapshotArray, version control), debugging, caching, cache invalidation. Edge‑case testing emphasis.
• These are not pure LeetCode; they test real engineering skills. Problem‑solving matters more than algorithmic cleverness. AI use is strictly prohibited during interviews.

Prep strategy

• Build real data structures from scratch (KV store, cache).
• Practice debugging others’ code.
• Focus on comprehensive edge‑case handling.
• Write production‑quality code with clear structure and tests.

Anthropic

• Focus: CodeSignal OA (90 min, progressive levels) + live coding in Google Colab / Replit. Problems like LRU Cache, KV DB, banking system, file cache.
• The OA is progressive — each level builds on your previous code. Messy code in Level 1 makes Level 4 impossible. Live coding tests scaling (e.g., 100K requests/sec).

Prep strategy

• Practice building systems incrementally: start simple, then add features.
• Write modular, extensible code from the start.
• Practice timed CodeSignal‑style sessions (90 min, 4 levels).