The Complete 60-Day Algorithm Study Plan for FAANG Interviews

Ask ten engineers how to prepare for a coding interview and you’ll get ten answers, most of which amount to “do LeetCode until it stops hurting.” That advice produces a very specific kind of candidate: someone who has solved 400 problems, still panics when a graph question appears, and can’t explain why their solution is O(n log n).

The problem was never effort. It was the absence of a plan.

This is the complete 60 day algorithm study plan we built this entire site around. It takes you from “I know a for-loop” to confidently working through FAANG-style interview problems, in one focused hour a day. Every week below maps directly to our free curriculum, so you can follow along lesson by lesson starting with Day 1.

Why 60 Days Is the Right Timeframe

Study plans for coding interviews cluster at two extremes: the “crash course” (1–2 weeks, pure memorization) and the “someday” plan (six months of open-ended grinding that most people abandon by week three). Both fail for predictable reasons.

Two weeks is too short to build transfer. Cramming solutions to 75 specific problems teaches you those 75 problems. Interviews test whether you can recognize that a new problem is secretly a graph traversal or a two-pointer scan. That pattern recognition is a skill, and skills need repetition spaced over weeks, not days.

Six months is too long to sustain. Motivation research and every abandoned New Year’s resolution agree: goals without a visible finish line decay. When the plan is “study until ready,” every skipped day feels recoverable, so days get skipped until the plan quietly dies.

Sixty days sits in the useful middle:

• Long enough for spaced repetition to work: you’ll revisit arrays while learning trees, and trees while learning graphs, which is when the material actually sticks.
• Long enough to cover the full interview syllabus properly: data structures, sorting, searching, dynamic programming, greedy algorithms, backtracking, and the specialized topics (bit manipulation, string algorithms) that separate strong candidates.
• Short enough to stay urgent. Sixty checkboxes is a countdown, not a lifestyle.
• Realistic about your life. One hour a day for 60 days is ~60 focused hours, comparable to a university algorithms course, without quitting your job to do it.

If your interview is in three weeks, this plan still works. See the compressed variants near the end. But if you can choose your timeline, choose 60 days.

The Week-by-Week Breakdown

The plan is organized into six modules of roughly ten days each. Each module builds on the previous one: the ordering is deliberate, and skipping ahead is the single most common way people sabotage themselves (more on that in the pitfalls section).

Weeks 1–2: Fundamentals (Days 1–10)

Goal: think in algorithms, and make Big-O reflexive.

You start with what an algorithm actually is and how to sketch one in pseudocode before touching a keyboard. Then comes the most important lesson in the entire plan: time complexity. Every interview answer you ever give will end with an interviewer asking “what’s the complexity?” After Day 3, you’ll never guess again.

The rest of the fortnight covers the workhorses: arrays, multi-dimensional arrays, basic sorting, and linked lists through doubly-linked variants.

By Day 10 you should be able to: reverse a linked list on a whiteboard, explain why array insertion is O(n), and sort a list by hand using insertion sort.

Weeks 3–4: Core Data Structures (Days 11–20)

Goal: know every structure an interviewer can name.

This is the densest module. Stacks and queues come first because they’re conceptually light and appear constantly as building blocks. Then trees (the introduction, binary trees, binary search trees, traversals, and heaps), followed by graphs, their representations, and BFS/DFS traversals.

Trees and graphs together account for a huge share of FAANG interview questions. Don’t rush these ten days.

By Day 20 you should be able to: implement BFS and DFS from memory, explain when a heap beats a BST, and convert between adjacency-list and adjacency-matrix representations without thinking.

Weeks 5–6: Searching, Sorting, and DP Foundations (Days 21–30)

Goal: master the algorithms interviewers use as difficulty dials.

Shortest paths, hash tables (the answer to roughly a third of all “optimize this” follow-ups), sets, and binary search, which is far more versatile than “find x in a sorted array,” as interviewers love demonstrating.

Then the classic sorts: quicksort, mergesort, heapsort, and a comparison day that ties them together. The module closes with your first taste of dynamic programming.

By Day 30 (halfway), you can already handle the majority of easy and medium interview questions. This is also the point where the daily review habit (below) starts paying compound interest.

Weeks 7–8: Dynamic Programming (Days 31–40)

Goal: stop fearing the two most feared letters in interviewing.

