The two-week plan

This plan assumes you have seen this material before. You are consolidating, not learning from zero. Every page it sends you to is a page in one of your own four books, so the reading is revision and the writing is recall.

Budget four to six hours on each weekday and eight to ten hours on each of the four weekend days. That is the honest figure for fourteen days of full coverage. If you only have two to three hours a day, do this instead: keep every Practise block and every Say it out loud block, and read only the first linked page of each day. The deep dives are the part to cut, because you can reach them later from the interview grills.

One rule matters more than the schedule. Reading is not preparation. A page you have read feels known, and it stops feeling known the moment somebody asks you about it in a room. So every day ends with your mouth or your keyboard, never with your eyes. You either say the answers out loud, at speaking speed, with nobody prompting you, or you write the code from a blank file with the page closed. If a day runs short of time, drop the reading and keep the recall. The reverse trade fails, because reading builds recognition and interviews test production.

Three of the workbook pages are not tied to a day. The breadth pages — machine learning, NLP and deep learning, and LLMs and modern systems — hold 217 rapid-fire questions, each answered in about a minute of speech. Use them as a daily warm-up: ten questions out loud before you start, taken from whichever page matches the day. A breadth round is its own exam, and it rewards answering in a minute and then stopping.

Every day opens with a Workbook line pointing at the matching page in the two-week workbook. That page holds the equations, the code to write from memory, and the questions with a spoken answer for each, so you can work a day without leaving it. The Read links are for depth when a workbook answer is not enough.

How the fortnight is shaped

Week 1 builds the foundation and then the depth. It starts with classical ML and the loss and metric vocabulary, moves through optimisation and training behaviour, then evaluation and statistics, then probability, and ends on transformers, tokenization, training techniques and inference. That order is deliberate, because the LLM material sits on top of the classical material and an interviewer will push down into it.

Week 2 builds the applied layer. It covers RAG, agents, agent evaluation, ML system design, security and alignment, then coding, then a full mock loop. This is the layer that decides an AI or ML engineer offer, because the questions there are open and the grading is on judgement.

Coding runs through every day rather than sitting in one block at the end. Recall decays. A little typing every day beats one large session, because fourteen small retrievals leave a stronger trace than one long one. Each day therefore has something to type, even the reading-heavy days.

Week 1

Day 1 — Classical ML and the loss vocabulary

Workbook. Linear algebra and Classical ML — the equations, the code to type from memory, and the questions with a spoken answer for each. Work the page before you open anything else.

Read. Start with Classical ML for the map of models and losses. Then read the Logistic regression deep dive, because logistic regression is the model interviewers use to test whether you know where a loss comes from. Then read Bias and variance for the decomposition you will reuse all fortnight. Finish with the Regularization deep dive for L1, L2 and the geometric reason L1 gives sparsity.

Practise. Open a blank file. Write linear regression with gradient descent in NumPy, then logistic regression with the same loop and a sigmoid. No framework, no autograd, and closed pages. Check yourself against linear_regression.py and logistic_regression.py. Then derive the logistic gradient on paper with the derivation page closed.

Say it out loud. Why is squared error the wrong loss for classification? Where does the cross-entropy loss come from, in one line of maximum likelihood? What exactly does high bias look like on a learning curve, and how does it differ from high variance? Why does L1 drive weights to exactly zero while L2 only shrinks them? Your model has train accuracy 0.99 and test accuracy 0.71 — name three fixes and rank them.

Then take five questions from the Logistic regression interview grill and answer them aloud, at speaking speed, before you read the answers.

Done when. You can write logistic regression with a manual gradient from a blank file in under ten minutes, and state the maximum-likelihood origin of its loss without notes.

Day 2 — Optimisation and training behaviour

Workbook. Optimization and training dynamics — the equations, the code to type from memory, and the questions with a spoken answer for each. Work the page before you open anything else.

Read. Start with Gradient descent for the batch, mini-batch and stochastic variants. Then read the Learning rate deep dive, because the learning rate is the hyperparameter interviewers probe first. Then read Optimizers for momentum, RMSProp and Adam, and how they differ in what they store. Then read the Normalization deep dive for batch, layer and RMS normalisation. Finish with the Training behaviors deep dive, which is the page about what goes wrong.

Practise. Write SGD with momentum and then Adam from memory, as plain update rules over a dict of parameters. Compare with optimizers.py. Then write layer normalisation and RMS normalisation as functions, and check against the normalization implementations. Then run the diagnostic drill: take training_optimization.py and, for each failure it shows, write one sentence naming the fix.

