Working log · 22 weeks · 2 phases

AI Engineering Weekly Log

Twelve weeks from backend engineer to agentic AI engineer, then ten weeks of React to build the front end for what you shipped. Every week has a checklist, one named project, a gate that decides whether the week counts, and somewhere to write down what actually happened.

The Syllabus tells you what to know and the Ledgers drill you on it. This page is the plan you execute. Ticks, dates, hours and notes are saved in this browser.

22Weeks
22Projects
264Tick-boxes

The best way to work through this

The failure mode for a roadmap like this is not running out of time. It is finishing twelve weeks of videos with nothing you can show anybody. So the unit of progress here is not a topic, it is a week that closed — and a week only closes when its build runs, you have answered the checkpoint out loud, and you have written the note.

Roughly a quarter of your time is learning and three quarters is building. If a week produced only notes, it did not happen; carry the build forward and cut the reading, never the other way round.

The weeks are ordered as dependencies, not preferences. Week 6 assumes you built the loop by hand in Week 5. Week 10 assumes there is something worth evaluating. Skipping forward is the one change that reliably breaks the plan.

MonLearn. Read and watch, take rough notes, write nothing polished.
TueExperiment. Smallest possible script that proves you understood Monday.
Wed–ThuBuild. The named project, in the open, badly at first.
FriBreak it. Failure modes, edge cases, the design you now regret.
SatHarden. Tests, README, diagram, numbers.
SunClose. Checkpoint out loud, write the note, set next week current.

At twelve to eighteen hours a week that shape fits. At eight, run each of these weeks over two calendar weeks rather than dropping the build — twenty-two half-speed weeks beats eleven abandoned ones.

Every week has a Files panel next to its title. Put the repository or Colab link in first — that is the thing that travels and the thing an interviewer opens. Then attach the notebook itself, or drop the whole project folder in, and the week keeps its own evidence. Attachments are held in this browser and a folder comes back out as a single .zip; the link is the durable copy.

Six rules

  • Ship, don't studyEvery week leaves behind working code, a diagram, an evaluation result or a production decision. Notes alone do not count as a closed week.
  • Architecture firstBuild the agent loop by hand before LangGraph. Call the API directly before a framework. You cannot debug what you never assembled.
  • Measure before claiming“It works on my examples” is not a result. From Week 4 onward every claim about quality needs a number behind it.
  • Three-line notesWhat clicked, what broke, what to revisit. Written the day it happened. An essay on Sunday is a worse record than three lines on Wednesday.
  • Timebox the stuckNinety minutes stuck: write the question down, give it one more hour, then move on and log it. Come back when the next week has taught you the missing piece.
  • Depth over coverageOne system you can defend end to end beats six tutorials. When time runs short, deepen the capstone rather than adding a project.

What goes wrong

  • The tutorial loop. Finishing courses feels like progress and produces nothing an interviewer can look at. Courses are for unblocking a build, not for completing.
  • Framework first. LangGraph before you can write the loop gives you a system you can run and cannot fix.
  • “Looks good” evaluation. No dataset, no number, no idea whether last week's prompt change helped or hurt.
  • Demo-grade repositories. No README, no failure modes, no cost figures. The work existed; the evidence does not.
  • Multi-agent for its own sake. Three agents where one would do, defended by nothing but the fact that it was harder to build.
Phase 1

AI Engineering

Weeks 1–12

The goal is not to become a traditional ML engineer. It is to become a software engineer who can design, build, evaluate and operate production AI and agentic systems — with your existing Java, Spring and system-design experience kept, not replaced. Each week names one project; the projects compound, and by Week 12 they are one system.

01

ML Foundations

0/12

Learn the minimum ML vocabulary needed to read modern AI systems work. You are not becoming an ML researcher; you are becoming fluent enough that nobody can bluff you.

Learn

  • AI vs ML vs deep learning; supervised vs unsupervised; what “learning” actually means
  • Features, labels, and the train / validation / test split — why the test set is touched once
  • Regression vs classification, and the metrics that go with each (RMSE and MAE vs precision, recall, F1)
  • Overfitting, underfitting and the bias–variance trade-off
  • Cross-validation, and why evaluation data must never leak into training
  • Baselines: why “predict the mean” or “predict the majority class” is the number to beat

Build — ML Prediction Notebook

Start hereuv init ml-notebook && uv add pandas scikit-learn matplotlib jupyter, then open one notebook: 01_model.ipynb. Use one dataset for the whole week.

  • Pick one small tabular dataset; write down what a single row means before you model anything
  • Establish a dumb baseline and record its score — this is your floor
  • Preprocess: missing values, categorical encoding, scaling where the model needs it
  • Train two models and compare them on held-out data, never on training data
  • Error analysis: pull the twenty worst predictions and write a paragraph on why they fail
