Skip to main content
Course · 70 lessons

Interview Preparation Roadmap.

An interview prep course: process and behavioral fundamentals, DSA in Java or Python, then a SQL, cloud, data engineering or AI/ML track, 70 lessons end to end.

This path covers the whole interview arc: how the process actually works, the algorithmic core every round shares, and then the specific domain round you’ll actually sit for.

Phase 1 — Process & fundamentals

Behavioral answers that hold up, a framework for thinking out loud, complexity you can measure instead of guess, system-design interview basics, and the questions worth asking back.

Phase 2 — Data structures & algorithms: pick one language

Both tracks cover the same patterns — arrays and two pointers, hashing, sliding window, stacks, linked lists and trees, graphs, sorting/searching/heaps, DP, and backtracking — in Java or Python. Work through the language you’ll actually interview in start to finish; the other track is here if you want the same patterns in a second language later.

Phase 3 — Interview coding mechanics

Eight patterns that cover most coding problems, how take-homes and live coding differ, and what a code-review round is actually testing.

Phase 4 — Specialize for your target role

Four independent domain tracks — work through whichever matches the role you’re interviewing for, or more than one if you’re interviewing broadly:

  • SQL-heavy roles: joins and NULLs through query plans, ending in a full mock round.
  • Cloud / infrastructure roles: compute and storage choices through a full architecture design round and an infrastructure-as-code round.
  • Data engineering roles: the SQL and Python rounds, pipeline and data-modelling questions, Spark/streaming, and a take-home project.
  • AI / ML roles: ML fundamentals through deep learning, LLM/RAG questions, ML system design, and MLOps in production.

Phase 5 — Closing the loop

Distributed correctness questions (partitions, retries, exactly-once) that show up across every advanced round, and how to read and negotiate the offer once you get one.

The roadmap, step by step

1
interviews Step 1 of 70

Behavioural Questions

STAR applied to a real question — the answer that gets marked down, the same story told well, and what the interviewer writes on the scorecard.

2
interviews Step 2 of 70

Working a Problem Out Loud

The five minutes before you write code decide the round — clarify, work an example, state the approach, then implement, both versions shown.

3
interviews Step 3 of 70

Complexity Analysis, Measured

Big-O verified against a stopwatch — the hidden quadratic in string concatenation, why amortised O(1) is genuinely O(1), and constant factors.

4
interviews Step 4 of 70

System Design Interview Basics

The 45-minute structure, back-of-envelope sizing that changes the design, and the tradeoffs you volunteer — worked on one question end to end.

5
interviews Step 5 of 70

The Questions You Ask

The last five minutes are scored too — questions that reveal how the team actually works, and the answers that should worry you.

6
dsa-java Step 6 of 70

Java Collections and Their Real Costs

Which collection to reach for and what each operation costs — plus the Integer cache and autoboxing overhead that make Java's traps different.

7
dsa-java Step 7 of 70

Arrays and Two Pointers

Opposite ends, same direction and fast-slow in Java — with the invariant that proves each correct, and the array-copy costs that do not exist in Python.

8
dsa-java Step 8 of 70

Hashing and Counting in Java

HashMap, merge and computeIfAbsent, why an int array beats a map for characters, and the autoboxing tax that makes Java counting slower than a plain array.

9
dsa-java Step 9 of 70

Sliding Window in Java

Fixed and variable windows, the shrink condition that decides which you have, and why substring in a loop turns O(n) back into O(n squared).

10
dsa-java Step 10 of 70

Stacks and Monotonic Stacks in Java

Why ArrayDeque replaced the synchronized legacy Stack, the next-greater-element pattern, and the amortised argument that makes a nested-looking loop O(n).

11
dsa-java Step 11 of 70

Linked Lists and Trees in Java

Reference rewiring without losing the tail, the dummy-head idiom, recursive versus iterative traversal, and Java's StackOverflowError depth.

12
dsa-java Step 12 of 70

Graphs in Java: BFS, DFS, and Topological Sort

Adjacency lists with Map and List, why BFS finds shortest paths on unweighted graphs, and Kahn's algorithm for ordering dependencies.

13
dsa-java Step 13 of 70

Sorting, Binary Search, and Heaps in Java

Comparator without subtraction overflow, the binary search bug that lived in the JDK for years, and PriorityQueue for top-k without sorting all.

14
dsa-java Step 14 of 70

Dynamic Programming in Java

Memoisation with int arrays rather than HashMap, bottom-up tables, the rolling-array space reduction, and long arithmetic where int silently overflows.

15
dsa-java Step 15 of 70

Backtracking in Java

The choose-explore-undo skeleton, why you must copy the path before adding it to results, and pruning that turns hours into milliseconds.

16
dsa-python Step 16 of 70

Python Data Structures and Their Real Costs

Which structure to reach for and what each operation actually costs — measured, including the Python traps that turn linear solutions quadratic.

17
dsa-python Step 17 of 70

Arrays and Two Pointers

Opposite ends, same direction, and fast-slow — three variants that turn a nested loop into one pass, each with the invariant that proves it correct.