DP gets ten full days because it’s the topic candidates fail most and the one FAANG interviews over-sample. You’ll work through the canonical problems in order of difficulty: Fibonacci with memoization, longest common subsequence, the knapsack problem, longest increasing subsequence, edit distance, and coin change, then close with greedy algorithms and where they beat DP.

By Day 40 you should be able to: recognize a DP problem from its wording (“count the ways,” “minimum cost,” “maximum value”), define state and transitions out loud, and implement both top-down and bottom-up versions.

Weeks 9–10 (first half): Graph Algorithms and Backtracking (Days 41–50)

Goal: handle the “senior” questions.

Named graph algorithms (Dijkstra’s, Prim’s, Kruskal’s, Floyd-Warshall, Bellman-Ford), plus backtracking through N-Queens and Sudoku. These come up less often than arrays and trees, but when they do, they’re the questions that decide levels and offers.

Final Stretch: Specialized Topics (Days 51–60)

Goal: close the gaps that trip up otherwise-strong candidates.

Bit manipulation, string algorithms (KMP, Rabin-Karp), tries, advanced tree structures, and a final day of competitive programming techniques that doubles as a full-plan review.

By Day 60: there is no standard data-structures-and-algorithms question you haven’t seen the pattern behind.

The Daily 60-Minute Session

The week-by-week map tells you what to study. This is how. The single biggest predictor of finishing is having a fixed session structure, so you never spend your hour deciding how to spend your hour.

Minutes 0–10: Spaced review. Redo one problem from earlier in the plan, ideally one you struggled with. Not read your old solution: redo it, from a blank editor. This is the step almost everyone skips and the step that makes patterns permanent.

Minutes 10–35: Learn today’s topic. Work through the day’s lesson. Type out every code example yourself. Transcription feels slow and works precisely because of it.

Minutes 35–55: Practice. Solve the day’s exercises, or one related problem, without looking at the solution for at least 15 minutes. Being stuck is the workout. If you’re still stuck after 15, read the solution’s first hint only, and try again.

Minutes 55–60: Log it. One or two sentences: what was today’s core idea, and what problem should Future You redo in a week?

That review queue is worth automating. Here’s the exact spaced-repetition scheduler I recommend. It’s also a nice checkpoint: by Day 25 of the plan, every line of it should read as obvious:

 1from datetime import date, timedelta
 2import heapq
 3
 4class ReviewQueue:
 5    """Schedule problem reviews at growing intervals (1, 3, 7, 14, 30 days)."""
 6
 7    INTERVALS = [1, 3, 7, 14, 30]
 8
 9    def __init__(self):
10        self._heap = []  # min-heap of (due_date, problem, stage)
11
12    def add(self, problem: str, solved_on: date, stage: int = 0):
13        due = solved_on + timedelta(days=self.INTERVALS[stage])
14        heapq.heappush(self._heap, (due, problem, stage))
15
16    def due_today(self, today: date) -> list[str]:
17        """Pop everything due, re-schedule each at the next interval."""
18        due = []
19        while self._heap and self._heap[0][0] <= today:
20            _, problem, stage = heapq.heappop(self._heap)
21            due.append(problem)
22            if stage + 1 < len(self.INTERVALS):
23                self.add(problem, today, stage + 1)
24        return due
25
26queue = ReviewQueue()
27queue.add("reverse-linked-list", date(2026, 6, 1))
28queue.add("two-sum", date(2026, 6, 2))
29print(queue.due_today(date(2026, 6, 3)))  # ['reverse-linked-list', 'two-sum']

Why a heap instead of a sorted list? Because insertion is O(log n) and today’s due items pop off in order, which happens to be Day 17’s lesson. The plan teaches you the tools you’ll use to follow the plan.

Weekends: if you have more than an hour, don’t binge new topics. Do one full mock problem under a 35-minute timer, out loud, as if an interviewer were watching. One timed problem per week from Week 4 onward is enough to make the real interview feel familiar.

What a real week looks like

Here’s Week 1 in practice, so you can see how the pieces fit. Every later week has the same shape with harder material:

Nothing about any individual day is heroic. The plan works because Thursday builds on Wednesday, sixty times in a row.

If You Fall Behind

You will miss days. The plan survives if you handle it correctly:

