The 60-Question Blind 75 Sequencing for FAANG L4-L7

Blind 75 is the most-cited prep list in FAANG interview preparation, but every guide that recommends it presents the problems in the same flat 14-bucket structure the original 2020 Blind post used. That structure was written for a candidate who'd never seen a LeetCode problem. If you're targeting L4-L7 — staff, senior, principal — that ordering wastes the first three weeks teaching you patterns you already know and leaves the highest-leverage senior-track problems for the end, where you usually run out of time.

This post is the sequencing we'd give a friend at L5 or above with eight to ten weeks until their loop. Sixty of the seventy-five problems, in the order they actually compound on each other, with the fifteen we'd cut and the four phases an L7+ candidate should add on top.

Key takeaways

• The original Blind 75 ordering is bucketed by data structure (Array, Tree, Graph). For a senior candidate, that ordering is wrong — it teaches breadth before depth. Pattern-first sequencing (sliding window, two pointers, monotonic stack, then graph patterns) compounds faster.
• Fifteen of the seventy-five problems are base templates that a candidate at L4+ has already internalized. Skipping them frees ~12 hours that can be redirected to system design or behavioral prep.
• L5 is the inflection where problem density at the round-level changes. Below L5, prioritize coverage. At L5+, prioritize speed-to-template-recognition — interviewers at staff and above probe optimization paths and edge cases harder than they probe correctness.

How the standard Blind 75 ordering breaks down for senior candidates

The original Blind post organizes 75 problems into 14 buckets — Array (8), Binary (5), DP (12), Graph (6), Interval (5), Linked List (6), Matrix (4), String (10), Tree (15), Heap (4). The implicit study path is "go through the buckets in order; inside each bucket, easier problems first."

That works for a new-grad candidate building base templates from scratch. It does not work for a senior candidate, for three reasons.

1. Senior candidates already have base templates. A staff engineer who has shipped systems for ten years knows what a hash map is, can implement a binary search without thinking, and has written enough recursion to recognize it instantly. Spending three days on the Array bucket's easier problems (Two Sum, Best Time to Buy and Sell Stock, Contains Duplicate) is review, not learning.

2. The interview rubric at L5+ probes pattern recognition, not data structure familiarity. The interviewer's question is "did the candidate identify the pattern in the first 90 seconds?" not "did the candidate eventually arrive at a correct solution?" The right preparation is a pattern-fluency drill, not a coverage walk. For the underlying patterns, see the 23-pattern pillar.

3. The senior-track patterns are back-loaded. Interval problems and graph problems — the ones interviewers at L5+ favor because they admit multiple optimization paths — sit in buckets 7 and 4 of the original 14. A candidate who runs out of prep time loses exactly those buckets.

The 60-question sequencing — ten phases over eight weeks

The sequencing below is pattern-first, with each phase building on the recognition skills the previous phase trained. We removed fifteen of the seventy-five problems (listed at the bottom) — they're either redundant with another problem in the list or they're the base-template problems an L4+ candidate already knows cold.

Total: 60 problems across 10 phases. Eight weeks at 7-9 problems per week (~12 hours/week).

Phase 1 — Two pointers and sliding window (week 1, 6 problems)

Open with the patterns that recur most often inside other problems. Sliding window appears inside string problems, array problems, and even some linked-list problems. Two pointers is the foundation for the interval phase later.

• Container With Most Water (two pointers, opposite ends)
• 3Sum (two pointers + sort)
• Longest Substring Without Repeating Characters (sliding window)
• Longest Repeating Character Replacement (sliding window)
• Minimum Window Substring (sliding window, hard)
• Valid Palindrome (two pointers, opposite ends)

Phase 2 — Hash and prefix patterns (week 2, 6 problems)

The bridge between two-pointer thinking and the more complex array work to come. Group Anagrams introduces the bucketing pattern that returns under disguise in graph problems.

• Two Sum (hash for complement)
• Top K Frequent Elements (heap or bucket sort)
• Group Anagrams (bucketing)
• Product of Array Except Self (prefix/suffix product)
• Encode and Decode Strings (length-prefix protocol — interviewer favorite at L5+)
• Longest Consecutive Sequence (set lookup with directional walk)

Phase 3 — Binary search beyond the base template (week 3, 5 problems)

The base template — find an element in a sorted array — is assumed knowledge. The phase covers binary search on the answer, on a rotated array, and across two arrays. These are L5+ favorites.

• Search in Rotated Sorted Array (binary search with predicate flip)
• Find Minimum in Rotated Sorted Array (binary search with monotonic invariant)
• Median of Two Sorted Arrays (binary search on partition position, hard)
• Find First and Last Position of Element in Sorted Array (lower/upper bound technique)
• Search a 2D Matrix (binary search with index linearization)