Say it out loud. What does the second moment in Adam actually do to the step size? Why does batch normalisation behave differently at training time and at inference time? Why do transformers use layer normalisation instead of batch normalisation? Your loss goes to NaN at step 400 — name your first four checks, in order. Your training loss falls and your validation loss rises from epoch three — what do you change first?

Done when. You can write the Adam update from a blank file, name every term in it, and give an ordered debugging list for a diverging loss without pausing.

Day 3 — Evaluation and statistics

Workbook. Evaluation metrics and A/B testing — the equations, the code to type from memory, and the questions with a spoken answer for each. Work the page before you open anything else.

Read. Start with the Evaluation metrics deep dive for precision, recall, F1, ROC-AUC and PR-AUC, and for when each one lies. Then read the Statistical inference deep dive for hypothesis tests, confidence intervals and p-values. Then read the A/B testing deep dive, because every applied loop asks how you would ship the model and prove it helped. If you have time, read Perplexity in detail, since it returns on Day 6.

Practise. Write precision, recall, F1 and a confusion matrix from a blank file with only NumPy. Then write ROC-AUC by sorting scores, not by calling a library. Check against metrics.py. Then write a two-proportion A/B test: sample size for a given minimum detectable effect, then the test itself. Check against ab_testing.py.

Say it out loud. When does ROC-AUC mislead you, and what do you report instead? Your fraud model has 99.9 percent accuracy — why is that number useless, and what do you ask for? Explain a p-value to a product manager in two sentences, without the word “probability of the hypothesis”. How do you size an A/B test, and what happens to it if you peek at the results daily? What is a novelty effect, and how does it change your test duration?

Done when. You can write ROC-AUC from sorted scores in under fifteen minutes, and defend a launch decision from an A/B result including its confidence interval.

Day 4 — Probability and the scenario problems

Workbook. Probability and statistics and Conditional probability: worked problems — the equations, the code to type from memory, and the questions with a spoken answer for each. Work the page before you open anything else.

Read. Start with the Probability deep dive for the core rules, Bayes, and the standard distributions. Then work through Scenario problems on conditional probability and Scenario problems on expectation. Treat both as problem sets, not as reading. Cover the answer, solve on paper, and only then compare. Then read the MLE and MAP deep dive, because it connects probability back to the losses from Day 1.

Practise. For each scenario problem you got wrong, write the solution again from scratch the same evening. Then write code: a function that simulates each problem and estimates the answer by Monte Carlo, so the simulation and the algebra agree. Compare your setup with probability_qa.py. Then derive the maximum-likelihood estimator for a Gaussian mean and variance on paper, and check with the MLE and MAP derivations.

Say it out loud. State Bayes theorem, then apply it to a medical test with a one percent base rate. What is the difference between a MAP estimate and a maximum-likelihood estimate, and what makes them equal? Why is the maximum-likelihood variance estimator biased, and by how much? Explain expectation and variance of a sum of dependent variables. Pick one scenario problem you failed and explain the trap in it aloud.

Done when. You can solve a fresh conditional-probability scenario on paper in five minutes and confirm it with a twenty-line simulation.

Day 5 — Transformers and attention

Workbook. Transformers and attention — the equations, the code to type from memory, and the questions with a spoken answer for each. Work the page before you open anything else.

This is the highest-value day of the fortnight for an LLM role. Give it your best hours.

Read. Start with the Transformers deep dive for the block structure end to end. Then read the Attention deep dive for the mechanism itself. Then read Causal attention in detail and Attention complexity, which is the cost argument every serving question later depends on. If time allows, read Advanced attention mechanisms for multi-query and grouped-query attention.

Practise. Write scaled dot-product attention from a blank file, in PyTorch, with the causal mask, and no reference open. Then wrap it into multi-head attention with the reshape and the output projection. Then add the feed-forward block, the residual connections and the normalisation, so you have a whole transformer block. Check against attention.py and causal_attention_code.py. Do this twice. The second attempt is the one that sticks.

Say it out loud. Why divide by the square root of the head dimension, and what breaks without it? Draw the shape of every tensor in multi-head attention, from input to output. Why is attention quadratic in sequence length, and which term dominates the memory? What does the causal mask do numerically, and why negative infinity rather than zero? What does grouped-query attention trade away, and what does it buy?

Done when. You can write scaled dot-product attention from a blank file in under ten minutes, and multi-head attention in under twenty, with correct shapes on the first run.