• Missed 1 day: do nothing special. Continue with the next lesson. Do not double up: doubling up turns one missed day into a two-hour obligation you’ll dodge.
• Missed 2–4 days: resume at the next unread lesson and add ten minutes of review time for a week. The sequence matters more than the calendar; “Day 23” can happen on your day 27.
• Missed a week or more: restart the current module (not the whole plan). If you were on Day 27, go back to Day 21. Re-entry through familiar material rebuilds momentum; re-entry through the hardest unread lesson kills it.
• Life happened, interview moved up: switch to triage: jump to the comparison guide and pick a short list for the time you have left, then return afterward.

How to Know You’re Ready

Sixty checkboxes is the schedule, not the goal. Before you interview, verify against this list. Each item maps to lessons you’ll have completed:

• You can implement a hash map lookup solution, BFS, DFS, and binary search from a blank editor without references.
• Given a new problem, you can name a candidate pattern within two minutes and say what in the wording suggested it.
• You state time and space complexity after every solution without being asked.
• You’ve solved at least five problems out loud, under a timer, with no pauses longer than a thought.
• Reading your review log’s oldest entries feels easy: problems that once took 40 minutes now take 10.

If any item fails, you don’t need more days. You need more of the specific behavior that item describes.

Common Pitfalls (and How to Avoid Them)

After watching thousands of learners go through this material, the failure modes are remarkably consistent. None of them is “the material was too hard.”

1. Skipping ahead to the scary topics. Anxious candidates jump straight to dynamic programming because it’s what they fear. But DP problems are recursion + arrays + hash tables wearing a trench coat. Without Days 1–30, Day 31 is memorization, not understanding. Trust the ordering; fear of DP is usually a fundamentals gap in disguise.

2. Watching instead of writing. Reading a solution and nodding is the study equivalent of watching fitness videos. If your fingers didn’t type the code and your voice didn’t explain the approach, it didn’t happen. The 60-minute structure exists specifically to force output every single day.

3. Grinding problem counts. “I’ve done 300 problems” is not a credential; interviewers can tell within minutes whether you recognize patterns or recall solutions. Twenty problems understood deeply (solved, explained aloud, redone a week later) beat a hundred solved once. This is also the core difference between this plan and list-based approaches like Blind 75 or NeetCode.

4. Breaking the chain twice. Missing one day is noise. Missing two consecutive days is the beginning of quitting: nearly everyone who abandons the plan can point to a specific pair of skipped days. The rule: you may miss a day, but never two in a row. A ten-minute session that only does the review step still counts.

5. Practicing in silence. The interview is a spoken exam. If the first time you narrate your reasoning is in the actual interview, you’ll discover that explaining while coding is a separate skill, one you haven’t practiced. From Week 3 onward, talk through every practice problem out loud, alone in a room, like a maniac. It works.

6. Ignoring complexity analysis. Every practice problem should end with you stating time and space complexity, unprompted. Interviewers at every FAANG company ask; making it a reflex during practice means one less thing consuming brainpower under pressure.

Adapting the Plan to Your Timeline

30 days: double up, two lessons per day, 90–120 minutes. Keep the review step; drop the weekend mocks until the final week. Prioritize Days 1–40 and compress 41–60 into pattern-recognition reading.

90 days: perfect. Follow the 60-day plan, then spend the extra month on timed mocks, company-specific problem lists, and redoing every problem in your review log.

14 days (emergency): this plan isn’t for you. Do a focused list instead, and read our comparison of NeetCode, Blind 75, and structured plans to pick the right one. Then come back after the interview and build the foundation properly.

For the broader picture (behavioral rounds, system design, and how Google, Meta, and Amazon actually differ), read the companion guide: How to Prepare for a FAANG Interview.

Start Today, Not Monday

There is no version of this where waiting helps. The plan is free, the full curriculum is laid out day by day, and Day 1 takes about twenty minutes.

Sixty days from now you’ll either be a candidate who recognizes patterns and narrates complexity analysis by reflex, or you’ll be sixty days older and still bouncing between resources. One focused hour a day. That’s the whole trick.

Related Reading

• Full 60-Day Curriculum
• How to Prepare for a FAANG Interview: The Complete Guide
• NeetCode vs Blind 75 vs 60-Day Plan: Which Should You Use?
• The Best FAANG Interview Prep Resources in 2026
• Day 1: Introduction to Algorithms