Ship gate — the week is not done until this is true

The notebook runs top to bottom on a fresh kernel, and the README states the baseline, the final metric, and one sentence on what the model still gets wrong.

Interview checkpoint — answer it out loud, from memory

Explain training vs testing, overfitting, and how you would know your model is any good — without writing a single formula.

The trap this week is completeness. Do not implement every classical algorithm. Stop the moment the end-to-end lifecycle is clear and move on.

ReferencesCampusX — 100 Days of Machine LearningDeepLearning.AI — ML Specializationscikit-learn — model evaluation

02

Deep Learning and Transformers

0/12

Build working intuition for the machinery under an LLM, so that “context window”, “embedding” and “attention” stop being magic words you repeat.

Learn

  • Neurons, weights, loss, gradient descent and backpropagation — the loop, not the calculus
  • Tokenisation: why text becomes subword units, and what that costs you in practice
  • Embeddings as geometry: similarity, distance, and what “semantic” actually means here
  • Attention and self-attention: query, key, value — and why it displaced recurrence
  • The transformer block: multi-head attention, feed-forward, residual connections, layer norm
  • Encoder vs decoder vs encoder–decoder; autoregressive generation, temperature and top-p

Build — Embedding Explorer

Start hereuv add sentence-transformers tiktoken scikit-learn umap-learn matplotlib. Keep a texts.txt corpus of 100–200 lines you wrote or collected.

  • Tokenise a paragraph and print the tokens; find a string that tokenises far worse than it looks
  • Embed a corpus of 100–200 short texts with an off-the-shelf model
  • Compute cosine similarity and retrieve nearest neighbours for ten queries
  • Find and record one case where “similar vectors” are not “similar meanings”
  • Project to 2-D, plot it, and write down what the clusters actually are
Ship gate — the week is not done until this is true

You can point at any retrieved neighbour and explain, in embedding terms, why it came back.

Interview checkpoint — answer it out loud, from memory

What does self-attention compute, and why do transformers handle long-range dependencies better than RNNs?

This is the one week where theory earns its keep. Level 9 of the Syllabus (Inside the Model) is the long-form version of exactly this material — use it if a concept will not land.

ReferencesHugging Face — LLM CourseAttention Is All You Need (2017)The Illustrated TransformerKarpathy — Let's build GPT

03

LLM Engineering

0/12

Treat the LLM as what it is: an unreliable remote service sitting inside an otherwise normal software system.

Learn

  • Prompt structure: system vs user vs assistant, few-shot, and what actually moves the output
  • Structured outputs and JSON schemas; validating model output like any untrusted input
  • Function and tool calling: the contract, the schema, and the error path
  • Streaming, latency budgets, token accounting and cost per request
  • Model selection: when a small model is enough, and when it is not
  • Temperature, determinism, and why “it worked yesterday” is not a defence

Build — Expense Analyzer API