18
dsa-python Step 18 of 70

Hashing and Counting

The canonical-key trick, prefix sums in a dict, and the two questions that turn an O(n²) scan into one pass — plus what Python can and cannot use as a key.

19
dsa-python Step 19 of 70

Sliding Window

Fixed and variable windows, the amortised argument that makes a nested-looking loop O(n), and the condition that decides whether a window works at all.

20
dsa-python Step 20 of 70

Stacks, Queues, and the Monotonic Stack

Matching, undoing, and the monotonic stack that answers 'next greater element' in one pass, with the amortised argument behind it.

21
dsa-python Step 21 of 70

Linked Lists and Trees

Pointer reversal without losing the list, the four traversals and when each is right, and the recursion depth that turns a fix into a crash.

22
dsa-python Step 22 of 70

Graphs: BFS, DFS, and Topological Order

Why BFS and not DFS for shortest path, cycle detection that distinguishes directed from undirected, and the two topological sorts explained.

23
dsa-python Step 23 of 70

Sorting, Binary Search, and Heaps

Stability and custom keys, binary search on an answer space with nothing sorted, and the crossover where a heap stops beating a sort.

24
dsa-python Step 24 of 70

Dynamic Programming

Finding the recurrence, converting recursion to memoisation to a bottom-up loop, and the space reduction that turns O(n·m) into O(m) — each step measured.

25
dsa-python Step 25 of 70

Backtracking

One template for subsets, permutations and N-queens — the copy that everyone forgets, and pruning measured as the nodes it never visits.

26
interviews Step 26 of 70

Coding Interview Patterns

Eight patterns that cover most problems — each with the signal that tells you to reach for it, the brute force it replaces, and the timing proof.

27
interviews Step 27 of 70

Take-Homes and Live Coding

Two formats with opposite rules — one rewards polish and scoping, the other rewards narration and recovery. Getting them the wrong way round costs offers.

28
interviews Step 28 of 70

Code Review Interviews

Given a pull request and twenty minutes — the order to read it in, the eight bug classes worth hunting, and why how you phrase a finding is half the score.

29
sql-interviews Step 29 of 70

What SQL Interviews Actually Test

The four things every SQL round scores, a runnable DuckDB dataset you can paste into a terminal, and why reading your result out loud beats memorising.

30
sql-interviews Step 30 of 70

Joins and NULL Semantics

Inner, left, anti and self joins with real result sets, why NOT IN returns zero rows against a NULL, and where the status filter has to go in a LEFT JOIN.

31
sql-interviews Step 31 of 70

GROUP BY and Aggregates

What you may select alongside a group, WHERE versus HAVING, conditional aggregation instead of three queries, and the join fan-out that doubles your SUM.

32
sql-interviews Step 32 of 70

Window Functions

ROW_NUMBER, RANK and DENSE_RANK on the same ties, running totals, LAG and LEAD, and the frame clause that silently changes your answer.

33
sql-interviews Step 33 of 70

Top N Per Group

The most-asked SQL interview pattern solved four ways — window function, correlated subquery, lateral join, and DISTINCT ON — with tie handling.

34
sql-interviews Step 34 of 70

CTEs, Subqueries, and Recursion

Why a named CTE scores better than a nested subquery returning the same rows, when a correlated subquery runs once per row, and recursive CTEs.

35
sql-interviews Step 35 of 70

Dates, Cohorts, and Retention

Date truncation and spines, month-over-month growth, the cohort retention grid, and why BETWEEN on a timestamp column loses the last day of the range.

36
sql-interviews Step 36 of 70

Gaps and Islands

Consecutive-day streaks, session grouping, and merging overlapping intervals — the pattern that looks hardest and reduces to subtracting a row number.

37
sql-interviews Step 37 of 70

Query Plans and Performance

Reading EXPLAIN ANALYZE, the four reasons a query is slow, what an index can and cannot do, and the estimate-versus-actual gap that explains a bad plan.

38
sql-interviews Step 38 of 70

A Full Mock SQL Round

Five questions of escalating difficulty with the wrong first attempt shown each time, the clarifying question that prevents it, and what's scored.

39
cloud-interviews Step 39 of 70

What Cloud Interviews Test That Certifications Do Not

Cert prep drills service trivia; interviews ask you to size, cost, and defend a design. The five things being scored, and a costing script you can run.

40
cloud-interviews Step 40 of 70

VM, Container, or Serverless

The break-even calculation that decides between them, why serverless gets expensive at steady load, and cold starts measured.

41
cloud-interviews Step 41 of 70

Storage Classes and the Egress Bill

Object, block and file storage, when a cheaper storage class costs more, retrieval fees and minimum durations, and CDN arithmetic.

42
cloud-interviews Step 42 of 70

VPCs and the Connectivity Debug Ladder

Subnets, route tables, security groups and NACLs, and the ordered checklist that finds why two things cannot talk on the network.

43
cloud-interviews Step 43 of 70

IAM and Least Privilege

How a policy decision is actually evaluated, why an explicit deny always wins, roles versus long-lived keys, and the wildcard that looks scoped and is not.

