A Coding-Interview Study Plan Mapped to This Site

Most people fail to prepare in one of two ways. They grind random problems with no order, or they read about topics and never solve anything under time pressure. A plan fixes both. This lesson explains one public plan, shows how many hours it asks for, and maps each week to the lessons of the DSA series so that you learn and practise in one place.

This is the second lesson of the career series. The first was the resume guide, and the next is about practising well with mock interviews. For the other rounds see Live coding and take-home, Full-Stack Lesson 37, System design mock, Full-Stack Lesson 36 and Behavioural questions, salary and offers, Full-Stack Lesson 38.

Words used in this lesson

• Breadth-first means covering every topic quickly, then practising across all of them.
• Depth-first means studying one topic until you are good at it, then moving to the next.
• Pattern means a reusable way to solve a family of problems (two pointers, sliding window, BFS).
• Corner case (or edge case) means an unusual input that breaks naive code: empty input, one element, duplicates, huge values.
• Mock interview means a practice interview with another person who plays the interviewer.
• Grind 75 is a question list and planning tool made by the handbook's author. You choose the number of weeks and hours and it generates a plan.

The numbers from the handbook

The handbook gives these figures. Use them to check your own plan, not to copy it:

The handbook warns that the naive pace "may not build the right approach or retention", and that aimlessly grinding questions is a poor use of time. It also says LeetCode alone is not enough. It advises keeping your time estimates conservative so that you do not burn out.

Three ways to order your study

The handbook describes three approaches:

1. Breadth-first. Revise every topic, then practise across all topics. Suggested if you have about a month.
2. Depth-first. Study and practise one topic at a time until you have mastered it. Suggested if time is short; focus on the high-priority topics.
3. Depth-first, then breadth. Go topic by topic with a few questions each, then do a mixed practice phase. Suggested for more than a month.

The author recommends the first or the third. The reason given is that some breadth-level practice is needed so that you do not forget the earlier topics.

The handbook's 12-week shape

Weeks 1 to 4: study each topic, then practise it straight away. The topics, with the handbook's priority and time:

Weeks 5 to 12: in-depth practice. The handbook lists 75 questions, generated with its Grind 75 tool. You may skip or repeat questions from weeks 1 to 4. It says dynamic programming questions can be skipped if you did not study the topic or it seems irrelevant, because many can be solved with recursion or backtracking. It recommends tracking progress in the tool.

In parallel: write your self-introduction and your final questions (about 3 hours), and start mock interviews at about 60% of the plan, which in a 12-week plan is around week 7.

The same plan, mapped to this site

The DSA series on this site is ordered so you can learn a topic and practise it in the same place. Here is the 12-week table with the matching lessons. (The mapping is mine; the handbook's topics are the left column.) Lesson numbers are the numbers in the URLs, /dsa/lesson-N.

How to practise a topic

The handbook's advice is to study a single concept and practise relevant questions straight away, using its cheatsheets next to your practice. The rest of this section is my own routine for doing that well:

1. Learn the idea first. Read the lesson, trace the example by hand on paper, then close it.
2. Solve a question cold, with a timer. Give yourself about 30 to 40 minutes (the handbook assumes 30 minutes per question for its pace). Say your thinking out loud as in a real interview.
3. When you are stuck, use the order: a smaller example, then a hint, then the solution. Write down what hint you needed.
4. Read a good solution after you finish, even if yours worked. Compare time and space cost.
5. Write a one-line pattern note. For example: "sorted array and pair sum: two pointers". Patterns, not memorised answers, are what carry over.
6. Re-solve the same question after a few days without looking. (Spaced review is my suggestion, not the handbook's, but it is easy to test on yourself: if you cannot solve it again, you had not learned it.)

A weekly routine

Adjust the days to your life. The point is: new material, review, mixed practice and a look at your mistakes every week.

Choosing a language

The handbook recommends a language you know well and that suits interviews, and names Python, C++, Java and JavaScript as common choices. This site's DSA series uses JavaScript. If you already work in JavaScript or TypeScript, use it, and learn its sharp edges: sorting numbers with .sort() sorts them as text unless you pass a compare function, and there is no built-in heap or ordered map, so know how you would write or avoid them. (Check with your target company that your language is allowed.)

Interview day, short version

• Sleep and eat. Arrive early, or test your video, audio and editor setup 30 minutes before a remote interview.
• Say your plan before you code: restate the problem, ask about inputs and sizes, give two examples, outline the approach, say the expected time and space cost.
• Start with a simple correct solution if you cannot see the best one, then improve it.
• Test with your own examples, including empty and one-element inputs, before you say "done".
• Ask your final questions. Prepare them in advance (the handbook's estimate for the introduction and final questions together is about 3 hours).

The techniques inside the interview are the subject of Lesson 2.

Printable checklist

• I chose one language and checked it is allowed.
• I picked a plan length that I can really keep (weeks and hours per week).
• I have a topic order and a lesson for each week.
• I solve new questions with a timer and talk aloud.
• I write a one-line pattern note after every question.
• I re-solve old mistakes every week.
• I will start mock interviews at about 60% of the plan.
• My self-introduction and my final questions are written.

Self-check

1. What does the handbook recommend as a holistic plan? About 3 months at about 11 hours a week (about 2 to 3 hours a day).
2. Name the three ways to order your study. Breadth-first, depth-first, and depth-first then breadth. The author recommends the first or the third.
3. Which topics does the handbook put in week 3, and why is it the heaviest? Tree, graph, heap and trie, about 14 hours: trees and graphs are high priority and need the most time.
4. When should you start mock interviews? At about 60% of the plan.
5. What does the handbook say about grinding hundreds of questions? A pace of 30 minutes per question for about 3 hours a day (about 160 questions in 3 to 4 weeks) may not build the right approach or retention, and aimless grinding is a poor use of time.
6. What do you write after each question? A one-line pattern note: what kind of problem it was and which technique solved it.
7. What is one thing this lesson suggests that the handbook page does not mention? Spaced review of old questions. It is my suggestion.
8. How would you shorten the plan if you only have a month? Use the handbook's depth-first idea on the high-priority topics (array, string, sorting and searching, matrix, tree, graph), keep mixed practice short, and still start mocks about 60% in.

Key takeaways

• A plan beats random grinding: topics in order, practise right after studying, then mixed practice, then mocks.
• The handbook's figures: about 30 hours at the minimum, about 100 hours to be well prepared, and a 3-month plan at about 11 hours a week.
• Three orders: breadth-first, depth-first, or depth-first then breadth (recommended with more than a month).
• Learn patterns, not answers. Write a pattern note after each question.
• Review old mistakes every week. Spaced review is an easy way to test what you really learned.
• Start mock interviews at about 60% of the plan, and keep time estimates conservative.

What's next

Go to Practising well: mock interviews, feedback loops and nerves, Lesson 2. This week, pick your language, choose how many weeks you can keep, and fill in your own copy of the 12-week table with the lessons from the DSA series.