Start hereuv add fastapi uvicorn pydantic anthropic (or your provider's SDK). Put the API key in .env; never in code.

  • Endpoint takes free-form expense text and returns a validated object: amount, currency, category, date
  • Enforce the schema at the boundary — reject and retry on a schema violation, never pass it through
  • Handle refusal, truncation, malformed JSON, timeout and rate limit as distinct cases
  • Log tokens in and out plus cost per request; print a running daily total
  • Write twenty adversarial inputs (ambiguous, multi-currency, no amount) and record the behaviour of each
Ship gate — the week is not done until this is true

The API never returns an unvalidated model response, and every failure mode above has a test that proves it.

Interview checkpoint — answer it out loud, from memory

What is tool calling, and why should LLM output be validated exactly like an external API response?

Keep this version framework-light. You are learning the raw mechanics; a framework here would hide the exact failures you need to see.

ReferencesOpenAI — API documentationOpenAI Agents SDK — quickstartAnthropic — tool use

04

RAG

0/12

Build a retrieval pipeline and learn the lesson that decides most RAG projects: retrieval quality, not model quality, caps answer quality.

Learn

  • Document parsing — PDFs, HTML, and the information lost at this very first step
  • Chunking strategies, overlap, and how chunk boundaries silently destroy answers
  • Metadata and filtering; hybrid search combining dense vectors with BM25
  • Top-k and reranking, and the recall against precision trade you are making
  • Grounding and citation: making the answer point at the passage it came from
  • Retrieval failure vs generation failure — and how to tell which one you have

Build — Personal Knowledge RAG

Start herePick a vector store (Chroma locally, or pgvector). Put 20–50 of your own notes and PDFs in data/. Chunk, embed, store, then query.

  • Ingest your own notes and PDFs; store every chunk with its source metadata
  • Answer with inline citations that resolve to the exact passage
  • Add a floor: when top-k similarity falls below a threshold, answer “not in the corpus”
  • Write twenty test questions with a known answer and a known source document
  • Measure retrieval hit-rate as a separate number from answer quality
Ship gate — the week is not done until this is true

You can state your retrieval hit-rate as a number, and the system refuses to answer when retrieval is weak instead of inventing something.

Interview checkpoint — answer it out loud, from memory

Why does RAG fail even when the LLM is strong? Separate retrieval failure from generation failure in your answer.

The twenty test questions are not optional busywork. Without them you cannot tell a chunking change from a prompt change, and every later week depends on that skill.

ReferencesDeepLearning.AI — short coursesLlamaIndex — documentationLangChain — retrieval

05

Agents Without Frameworks

0/12

Understand the agent loop completely before any framework gets to hide it from you.

Learn

  • The loop: model proposes → tool executes → result returns → model continues
  • Tool selection, and how much of it is really driven by the tool description you wrote
  • State: what carries between turns and what gets re-derived each time
  • Termination: step budgets, success conditions, and the infinite-loop failure
  • Retries, timeouts and partial failure inside a tool call
  • Workflow vs agent — when the flow is known, do not let a model decide it

Build — Tool-Using Assistant

Start herePlain Python and the provider SDK only. One file, agent.py, with run(task) looping over model → tool → model.

  • Implement the loop by hand; no agent framework this week
  • Three tools: calculator, search (real or mocked) and document lookup
  • An explicit step budget and an explicit termination condition
  • Retry with backoff on tool error, and surface the error back to the model as a result
  • Log every step: tool chosen, arguments, result, and the reasoning that led there
Ship gate — the week is not done until this is true

You can read the step log of any run and explain every decision the agent made, without guessing.

Interview checkpoint — answer it out loud, from memory

Walk through one complete agent loop end to end — tool selection, result handling, termination.

This is the highest-leverage week in the phase. Engineers who skip it can use LangGraph but cannot debug it.

ReferencesOpenAI Agents SDK — agentsOpenAI Agents SDK — running agentsAnthropic — building effective agents

06

LangGraph and Stateful Orchestration

0/12

Move from a hand-rolled loop to state that is explicit, inspectable and resumable.

Learn

  • State schema; nodes and edges as a graph rather than a script
  • Conditional routing — and why it is testable in a way a prompt never is
  • Tool nodes and how they differ from a plain function call
  • Persistence and checkpoints
  • Interrupts and human-in-the-loop
  • Replay and time-travel debugging of a previous run

Build — Stateful Research Agent

Start hereuv add langgraph langgraph-checkpoint-sqlite. Define the state as a TypedDict first, then the nodes, then the edges.

  • Graph: plan → retrieve → analyse → verify → answer
  • Persist state to a checkpoint store, not to memory
  • Add an interrupt before the final answer for human approval
  • Kill the process mid-run, restart it, and resume from the checkpoint
  • Add a verify node that can route back to retrieve when evidence is thin
Ship gate — the week is not done until this is true

You can stop the agent halfway, restart the process, and resume without losing any work.

Interview checkpoint — answer it out loud, from memory

When is a graph or workflow preferable to an autonomous agent? Explain state and conditional routing.

Port the Week 5 agent rather than starting fresh. The diff between your loop and the graph is the actual lesson.

ReferencesLangGraph — overviewLangGraph — workflows and agentsLangGraph — persistence

07

MCP

0/12

Learn the standard boundary between an agent and the systems it is allowed to touch.

Learn

  • MCP client vs server, and what responsibility lives on each side
  • Tools, resources and prompts — three different primitives, not three names for one
  • Discovery and invocation
  • Transports: stdio and HTTP, and when each fits
  • Permissions and authorisation at the boundary — where the check actually belongs
  • Why a protocol beats bespoke glue written once per integration

Build — Personal MCP Server

Start hereUse the official MCP Python SDK (uv add mcp). Start with the stdio transport and test with the MCP Inspector before connecting an agent.

  • Expose four tools: search_docs, get_document, create_task, update_task
  • Enforce permission checks server-side, never in the prompt
  • Connect the server to your Week 5 or Week 6 agent
  • Add one resource and one prompt, not only tools
  • Write down what breaks if a server returns a malicious tool description
Ship gate — the week is not done until this is true

The server refuses an unauthorised call even when the agent asks for it politely and repeatedly.

Interview checkpoint — answer it out loud, from memory

What problem does MCP solve, and where should authorisation happen?

The last build item is the interview answer. Prompt-injection through tool metadata is the question that separates people who have read about MCP from people who have run it.

ReferencesModel Context Protocol — docsMCP — specificationMCP — Python SDK

08

Multi-Agent Systems

0/12

Use more than one agent only where specialisation or delegation genuinely pays for the cost and latency it adds.

Learn

  • Supervisor and manager patterns
  • Agent-as-tool vs handoff — the difference in control flow and in what context travels
  • Planner → executor → reviewer
  • Shared state, and the context that must move with a handoff
  • How cost and latency multiply with every additional agent
  • When not to use multi-agent — which, honestly, is most of the time

Build — Software Engineering Agent

Start hereReuse the Week 5 or 6 agent code. Pick 10 small coding tasks (for example 'add a function with tests') that you can check automatically with pytest.

  • Requirement in → planner → implementer → reviewer
  • The reviewer can reject work and send it back, under a hard revision limit
  • One shared state object; a step and token budget for the whole run, not per agent
  • Run the same ten tasks through a single-agent baseline
  • Record cost and latency for both and put them side by side
Ship gate — the week is not done until this is true

You have a number showing whether multi-agent actually beat the single agent — and you believe the number.

Interview checkpoint — answer it out loud, from memory

Compare supervisor and agents-as-tools with handoffs. When would you use each?

If the baseline wins, that is a result, not a failed week. Say so in the README — it is a better interview story than a system you cannot justify.

ReferencesOpenAI Agents SDK — multi-agentLangGraph — multi-agentAnthropic — multi-agent research system

09

Agent Harness and Reliability

0/12

Build the engineering layer that makes an agent safe to leave running unattended.

Learn

  • Permissions and tool policies — allow-lists, not deny-lists
  • Retries, timeouts, circuit breaking and termination conditions
  • Context management: compaction, summarisation, and deciding what to drop
  • Memory: session vs durable, and what should never be remembered at all
  • Guardrails on input and on output
  • Human approval gates on irreversible actions; idempotency of every tool

Build — Production Agent Harness

Start hereWrap the Week 6 graph in a Harness class. Every tool call goes through one execute_tool() function, where the policies live.

  • Wrap the Week 6 agent with a permission gate, retry policy, timeout and step budget
  • Persist state; make each tool idempotent or explicitly mark it not-retryable
  • Require human approval before any write or side-effecting tool call
  • Structured logs with one trace id per run, threaded through every step
  • Document every failure mode you handle — and every one you knowingly do not
Ship gate — the week is not done until this is true

A written failure-mode table exists, and the agent cannot spend unbounded money or take an irreversible action while unattended.

Interview checkpoint — answer it out loud, from memory

How do you stop an agent looping, exceeding its budget, or calling a dangerous tool?

The failure-mode table is the deliverable people remember. It is the clearest signal that you have operated a system rather than demoed one.

ReferencesOpenAI Agents SDK — guardrailsLangGraph — human-in-the-loopOWASP — Top 10 for LLM applications

10

Evaluation and Observability

0/12

Replace “looks good to me” with a number you would be willing to defend in a review.

Learn

  • Building an eval set: where the cases come from and how many you actually need
  • Deterministic graders vs LLM-as-judge — and the judge's own biases
  • Correctness, groundedness, tool-selection accuracy and trajectory evaluation
  • Regression testing: the suite that must pass before a prompt change ships
  • Traces and spans — what is worth recording on every run
  • Latency, token usage and cost as first-class metrics, not afterthoughts

Build — Agent Evaluation Suite

Start hereCreate an evals/ folder: cases.jsonl, graders.py, run_eval.py. Output a CSV per run, named model_prompt_date.csv.

  • One hundred cases: input, expected answer, expected tools, expected sources
  • Deterministic graders wherever possible; use a judge only where nothing else works
  • Run two versions (prompt or model) and produce a comparison table
  • Track latency and cost per case alongside quality
  • Wire tracing so that clicking a failed case opens its full trace
Ship gate — the week is not done until this is true

A table comparing two versions on quality, tool choice, latency and cost — and a decision you actually made from it.

Interview checkpoint — answer it out loud, from memory

How would you know whether a new prompt or a new model genuinely improved your agent?

Build the eval set from real failures you hit in Weeks 4 to 9, not from invented questions. Cases you have already been burned by are worth ten you imagined.

ReferencesLangSmith — evaluationLangSmith — observabilityAnthropic — evaluating model outputs

11

Production AI Engineering

0/12

Turn a prototype into a service that somebody other than you could operate.

Learn

  • FastAPI, async request handling and streaming responses
  • Docker, configuration and secret handling
  • PostgreSQL with pgvector; Redis for cache and rate limits
  • Background workers and queues for long-running agent executions
  • Auth, rate limiting and per-tenant cost caps
  • Logging, metrics, alerting and CI/CD

Build — Deployable Agent Platform

Start hereCreate docker-compose.yml with api, worker, postgres (with pgvector) and redis. Get docker compose up working before adding features.

  • API plus worker and queue, so a long run never holds an HTTP connection open
  • Postgres for state, pgvector for retrieval, Redis for cache and limits
  • Auth, a per-key rate limit, and a hard spend cap that actually stops work
  • Structured logs, basic metrics and one dashboard worth looking at
  • Dockerised, one-command local bring-up, deployed somewhere real
Ship gate — the week is not done until this is true

Someone else can clone it, run one command and get a working system — and you can answer “what does this cost per thousand requests?”

Interview checkpoint — answer it out loud, from memory

How would you scale an agent API while controlling LLM cost, concurrency, retries and state?

Your existing backend and system-design experience is the advantage here. This week should feel like familiar work with one unfamiliar, expensive, non-deterministic dependency in the middle.

ReferencesFastAPI — documentationDocker — get startedpgvector

12

Capstone — OurAtlas AI Travel Agent

0/12

One portfolio-grade system that demonstrates AI engineering rather than another chatbot demo.

Learn

  • Requirement understanding and constraint extraction from free text
  • RAG over domain knowledge
  • External tools reached through MCP
  • Planning, verification, and revision when a requirement changes mid-conversation
  • Approval before sensitive or expensive actions
  • Evaluation, traces, cost and failure handling, end to end

Build — OurAtlas AI Travel Agent

Start hereReuse the pieces: Week 4 RAG + Week 6 graph + Week 9 harness + Week 11 platform. Write the target itinerary format (JSON schema) first.

  • Handle: “Plan five days in Auli in February with one skiing day and a controlled budget”
  • Retrieve, call tools, verify constraints, and produce a cited itinerary
  • Persist trip state and revise correctly when the user changes a requirement
  • Require approval before any booking-like action
  • Ship it: README, architecture diagram, eval results, cost per run, known limitations
Ship gate — the week is not done until this is true

A stranger can run it, and the README answers “what would you change at ten times the scale?”

Interview checkpoint — answer it out loud, from memory

Draw your complete production architecture and explain every component and its failure mode.

Stop adding courses. This week integrates what you already have; anything new you learn here should be forced on you by the build, not chosen from a syllabus.

ReferencesOpenAI Agents SDKModel Context ProtocolAnthropic cookbook

Phase 2

React and the AI Front End

Weeks 13–22

An agent nobody can click on is hard to interview with. This phase takes you from language fundamentals to a streaming, tool-aware chat interface wired to the agent you built in Phase 1. If you already write React professionally, run Weeks 13–16 as a single revision week and go straight to server state, testing and performance.

13

JavaScript and TypeScript Foundations

0/12

Get the language out of the way, so that when React starts, React is the only new thing.

Learn

  • ES modules; objects and arrays; map, filter, reduce; destructuring and spread
  • Closures — which quietly explain most of the React bugs you will hit later
  • Promises, async/await, fetch and AbortController
  • Error handling at the network boundary, including non-2xx responses
  • TypeScript: types, interfaces, unions and narrowing
  • Generics, and typing an API client so callers cannot misuse it

Build — Typed API Dashboard

Start herenpm create vite@latest dashboard -- --template vanilla-ts, and set "strict": true in tsconfig. Pick a free API (for example JSONPlaceholder or REST Countries).

  • Consume a REST API with fully typed response models
  • Render loading, error and empty states explicitly — all three, every time
  • Client-side filtering and sorting over the fetched data
  • Abort the in-flight request when the query changes
  • No any anywhere, with strict turned on
Ship gate — the week is not done until this is true

tsc --noEmit passes under strict mode, and every network state is visible in the UI rather than assumed.

Interview checkpoint — answer it out loud, from memory

What does await actually do to control flow, and how do unions plus narrowing make invalid states unrepresentable?

If you already write TypeScript daily, compress this to two days and spend the rest on Week 2. Do not skip AbortController — Week 4 depends on it.

ReferencesMDN — JavaScript GuideTypeScript HandbookTypeScript & React Ground Up

14

React Fundamentals

0/12

Learn what React is actually doing when you change state, before you learn anything clever.

Learn

  • Components, JSX and the compile step underneath it
  • Props and children; composition instead of configuration
  • Conditional rendering and the patterns that read badly at scale
  • Lists and keys — and precisely why an index key corrupts state
  • Events, synthetic events and handler identity
  • State, controlled inputs, and the single source of truth

Build — Expense Tracker UI

Start herenpm create vite@latest expenses -- --template react-ts. Sketch the components on paper first: App → ExpenseForm, Filters, Summary, ExpenseList → ExpenseRow.

  • A componentised expense tracker with a validated add-expense form
  • Totals and per-category breakdown derived from state, never stored separately
  • Filters by category and date range
  • Persist to localStorage and restore on load, guarded against a throwing read
  • A real empty state and a real error state, not a blank screen
Ship gate — the week is not done until this is true

No component runs past roughly a hundred lines, and every list key is a stable id rather than an array index.

Interview checkpoint — answer it out loud, from memory

What triggers a re-render, and why does a wrong key corrupt list state?

Type the whole thing out rather than scaffolding from a template. The muscle memory for JSX and handlers is worth two days by itself.

ReferencesReact — Describing the UIReact — Adding InteractivityReact — rendering lists

15

State and Component Architecture

0/12

Decide where state lives. Most React codebases are difficult for exactly one reason: they got this wrong.

Learn

  • State ownership and lifting state to the nearest common parent
  • Derived state — never store what you can compute
  • useState vs useReducer, and the point at which the switch pays off
  • useContext and its real re-render cost
  • Custom hooks: extracting behaviour rather than markup
  • Purity, and why a component must not lie about its inputs

Build — Kanban Board

Start hereNew Vite React TS app. Write the reducer and its action types first, and test the reducer as a pure function before building any UI.

  • A task board with columns, driven by a single reducer
  • Move tasks between columns; support undo through the reducer
  • Extract at least two custom hooks with names that describe behaviour
  • Use Context only where prop drilling is genuinely painful, and say why in a comment
  • Persist and rehydrate board state without breaking on a schema change
Ship gate — the week is not done until this is true

No piece of state is derivable from another, and one reducer owns every board mutation.

Interview checkpoint — answer it out loud, from memory

When do you reach for useReducer over useState, and why is Context not a state manager?

The undo requirement is deliberate. It is nearly free with a reducer and miserable without one, which is the whole argument in a single feature.

ReferencesReact — Managing StateReact — Scaling Up with Reducer and ContextReact — Hooks reference

16

Effects and Escape Hatches

0/12

Learn what useEffect is for — and, more usefully, the many things it is not for.

Learn

  • What an effect actually is: synchronising with something outside React
  • The dependency array, and why lying to it is the root of most effect bugs
  • Cleanup functions and subscriptions
  • Refs for values that must not trigger a render
  • useMemo and useCallback — when they help and when they are pure noise
  • You Might Not Need an Effect: the cases that should be event handlers or derived state

Build — Live Search

Start hereOne LiveSearch component and one useSearch(query) hook. Use a slow API or add an artificial delay so the race condition is visible.

  • A search box that debounces input before hitting the API
  • Cancel the previous request when a new one starts
  • Protect against stale results — an older response must never overwrite a newer one
  • Keyboard navigation through results, with correct focus handling
  • Loading indication that does not cause layout shift
Ship gate — the week is not done until this is true

Typing quickly never displays results belonging to an older query, and you can demonstrate the race deliberately.

Interview checkpoint — answer it out loud, from memory

Name three things people commonly do inside an effect that should not be in one at all.

The stale-result race is the single most common bug in production React search UIs. Reproduce it on purpose before you fix it.

ReferencesReact — Escape HatchesReact — You Might Not Need an EffectReact — useEffect reference

17

Routing

0/12

Treat the URL as state. It is the only state your users can bookmark, share or send to support.

Learn

  • React Router: route definitions, nested routes and layout routes
  • Path params and loading data from them
  • Query params as application state
  • A real 404 route, and error elements per route
  • Protected routes and redirect-after-login
  • Loaders and actions, and what they move out of components

Build — Travel Planner

Start herenpm i react-router-dom. Write the route tree first with createBrowserRouter, using placeholder pages, then fill in each page.

  • Routes for home, destination, trip, itinerary and profile
  • Nested layout with a persistent shell and per-route content
  • Filters and search stored in the query string so a URL reproduces the view
  • Profile behind a protected route that redirects back after login
  • A 404 page and a route-level error boundary that are actually reachable
Ship gate — the week is not done until this is true

Pasting a filtered URL into a fresh tab reproduces the exact same view, with no hidden component state required.

Interview checkpoint — answer it out loud, from memory

What belongs in the URL and what belongs in component state?

The shareable-URL gate is what interviewers probe. Anyone can add a route; far fewer put filter state where it belongs.

ReferencesReact Router — documentationReact Router — routing conceptsMDN — URLSearchParams

18

Server State with TanStack Query

0/12

Stop writing fetch-in-effect. Server state is a cache problem, and it has a right answer.

Learn

  • Server state vs client state — why conflating them causes most data bugs
  • Query keys, and what a key actually keys
  • The cache, stale time, garbage collection time and refetch behaviour
  • Mutations and cache invalidation
  • Optimistic updates, and the rollback path when the server disagrees
  • Pagination, infinite queries and prefetching

Build — CRUD Trip App

Start herenpm i @tanstack/react-query plus a fake backend (json-server or MSW). Add React Query Devtools from day one.

  • Full CRUD against a REST backend
  • Invalidate precisely on mutation — not a blanket cache clear
  • An optimistic status update that rolls back visibly on failure
  • A paginated list that keeps previous data while the next page loads
  • Prefetch a detail view on hover over its list row
Ship gate — the week is not done until this is true

An optimistic update that fails rolls the UI back and tells the user, rather than silently diverging from the server.

Interview checkpoint — answer it out loud, from memory

Why is server state different from client state, and what does a query key actually key?

Delete a fetch-in-useEffect you wrote in Week 4 and replace it with a query. The diff is the argument for the library.

ReferencesTanStack Query — React docsTanStack Query — optimistic updatesTanStack Query — examples

19

Forms and Auth

0/12

Forms are where validation, error handling and authorisation all meet the user at once.

Learn

  • Form architecture; controlled vs uncontrolled and the cost of each
  • Schema validation with Zod, shared between client and types
  • Mapping server errors back onto individual fields
  • Auth flow: tokens, storage choices and their trade-offs
  • Refresh tokens and handling expiry mid-request
  • Protected routes and RBAC in the UI — and why that is not security

Build — Trip Creation Flow

Start herenpm i react-hook-form zod @hookform/resolvers. Write the Zod schema first; every form and type comes from it.

  • Multi-step trip creation with per-step validation and a resumable draft
  • One Zod schema drives both validation and the TypeScript types
  • A 422 from the server lands on the correct field with the server's message
  • Mock auth with login, refresh and a clean expiry path
  • Role-gated actions hidden in the UI and still rejected by the API
Ship gate — the week is not done until this is true

A server-side validation error attaches to the right field rather than appearing as a generic toast.

Interview checkpoint — answer it out loud, from memory

Why is client-side role gating a UX feature rather than an authorisation control?

The role-gating point is a favourite interview question. Hidden buttons are convenience; the server is the control.

ReferencesZod — documentationReact — formsReact Router — authentication

20

Testing

0/12

Write tests that survive a refactor, because tests that do not are worse than none.

Learn

  • Unit, component and integration tests — what each is actually for
  • React Testing Library: testing behaviour rather than implementation
  • Queries by role and accessible name, and why they beat test ids
  • API mocking with MSW at the network layer
  • Accessibility assertions inside ordinary tests
  • What not to test, and the cost of over-testing

Build — Tested Travel Dashboard

Start herenpm i -D vitest @testing-library/react @testing-library/user-event msw jsdom. Set up setupTests.ts with an MSW server that starts before all tests.

  • Component tests for the dashboard's primary widgets
  • Form tests covering validation, submission and the server-error path
  • Routing tests including a protected route redirect
  • MSW handlers for success, error, empty and slow responses
  • One integration test that walks a full user journey end to end
Ship gate — the week is not done until this is true

The suite catches a real regression that you introduce on purpose, and no test breaks when you rename an internal variable.

Interview checkpoint — answer it out loud, from memory

What makes a test brittle, and why is querying by role better than querying by test id?

Introduce the regression deliberately before you trust the suite. An untested test suite is a comfort blanket, not a safety net.

ReferencesReact Testing LibraryVitestMSW — Mock Service Worker

21

Performance and Production

0/12

Measure first. Almost every React performance change made without a profile is either neutral or harmful.

Learn

  • Rendering, reconciliation and what actually causes a re-render
  • Memoisation done right — and the cases where memo makes things slower
  • Code splitting, lazy loading and Suspense boundaries
  • Bundle analysis and finding the dependency that costs 300 KB
  • Network waterfalls and how to flatten them
  • Image optimisation, list virtualisation, error boundaries, environment config

Build — Performance Challenge

Start hereClone your Week 8 dashboard and add deliberate slowness: a 5k-row list, heavy renders, a big dependency. Then measure before changing anything.

  • Profile a deliberately slow dashboard with the React Profiler and DevTools
  • Record baseline numbers: LCP, INP, bundle size, render count
  • Fix the top three bottlenecks and re-measure after each one
  • Virtualise one long list and confirm the improvement is real
  • Add error boundaries and a production build config
Ship gate — the week is not done until this is true

A before-and-after table with real measurements, where every number came from a profile rather than an opinion.

Interview checkpoint — answer it out loud, from memory

How do you find the cause of a slow list, and when is memo actively harmful?

Keep the before-and-after table in the README. “I made it faster” is worthless; “INP went from 480 ms to 90 ms, here is what caused it” is a hire signal.

ReferencesReact — referenceVite — building for productionChrome DevTools — performance

22

AI Frontend Capstone

0/12

Design a UI for a backend that is slow, non-deterministic and occasionally wrong — which is the real AI frontend problem.

Learn

  • Streaming UI: rendering tokens as they arrive without thrashing the DOM
  • AI chat UX: message state, retry, edit, stop generation
  • Showing tool status so the user knows what the agent is doing
  • Rendering citations that resolve back to the source
  • File upload and conversation state that survives a reload
  • Error recovery, accessibility of a live region, responsive layout

Build — OurAtlas AI Frontend

Start hereFrontend with TanStack Query + router + Zod from earlier weeks. The backend is your Week 12 agent API. Agree on the streaming event format (SSE JSON events) first.

  • Chat with real token streaming from your Week 12 agent
  • Visible tool-call status: what ran, what it returned, what failed
  • Clickable citations that open the cited source passage
  • Trip editor and saved trips, with auth
  • An approval UI that gates the agent's sensitive actions
Ship gate — the week is not done until this is true

The frontend is wired to your own Week 12 agent: it streams, shows what the agent is doing, and lets a user approve or reject an action before it happens.

Interview checkpoint — answer it out loud, from memory

How do you design a UI for a system that is slow, non-deterministic and sometimes wrong?

This is the week that makes the whole roadmap legible to a non-AI interviewer. Everything before it is invisible until someone can click it.

ReferencesReact — documentationMDN — Server-sent eventsMDN — ARIA live regions

Topic → evidence

When someone asks “have you used X?”, the answer is a repository, not a yes. This is the mapping from the React half; Phase 1 maps the same way, one project per week, compounding into the capstone.

TopicProject evidence
JavaScript arrays and objectsTyped API Dashboard
Async and promisesTyped API Dashboard — abort on query change
TypeScriptTyped API models and hooks, strict mode clean
Components and JSXExpense Tracker UI
Props and childrenReusable cards and layout components
StateKanban board
useReducerKanban state machine with undo
ContextAuth or theme, scoped deliberately
Custom hooksuseDebounce, useAuth, useTrip
EffectsLive search cancellation
RefsFocus management and imperative behaviour
RoutingTravel planner, nested layouts
URL stateShareable search and filter parameters
Server stateCRUD trip app with cache invalidation
MutationsCreate, update and delete trip
Optimistic updatesTrip status update with rollback
Forms and validationMulti-step trip creation, Zod schema
AuthProtected routes, refresh, role-gated actions
TestingTravel dashboard, MSW handlers, a11y checks
PerformanceSlow-dashboard challenge, before/after table
StreamingAI chat with token streaming
AccessibilityKeyboard and screen-reader pass on the chat surface
ProductionVite build, Docker, deployed

Interview standard

By the end you should be able to take any of these and talk for five minutes from your own code rather than from a blog post you read.

  • Workflow vs agent vs multi-agent, and when each is the wrong choice.
  • Where state lives in your system, and why it lives there.
  • RAG failure modes, and how you tell retrieval failure from generation failure.
  • MCP, the protocol boundary, and where authorisation belongs.
  • The agent harness as a reliability boundary: permissions, retries, budgets, approval.
  • Evaluation and regression testing — how you know a change helped.
  • Cost per request, and what you did to bring it down.
  • React state vs server state, and why fetch-in-effect goes wrong.
  • Why unnecessary effects are harmful, with an example from your own code.
  • Caching, retries, idempotency and rate limiting across the whole stack.
  • Prompt injection through tool output, and what you did about it.
  • How you would design the system at ten times the scale.

Project standard

Every project on this page is finished when all eight of these exist. A repository missing them is a draft, however good the code is.

  • README that states what it does and what it does not.
  • Architecture diagram, even if hand-drawn and photographed.
  • Setup instructions that work from a clean clone.
  • Tests, and one regression they actually caught.
  • Sample inputs and outputs.
  • Known limitations, written honestly.
  • Screenshots or a short recording.
  • A closing section: what I would change at 10× scale.