44
cloud-interviews Step 44 of 70

Availability, Regions, and the Arithmetic of Nines

What an SLA number actually buys you, RTO versus RPO, why multi-region costs more than twice as much, and the failure modes redundancy does not fix.

45
cloud-interviews Step 45 of 70

Scaling, Queues, and Backpressure

Why autoscaling reacts too late, Little's law applied to a real queue, and the retry storm that turns a blip into an outage.

46
cloud-interviews Step 46 of 70

The FinOps Round: Where the Money Goes

Reading a bill by line item, the commitment ladder priced out, the four wastes behind most overspend, and unit cost as the metric that survives growth.

47
cloud-interviews Step 47 of 70

A Full Architecture Design Round

One question worked end to end — clarify, size, sketch, fail it, cost it, trade off — with the weak version of each step shown alongside the strong one.

48
cloud-interviews Step 48 of 70

The Infrastructure-as-Code Round

Reading a Terraform plan for what it will destroy, state and locking, the drift question, and the review comments an interviewer is waiting to hear.

49
data-interviews Step 49 of 70

The Data Engineering Interview

What the five rounds actually test, and a worked warm-up question answered two ways — the version that gets marked down and the version that gets an offer.

50
data-interviews Step 50 of 70

The SQL Round

The twelve patterns that cover almost every SQL interview question — top-N per group, running totals, and gaps and islands, wrong answer first.

51
data-interviews Step 51 of 70

The Python Round

Data manipulation questions answered in plain Python and in pandas — with the O(n²) answer that passes on ten rows and times out on a million.

52
data-interviews Step 52 of 70

Pipeline Design Questions

The round that separates mid from senior — requirements first, then a design whose failure modes you name before the interviewer does.

53
data-interviews Step 53 of 70

Data Modelling Questions

Grain, keys and star schemas — plus the slowly changing dimension question, worked until the wrong join silently restates last quarter's revenue.

54
data-interviews Step 54 of 70

Spark and Distributed Systems Questions

Shuffles, skew and broadcast joins — why one task runs for 40 minutes while 199 finish in seconds, and the four fixes ranked by what interviewers expect.

55
data-interviews Step 55 of 70

Streaming and CDC Questions

Exactly-once explained without hand-waving, the offset commit order that loses data, and the watermark that silently drops 42% of revenue.

56
data-interviews Step 56 of 70

Data Quality and Incident Questions

The round about the day something went wrong — structuring an incident answer and finding a discrepancy by bisecting the pipeline.

57
data-interviews Step 57 of 70

Data System Design

The 45-minute whiteboard round, sequenced — requirements, back-of-envelope sizing, storage choice, and the tradeoffs you volunteer before being asked.

58
data-interviews Step 58 of 70

The Take-Home Project

What is actually marked — a repo skeleton, the README that does most of the work, and the four hours' effort that beats forty.

59
ai-interviews Step 59 of 70

The AI and ML Interview

Which of the four ML roles you are actually interviewing for, what each loop tests, and a warm-up question answered two ways.

60
ai-interviews Step 60 of 70

ML Fundamentals Questions

Bias-variance, regularisation and the bias-variance-free lunch — each demonstrated with measured curves rather than recited definitions.

61
ai-interviews Step 61 of 70

Feature Engineering and Data Leakage

The four kinds of leakage, each shown as the AUC it inflates — plus the scaling mistake almost everyone makes and the time-series split that hides it.

62
ai-interviews Step 62 of 70

Model Evaluation Questions

Choosing a metric that matches the decision — precision/recall tradeoffs, why ROC AUC misleads on rare events, and calibration.

63
ai-interviews Step 63 of 70

The ML Coding Round

Vectorised numpy, pandas without loops, and the algorithms you're asked to write from scratch — logistic regression, k-means, timed.

64
ai-interviews Step 64 of 70

Classical ML Depth

Trees, bagging and boosting — what each does to bias and variance, and why gradient boosting still beats deep learning on tabular data.

65
ai-interviews Step 65 of 70

Deep Learning Questions

Backpropagation, vanishing gradients, normalisation and optimisers — the mechanisms interviewers ask about, each shown as a measurement in PyTorch.

66
ai-interviews Step 66 of 70

LLM and RAG Questions

Attention costs, chunking, retrieval evaluated with recall@k, and RAG failure modes — measured, so 'it hallucinated' becomes a diagnosis.

67
ai-interviews Step 67 of 70

ML System Design

The 45-minute round where the model is the smallest part — framing the problem, sizing it, and choosing a metric that tracks the business one.

68
ai-interviews Step 68 of 70

MLOps and Production Questions

Drift detected with PSI, reproducibility that actually holds, rollback that works, and the retraining trigger that is not a calendar.

69
interviews Step 69 of 70

Distributed Correctness in Interviews

CAP without the slogan, why exactly-once delivery is impossible but exactly-once processing is not, and idempotency demonstrated rather than asserted.

70
interviews Step 70 of 70

Reading and Negotiating an Offer

Comparing offers that are not comparable — vesting schedules, the four-year illusion, and the arithmetic behind a smaller real number.