Day 6 — Tokenization, positions and training techniques

Workbook. Tokenization and positional embeddings and LLM training and alignment — the equations, the code to type from memory, and the questions with a spoken answer for each. Work the page before you open anything else.

Weekend. This is a long day, so plan three blocks with breaks.

Read. Start with the Tokenization deep dive for byte-pair encoding and the failure modes it creates. Then read the Positional embeddings deep dive for sinusoidal, learned, ALiBi and RoPE. Then read the Alignment deep dive, followed by the RLHF pipeline explanation and the PPO process. Finish with the LoRA deep dive for parameter-efficient fine-tuning.

Practise. Write byte-pair encoding training and encoding from a blank file, then check with bpe.py. Then implement rotary position embedding as a function that rotates query and key pairs, and check with rope.py. Then write a LoRA linear layer: two low-rank matrices, a scaling factor, and a frozen base weight. Compare with lora.py. Finally read rlhf_dpo.py and write the DPO loss from memory afterwards.

Say it out loud. Why does a tokenizer make arithmetic hard for a language model? What does RoPE give you that a learned positional embedding does not? Name the models in an RLHF run and say what each one is for. Why does DPO remove the need for a separate reward model? How many parameters does LoRA train at rank eight on a 4096-wide layer, and why does that rank work?

Done when. You can write a LoRA layer and the RoPE rotation from blank files, and narrate the full RLHF pipeline in ninety seconds.

Day 7 — LLM inference and serving

Workbook. LLM inference and serving — the equations, the code to type from memory, and the questions with a spoken answer for each. Work the page before you open anything else.

Weekend. Long day again. This day brings in the serving book.

Read. Start with the LLM inference deep dive for prefill, decode and the KV cache. Then read The KV cache in detail and the Paged attention deep dive, because paged attention is the answer to the memory question the KV cache creates. Then move to the serving book: read Basic serving and then vLLM serving for continuous batching in practice. Finish with the Sampling deep dive.

Practise. Write a KV cache from a blank file: a decode loop that appends keys and values each step instead of recomputing them. Check against kv_cache.py, then read the comparison version for the timing argument. Then write temperature, top-k and nucleus sampling as three small functions, and check with sampling.py. Then compute KV cache size by hand for a 7B model at 8k context, batch 32, and write the formula as a Python function.

Say it out loud. Why is prefill compute-bound and decode memory-bound? What does continuous batching change about throughput and about tail latency? What problem does paged attention solve, and what is the analogy to virtual memory? Give the KV cache size formula and its terms. When does quantisation hurt quality, and which parts of the model do you quantise last?

Done when. You can size a KV cache from model dimensions in your head, and explain the prefill and decode split without a diagram.

Week 2

Day 8 — RAG, end to end

Workbook. Retrieval-augmented generation — the equations, the code to type from memory, and the questions with a spoken answer for each. Work the page before you open anything else.

Read. Start with the RAG deep dive for the full pipeline. Then read Retrieval methods and Chunking strategies, which are the two places most real systems fail. Then read RAG failure diagnosis, because interviewers give you a broken system and ask what you check. Finish with RAG latency in production.

Practise. Write a small retrieval pipeline from a blank file: chunk a document, embed the chunks, store them, and retrieve by cosine similarity. Then add BM25 and fuse the two rankings with reciprocal rank fusion. Check against retrieval_implementations.py and chunking_implementations.py. Then write recall at k, mean reciprocal rank and nDCG as functions, and compare with rag_evaluation.py.

Say it out loud. Answers are wrong but the retrieved chunks look right — where is the fault, and how do you prove it? When does hybrid search beat dense retrieval, and when does it not help at all? What does a cross-encoder reranker cost you, and where do you put it in the pipeline? How do you choose a chunk size, and what does overlap actually buy? Your p99 latency is four seconds — name the three stages you would time first.

Done when. You can build a hybrid retriever with reranking from a blank file, and give an ordered diagnosis for a RAG system that returns confident wrong answers.

Day 9 — Agents

Workbook. Agents — the equations, the code to type from memory, and the questions with a spoken answer for each. Work the page before you open anything else.

The production agent book is the spine today.

Read. Start with The whole picture for the shape of an agent system. Then read Agents versus workflows and Core architecture, which give you the vocabulary to answer “when would you not use an agent”. Then read Tool design and Context engineering. Finish with Multi-agent systems.

