Interview Prep

Start with how interviews are scored

The first five lessons take the interview apart before any code appears. You learn the shape of a round, what a scorecard rewards, how to talk while you code, and how to divide the minutes so the last five are not a panic. A fifth lesson teaches pattern recognition itself: reading a problem for the shape of its input and the question it asks, before reaching for a technique.

That order is deliberate. Most candidates fail on process, not knowledge: they code silently, spend too long on the first idea, or never check a small case. Naming the process first makes every later lesson land on a habit, not just a fact.

What you will learn

The course builds these skills:

• Read a coding problem and name the pattern it hides, from two pointers and sliding windows to heaps and intervals.
• Use a hash map for counting, prefix sums for range questions, and stacks for matching and monotonic runs.
• Search with binary search templates, including searching on the answer instead of on the list.
• Traverse trees and graphs with breadth-first and depth-first search, and choose between them for the question in hand.
• Handle linked lists with fast and slow pointers, reversal, and merging, and spot cycles and middles.
• Build dynamic programming answers from a recurrence, with memoization and tabulation as two ways to keep subanswers.
• Run a system design round in framework order: clarify, estimate, API and data model, scale, and trade-offs.
• Sit full mocks: one timed coding round and one design round, with the common mistakes named and the questions worth asking collected.
• Answer behavioral questions with the STAR shape, talk about your own projects cleanly, and read an offer before negotiating it.
• Close with a game plan: a week-by-week study order built from this course's own lessons.

Who this course is for

Read this course if you already write basic Python and know basic data structures, and interviews are on your calendar. It assumes the ground the DSA Beginner course and the Python Beginner course cover, and it says so plainly rather than re-teaching them.

It fits final-year students, bootcamp graduates, and working programmers switching jobs. The design rounds assume the System Design Beginner course as background; the framework lessons teach the interview order, not the systems themselves.

It is not a first programming course. Readers meeting lists, dicts, and recursion for the first time should begin with Python Beginner and DSA Beginner, then return here to turn that knowledge into interview performance.

How this course works

Work through the lessons in order. Each one builds on the ones before it, and the categories run in teaching order: interview craft, array patterns, stacks and search, trees and graphs, heaps and intervals, linked lists, dynamic programming, design rounds, mocks, practice, and the closing plan.

Every output on the page came from a real run. Each Python block ran twice under system Python 3.12, and the printed result is what both runs produced, character for character. Timed mocks use printed minute plans, not a live clock, so the lesson reads the same on every visit.

Each lesson closes with a single four-option question, and the explanation gives the reasoning behind the answer. Progress is saved in your browser, so closing the page never loses your place.

Frequently asked questions

How long does Interview Prep take?

The 47 lessons add up to 195 minutes of estimated lesson time. At three or four lessons per sitting, the course takes roughly two weeks to read, with the game plan scheduling review after that.

What language is the code in?

Python throughout. Every pattern lesson solves its problems in Python, and the design rounds use Python only for estimation arithmetic and checklists. The ideas transfer to other languages, but the code you run here is Python.

Do I need to finish DSA first?

Basic data structures and basic Python are assumed, not taught here. If lists, dicts, recursion, and trees feel new, start with Python Beginner and DSA Beginner, then come back. The pattern lessons teach recognition and templates, not the structures themselves.

Does the course teach system design from scratch?

No. The five design lessons teach the interview framework: the order of steps, estimation, API and data model choices, scaling, and trade-offs. The systems knowledge itself comes from the System Design courses, named as prerequisites in the lessons.

What happens in a mock?

A mock walks one full round the way an interviewer runs it: clarify the problem, talk through the approach, write the solution, and test small cases, with minute plans printed at each stage. The coding mock uses one array problem; the design mock walks one small system. Nothing is timed live, so the lesson reads the same every time.

What do I have after the course?

A pattern notebook in your own words, a set of timed-round habits, and the closing game plan: which lessons to revisit, how many problems to practise per week, and what to check the night before an interview. The course ends with a plan, not a promise.

Next steps

• System Design ❯ — System Design Beginner covers the systems knowledge the design rounds assume, in 47 lessons: estimation, storage, caching, and scaling, each explained one idea at a time. Read it before your first design mock.
• DSA Intermediate ❯ — DSA Intermediate goes deeper into the structures behind the patterns in 112 lessons, from heaps and tries to graphs and greedy choice. It suits the week a pattern lesson leaves you wanting the structure underneath.
• Python Beginner ❯ — Python Beginner teaches the language every example here runs in, across 116 lessons from first prints to files. If any code in this course feels unfamiliar, that is the place to firm it up.