Phase 4 — Stack and monotonic stack (week 4, 5 problems)

The patterns that get the most "huh, neat" reactions from interviewers and the smallest amount of practice from candidates. Trapping Rain Water and Largest Rectangle in Histogram are the L7-favorite probes — the ask is rarely "solve this" and usually "tell me the three different approaches with their trade-offs."

• Valid Parentheses (stack, base check)
• Min Stack (auxiliary stack pattern)
• Daily Temperatures (monotonic decreasing stack)
• Largest Rectangle in Histogram (monotonic stack, hard)
• Trapping Rain Water (monotonic stack or two-pointer, hard — multi-approach probe)

Phase 5 — Linked list (week 4-5, 5 problems)

The base linked-list problems are still on the list because they crop up at the phone-screen stage even for L6+. Skip them only if you can implement reverse and detect-cycle from muscle memory in under two minutes.

• Reverse Linked List (recursion + iterative)
• Linked List Cycle (Floyd's tortoise and hare)
• Merge Two Sorted Lists (merge template)
• Reorder List (split + reverse + merge)
• Reverse Nodes in K-Group (hard, interview favorite for staff probes)

Phase 6 — Trees and BFS/DFS templates (week 5-6, 7 problems)

Trees are over-represented in Blind 75 (15 of 75) for a reason — interviewers love them. We trim from 15 to 7 by cutting the "you already know this" base traversals (Maximum Depth, Same Tree, Invert Tree). For the templates, see BFS vs DFS for FAANG.

• Binary Tree Level Order Traversal (BFS template)
• Validate Binary Search Tree (DFS with bounds)
• Lowest Common Ancestor of a BST (recursive descent)
• Kth Smallest Element in a BST (in-order with early stop)
• Construct Binary Tree from Preorder and Inorder Traversal (index-mapped recursion)
• Serialize and Deserialize Binary Tree (DFS with delimiter, hard)
• Word Search II (trie + backtracking, hard)

Phase 7 — Graphs (week 6-7, 7 problems)

The phase senior candidates underprepare. Course Schedule is the cycle-detection probe; Graph Valley is the BFS-vs-DFS pick probe; Alien Dictionary is the topological-sort probe disguised as a string problem.

• Number of Islands (BFS or DFS with visited set)
• Clone Graph (DFS with hash for memoization)
• Course Schedule (topological sort, cycle detection)
• Pacific Atlantic Water Flow (multi-source BFS)
• Number of Connected Components in an Undirected Graph (union-find or DFS)
• Graph Valid Tree (union-find)
• Alien Dictionary (topological sort on character graph, hard)

Phase 8 — Intervals (week 7, 4 problems)

Small phase, high leverage. Every system-design round that touches scheduling, calendars, or rate-limiting traces back to interval logic. L6+ candidates: do all four; the patterns transfer to system-design discussions.

• Merge Intervals (sort + sweep)
• Insert Interval (binary search insertion + merge)
• Non-overlapping Intervals (greedy by end time)
• Meeting Rooms II (heap of end times)

Phase 9 — Dynamic programming (week 7-8, 9 problems)

Trimmed from 12 to 9 by cutting the "warm-up" DP problems (Climbing Stairs, House Robber I) that L4+ candidates already know cold. The remaining nine cover the four DP patterns interviewers actually probe at L5+: unbounded knapsack, longest-common-subsequence, partition, and DP-on-trees.

• Coin Change (unbounded knapsack, base DP probe)
• Longest Increasing Subsequence (LIS template + binary-search optimization)
• Word Break (DP with set lookup)
• Combination Sum IV (counting unbounded knapsack)
• House Robber II (DP with circular constraint)
• Decode Ways (DP with state-conditional transitions)
• Unique Paths (DP grid template)
• Longest Common Subsequence (2D DP, foundational template)
• Edit Distance (2D DP, hard, L6+ favorite)

Phase 10 — Matrix and bit manipulation (week 8, 6 problems)

Closes the loop with the patterns that recur as sub-problems inside larger questions. Set Matrix Zeroes is the in-place-mutation probe; Spiral Matrix is the boundary-shrinking probe; bit-manipulation problems are the "do you understand the bit-level invariants" probe.

• Spiral Matrix (boundary shrinking)
• Rotate Image (transpose + reverse, in-place)
• Set Matrix Zeroes (in-place marker pattern)
• Number of 1 Bits (Brian Kernighan's algorithm)
• Counting Bits (DP on bit count)
• Sum of Two Integers (XOR + carry, no +)

The 15 Blind 75 problems we cut for L4-L7

The original list problems we omit, by bucket:

• Array (3 cut): Best Time to Buy and Sell Stock, Maximum Subarray, Contains Duplicate. All warm-up patterns.
• Tree (8 cut): Maximum Depth of Binary Tree, Same Tree, Invert Binary Tree, Binary Tree Maximum Path Sum, Subtree of Another Tree, Implement Trie, Add and Search Word, Maximum Depth (alternate). Base traversal templates plus trie problems already implicitly tested in the kept Word Search II.
• DP (3 cut): Climbing Stairs, House Robber I, Jump Game. Warm-up DP a senior already knows cold.
• String (1 cut): Valid Anagram. Same recognition as Group Anagrams (kept).

If you're below L4 or have less than five weeks total, don't cut these — do them. They're warm-ups for new prep candidates, not for senior candidates with prior depth.

For a comparison of Blind 75 against NeetCode 150 and Grind 75 with FAANG match rates, see Blind 75 vs NeetCode 150. For the broader pattern catalog this sequencing is built on, see the 23 LeetCode patterns pillar.

What L7+ candidates should add on top

Sixty problems gets a staff candidate ready for the coding portion. L7+ candidates also face a system-design panel that's deeper than at L5-L6 (often two SD rounds), so the prep mix shifts toward design.

Add four phases on top of the sequencing above:

• Phase 11 — System design fundamentals. Four to six worked designs end-to-end. Start with the system design pillar for the framework, then drill the highest-frequency designs (URL shortener, distributed cache, news feed, rate limiter).
• Phase 12 — Concurrency and distributed primitives. L7 panels probe consensus, leader election, and idempotency at depth. Read the Raft paper sections on log replication; understand exactly-once vs at-least-once delivery.
• Phase 13 — Behavioral library expansion. L7 behavioral focuses on cross-org influence, conflict resolution at the staff/principal scope, and ambiguous prioritization. Build 12-15 stories across those archetypes.
• Phase 14 — AI-allowed round practice. Most FAANG L7 loops in 2026 include at least one round where AI assistance is permitted or expected. Treat those rounds as a different skill set — the failure mode is "candidate mechanically pasted code without understanding," not "candidate couldn't write code." Practice explaining AI-assisted solutions out loud before the interview. (This is a sharp signal interviewers explicitly probe for — see Hacker News discussion of "candidates who get something out, but have no foundation to reason about it.")

How to actually run the eight weeks

The sequencing is the curriculum, not the goal. The goal is pattern-recognition speed.

For each problem in the phase you're on:

1. Read the problem and say out loud which pattern it is in under 90 seconds. If you can't, you don't recognize the pattern yet — that's the gap to close.
2. Solve in target time (Easy: 12 min, Medium: 22 min, Hard: 35 min).
3. If you fail to solve in target time, look at the editorial. Re-do cold the next morning.
4. After completing each phase, write a one-paragraph note in your prep doc explaining the trigger for that pattern — the language in a problem statement that should fire pattern recognition.

Trigger-recognition fluency is the senior-candidate skill. Brute-force coverage is the new-grad skill. They look superficially similar; they're tested differently.

FAQ

Why not just do all 75? You can. The cut 15 are not bad problems — they're problems that an L4+ candidate has already internalized. If you have 12+ weeks instead of 8, do all 75. If you're at 8 weeks, the 12 hours saved by cutting is better spent on system design or AI-allowed round prep.

Should I do this in addition to NeetCode 150? No. Pick one list and run it cleanly. NeetCode 150 covers the same 60 problems plus 90 more. If you have 10+ weeks and want depth, do NeetCode 150 in pattern order. If you have 8 weeks and want speed, do the sequencing above.

What if I'm interviewing at L4 specifically? Use the sequencing above but don't cut the 15 base templates — do them. The L4 phone screen is more correctness-focused than the L5+ rounds, and the warm-up problems still come up.

How much time per day on this? About 1.5-2 hours per weekday plus 3-4 hours on one weekend day. That gets you the ~12 hours per week the sequencing assumes. Lower than that and 8 weeks isn't enough.

Where does AI-assisted prep fit? Use AI heavily during practice — explain solutions back to it, ask it to generate variant problems, drill the patterns. Do not use AI as your first attempt at a problem; that breaks the pattern-recognition feedback loop the sequencing relies on. For the live-interview side of the AI question, see the post-ChatGPT FAANG hiring shifts.

For the full 23-pattern pillar this sequencing is built on, see LeetCode patterns. For the broader prep arc with system design and behavioral integrated, see how to prepare for a FAANG interview.

If you're prepping for a round where AI assistance is on the table — Meta, Anthropic, OpenAI loops increasingly run an AI-allowed coding round — FaangCoder is the practice tool we built for that case. Same hotkey, same workflow as the live round. $399 lifetime, $199/mo monthly.