Practise. Follow Build a ReAct agent, but type it rather than copy it, and then rewrite the loop from memory afterwards. The loop is short: model call, tool parse, tool execute, append result, repeat, with a step limit. Then add two things it will not have: a retry budget and a hard stop. Then read the short version in Agent in thirty minutes and check what you missed.

Say it out loud. When is a fixed workflow better than an agent, and what is the cost of choosing wrong? What makes a tool description good, and what happens when two tools overlap? How do you stop an agent looping forever, and how do you know it looped rather than worked? What does context engineering mean beyond “put more in the prompt”? When does a multi-agent design pay for its coordination cost?

Done when. You can write a working tool-calling loop with a step limit from a blank file in about twenty minutes, and argue both sides of the agent-versus-workflow choice.

Day 10 — Agent and LLM evaluation

Workbook. Evaluating LLM and agent systems — the equations, the code to type from memory, and the questions with a spoken answer for each. Work the page before you open anything else.

Read. Start with the Evaluation frameworks deep dive for how to structure an eval at all. Then read the Metrics and benchmarks deep dive and the Tool use evaluation deep dive, because tool-use correctness is what separates agent evals from model evals. Then read the Automated evaluation deep dive for LLM-as-judge and its biases. Finish with the LLM evaluation deep dive from your own ML book, which ties this back to the metrics of Day 3.

Practise. Follow Build an eval harness and type it. Then, from a blank file, write a small judge harness of your own: a dataset of cases, a runner, a rubric prompt, a scorer, and an aggregate report with a confidence interval on the pass rate. The confidence interval matters, because a fifty-case eval cannot detect a two-point change. Then write pairwise comparison with position swapping, so you can show you know about position bias.

Say it out loud. How do you evaluate an agent whose trajectory is correct but whose final answer is wrong? Name three biases of an LLM judge and one mitigation for each. How many cases do you need to detect a five-point regression, and how did you get that number? What is your offline-to-online gap, and how do you close it? What do you monitor in production that an offline eval cannot catch?

Done when. You can specify an eval suite for a given agent in ten minutes, with per-case rubric, sample size and the metric you would gate a release on.

Day 11 — ML system design

Workbook. ML system design and ML system design case studies — the equations, the code to type from memory, and the questions with a spoken answer for each. Work the page before you open anything else.

Read. Start with the ML system design deep dive for the framework: requirements, data, features, model, serving, evaluation, monitoring. Then read the Large-scale LLM systems deep dive for the version of that framework that involves GPUs. Then work through two or three cases from Agent system design practice, for example the support copilot. Finish with the Business case studies deep dive for the metric-and-tradeoff framing.

Practise. Design three systems on paper, forty minutes each, with a timer, out loud, standing at a whiteboard or a large sheet. Pick a recommendation feed, a fraud detector and a document assistant. For each one write the requirements, the data flow, the model choice, the serving path with numbers, and the monitoring. Then type the core of one of them: for the recommender, write a two-tower scoring function and top-k retrieval, using recommendation.py as the check.

Say it out loud. What are your first five clarifying questions for any design prompt? How do you serve a model under a 50 millisecond p99 budget, and what do you cut first? Where do training and serving skew come from, and how do you detect it? How do you handle the cold start for a new user and for a new item? What do you log on day one so that you can debug this in month three?

Done when. You can run a forty-minute design out loud, unprompted, and produce latency and cost numbers rather than only boxes and arrows.

Day 12 — Security, alignment and frontier topics

Workbook. LLM security and safety — the equations, the code to type from memory, and the questions with a spoken answer for each. Work the page before you open anything else.

Read. Start with the LLM security deep dive for prompt injection, data exfiltration and the tool-permission problem. Then read Security from the agent book for the production controls. Then read the Reasoning models deep dive and the RLVR deep dive, which are the current-events part of a research interview. Finish with the Scaling laws deep dive, because compute-optimal reasoning comes up in almost every research screen.

Practise. Write a guardrail layer from a blank file: an input classifier, an allowlist of tool calls, an output filter, and a log line for each decision. Then write the attack side, because you cannot defend what you cannot construct: five prompt-injection payloads aimed at a document-reading agent, and the specific control that stops each one. Then compute a compute-optimal token budget for a given parameter count and write it as a small function.

Say it out loud. Why can prompt injection not be fully solved by better prompting? An agent reads untrusted web pages and can send email — how do you make that safe? What does a verifiable reward give you that a learned reward model does not? Why does test-time compute buy accuracy, and where does the curve flatten? Given a fixed compute budget, do you train a larger model or use more tokens, and why?

Done when. You can state a threat model for a tool-using agent and name a specific control for each threat, without falling back on “we would add guardrails”.

Day 13 — ML coding and LeetCode patterns

Workbook. The ML coding round and The algorithms round for the map, then the six pattern chapters for the depth: sliding window, arrays and hash tables, two pointers, binary search, trees, and graphs. Then the eight that complete the set: stack, heap, linked lists, backtracking and tries, dynamic programming I and II, intervals and greedy, and matrices, maths and bit tricks.

That is 291 problems across fourteen chapters, which covers the Blind 75 and the NeetCode 150 in full. It is far more than one day holds, so treat it as a standing rotation: one chapter a day from here to the interview, writing every block from a blank file. If a chapter feels slow, do its recognition table and its templates and move on, because recognising the pattern is worth more than finishing the problem set. If you have only one day, do the two dynamic-programming chapters and the stack chapter, because those are the three where not knowing the shape costs you the whole question.

Weekend. This is a keyboard day. Read little, type all day.

Read. Skim the Coding patterns deep dive for the recurring ML coding shapes. Then skim the LeetCode patterns deep dive for the pattern list, not for the solutions. Then read Memory skeletons, which is the page that makes recall reliable under pressure. Do not spend more than ninety minutes reading today.

Practise. Morning, ML coding: from blank files, write k-means, k-nearest neighbours, a small neural network with manual backpropagation, and a training loop with batching and early stopping. Check against interview_patterns.py, kmeans.py and neural_network.py.

Afternoon, algorithms: two problems from each of arrays, hashing and sliding window, two pointers and stack, binary search and linked list, trees and graphs. Set a 25-minute timer per problem and stop when it rings.

Evening: pick five drills from Blind coding drills and do them with the pages closed.

Say it out loud. Narrate your k-means implementation while you type it. State the complexity of every function you wrote today, before you run it. Which pattern applies here, and how did you recognise it in the first thirty seconds?

Done when. You wrote twelve or more programs today, and every one of them ran, and you never opened a solution before your timer rang.

Day 14 — The mock loop and the compression pass

Workbook. The algorithms round — the equations, the code to type from memory, and the questions with a spoken answer for each. Work the page before you open anything else.

Weekend. Morning is a full loop. Afternoon is compression. Then you stop.

Read. Nothing new today. Read The loops first, so you know the shape of the day you are simulating. Then use Mock loops and the Scorecard to run and grade yourself.

Practise. Run five rounds back to back, with a timer, out loud, in one sitting. Use the ML depth bank, the coding bank, the system design bank, the statistics bank and the behavioural bank, one round each. Score every round on the scorecard before you move on. Then take your three lowest scores and drill only those, from the spoken question bank and the depth and breadth questions in this folder. Finish the day in Night before review, with the Formula sheet, Code from memory and the AI engineer one-pager. Also sweep Asked in the wild and the main Interview Q&A bank for anything that still feels unfamiliar.

Say it out loud. Give your two-minute introduction, twice, until it is smooth. Explain your strongest project, then answer “why did you choose that” three levels down. Answer one question from each of the five banks with the page closed.

Done when. You scored every round on the scorecard, and the lowest score is one you have since drilled and can now answer aloud without notes.

If you have less than two weeks

Cut in this order. First, drop the deep dives and keep only the interview grills and the code files, because the grills contain the same content in question form and question form is what you need. Second, merge Day 6 into Day 5 and keep only tokenization and RoPE from it. Third, merge Day 12 into Day 10, and keep only prompt injection and tool permissions. Fourth, cut Day 4 to the two scenario problem sets and skip the theory.

Never cut three things. Never cut Day 5, because attention is asked in every LLM interview and it is asked at the keyboard. Never cut Day 13, because coding is the round that fails people who know the theory. Never cut Day 14, because an untested loop is an untested loop and the first real interview should not be your first full run.

With one week, run Days 1, 2, 5, 8, 9, 13 and 14. With three days, run Days 5, 13 and 14 only.

The last 24 hours

Stop learning new material. Nothing you read now will be available under pressure tomorrow, and reading new pages will cost you sleep and confidence. Work only from this folder. Read the Formula sheet once, slowly, and say each formula aloud rather than reading it silently. Then work through Code from memory at the keyboard, not on the page. Then read the AI engineer one-pager as your final sweep. Use the Depth and breadth questions only to find gaps you can close in one sentence each, not to open new topics. The Night before review index lists the order. Then close everything and sleep.

Tracking