All ninety days,
in order.

How code actually runs

Trace what happens between saving a Python file and seeing output: what reads your text, what turns it into instructions, where values live while it runs, and why a compiled language differs from an interpreted one.

Values, variables, and what a reference really is

Predict whether changing one variable will change another, explain the difference between a name and the value it points at, and say why two lists can look identical yet behave differently.

Conditions, loops, and the shape of logic

Read a nested block of conditions and loops and say exactly which lines run for a given input, and you can flatten a deeply nested block into something a person can follow.

Functions, arguments, returns, and scope

Say exactly which names a function can see, why a function that prints is different from one that returns, and why splitting code into functions is a design decision rather than tidiness.

Lists, dicts, sets, and choosing between them

Pick the right collection for a problem and defend the choice, and you can say roughly how expensive a lookup is in each one without having measured it.

Errors, exceptions, and reading a stack trace

Read a stack trace from the bottom up, name the line that actually failed, and say whether an error should be caught, allowed to crash, or fixed at its source.

How to debug anything without guessing

Take a bug you cannot explain and narrow it to a single line by halving the search space, rather than changing things until the symptom disappears.

The terminal, files, and paths

Navigate a filesystem from the command line without a mouse, explain the difference between a relative and an absolute path, and say what actually happens when you type a command and press enter.

Modules, packages, and virtual environments

Explain what happens when Python runs an import, why the same code works on one machine and fails on another, and what a virtual environment actually isolates.

Git, and why version control exists

Explain what a commit actually is, why branching is cheap, and what a merge conflict physically represents, rather than memorising commands you do not understand.

Reading unfamiliar code

Open a codebase you have never seen, find where it starts, follow one path of execution end to end, and describe what it does without having read every line.

Everything so far, and your first architecture question

Connect the eleven days behind you into one picture, identify which two concepts you are weakest on, and answer a design question about where code should live and why.

Big O, without the maths

Look at a loop and say how its cost grows as the input grows, explain why that matters more than raw speed, and name the complexity of the operations you use every day.

Arrays, strings, and the two-pointer idea

Recognise when a problem over a sequence can be solved with two moving indices instead of nested loops, and turn an O(n squared) solution into an O(n) one.

Hash maps, sets, and how caches use them

Explain what hashing actually does, recognise the class of problem where storing what you have already seen collapses a nested loop, and say why a cache is a hash map with a memory limit.

Objects, classes, and composition over inheritance

Decide whether something should be a class or stay a function, explain what self actually is, and say why deep inheritance hierarchies cause more problems than they solve.

Stacks, queues, and the call stack you already met

Say which of last-in-first-out or first-in-first-out a problem needs, and explain the call stack from Day 4 as an instance of a structure rather than a special language feature.

Recursion, and how it eats the stack

Write a correct recursive function by identifying its base case and its shrinking step, trace its frames on paper, and say honestly when iteration would have been the better choice.

Sorting, binary search, and when you only need the top K

Explain why sorting costs n log n and searching sorted data costs log n, write a binary search with correct boundaries, and decide whether sorting first is worth it.

Trees, and why every database index is one

Traverse a tree recursively, explain why a balanced tree gives logarithmic lookup, and say what goes wrong when a tree becomes unbalanced.

Graphs, BFS, DFS, and dependency order

Model a problem as nodes and edges, choose breadth-first or depth-first for a reason rather than a habit, and produce a valid order for things that depend on each other.

Your data structure decision table

A written decision table you can apply to any new problem, and you can defend a structure choice under pressure rather than reaching for a list by default.

What actually happens when you type a URL

Narrate the full path from pressing enter to seeing a page: name resolution, connection, request, response, and render, naming what could fail at each step.

HTTP methods, status codes, and headers

Read a raw request and response and explain every line, choose the correct method and status code for an operation, and say what makes a request safe or idempotent.

JSON, REST, and the idea of an API contract

Design a coherent set of endpoints for a resource, explain what makes an API RESTful beyond using HTTP, and say why a contract matters more than any individual endpoint.

JavaScript fundamentals for engineers

Read JavaScript confidently by mapping it onto what you already know from Python, and you can name the handful of genuine differences that cause real bugs.

The event loop, single-threaded and still fast

Predict the order in which asynchronous code runs, explain why a single thread can serve many requests, and say exactly what blocking the loop does to everyone else.

Promises, async, await, and real concurrency

Write asynchronous code that runs independent work at the same time rather than one after another, and you can spot the sequential await that quietly triples a response time.

TypeScript, and why static types exist

Explain what a type checker does and when, read type annotations fluently, and say honestly what TypeScript does not protect you from at runtime.

Interfaces, unions, and generics in practice

Model states so that impossible combinations cannot be expressed, narrow a union safely, and read a generic signature without flinching.

The browser, the DOM, and where state lives

Explain what the DOM is as a data structure, why touching it repeatedly is slow, and why manually keeping UI and state in agreement becomes unmanageable.

React's mental model

Explain React as a function from state to UI, predict when a component re-renders, and say why the manual synchronisation problem from yesterday disappears.

Next.js routing, layouts, server and client

Say which code runs on the server and which in the browser, explain what that means for secrets and for data fetching, and read a Next.js project without guessing.

Tracing one request through a whole app

Take one user action and narrate every layer it passes through, from keypress to pixel, naming what could fail and what you would check first at each step.

Anatomy of a backend

Open an unfamiliar backend and name each layer, say what belongs in each, and explain what goes wrong when business logic ends up inside a route handler.

Building an API with FastAPI

A working API with several endpoints, and you can explain what the framework is doing for you at each point rather than treating it as magic.

Validation, serialization, and the trust boundary

Identify every trust boundary in a system and say what must be validated at each, and explain why validating in the browser protects nobody.

Authentication versus authorization

Separate proving who someone is from deciding what they may do, and spot the authorization bug where an endpoint checks the first and forgets the second.

Sessions, tokens, and what a JWT actually is

Explain how a stateless protocol remembers who you are, decode a JWT by hand, and say precisely why you cannot revoke one without giving up the property that made it attractive.

Password hashing, CORS, and secrets

Explain why passwords are hashed rather than encrypted, read a CORS error and know exactly what the browser is telling you, and say where secrets belong.

Relational thinking: tables, keys, relationships

Turn a description of a business into tables with keys and relationships, and explain why storing the same fact in two places will eventually make them disagree.

SQL: SELECT, WHERE, JOIN, GROUP BY

Write a query joining several tables with filtering and aggregation, and explain in what order the database conceptually evaluates the clauses.

Indexes, and why a query goes from 4s to 4ms

Explain why an unindexed query on a large table is slow, what a B-tree index physically stores, read an EXPLAIN plan well enough to tell whether an index was used, and say what each index costs you on every write.

Transactions, and what ACID actually protects

Say which failures a transaction prevents and which it does not, and recognise the race condition that survives even inside one.

ORMs, the N+1 problem, and SQL injection

Read ORM code and know what SQL it will produce, spot an N+1 query before it reaches production, and explain why parameterised queries stop injection while escaping does not.

Design a schema and defend it

Take a business description, produce a schema and an API for it, and defend every decision against someone actively looking for holes.

Testing: what's worth testing, and what isn't

Decide what deserves a test and what does not, write tests that survive refactoring, and explain why a high coverage number can mean almost nothing.

Integration and end-to-end tests

Choose the right level for a given test, write one that exercises a real database, and explain why end-to-end tests are the most valuable and the most expensive at once.

Logging that helps you at 3am

Write log lines that answer questions during an incident, choose levels deliberately, and explain why structured logs and a correlation ID change what is possible.

Docker, and why containers exist at all

Explain what a container actually is, write a Dockerfile that is not wasteful, and say why a container is not a virtual machine.

CI, CD, and deployment pipelines

Describe what should happen automatically between a push and production, write a pipeline that runs your checks, and explain how a bad deploy is undone.

Environments, configuration, and secrets management

Separate configuration from code so one build runs correctly everywhere, and explain what to do the moment a secret leaks.

Observability: logs, metrics, and traces

Say which of the three signals answers which kind of question, choose what to alert on, and explain why a dashboard full of green graphs can coexist with users unable to log in.

Latency, throughput, and profiling intuition

Tell latency and throughput apart, estimate roughly what an operation should cost before measuring, and find where time actually goes rather than where you assumed.

Timeouts, retries, backoff, and idempotency

Make a call to something unreliable without making the outage worse, and explain why a naive retry is one of the most dangerous three lines of code you can write.

Write a production readiness checklist

A checklist you would genuinely use before putting something in front of users, and you can apply it to a service you did not write.

How to approach a system design question

A repeatable method for any design question, and you can resist the urge to name technologies before you have established what the system must actually do.

Estimating traffic, storage, and capacity

Turn a vague requirement into numbers in a couple of minutes, and use those numbers to decide whether a design needs anything beyond one server.

Scaling up, scaling out, and load balancing

Say when a bigger machine beats more machines, explain what statelessness actually requires, and name the problems that only appear once there is more than one server.

Caching: hits, misses, invalidation, and Redis

Decide what to cache and for how long, name the failure modes caching introduces, and explain why invalidation is genuinely one of the hard problems.

Replication, partitioning, and sharding

Say which of replication and sharding solves which problem, explain replication lag and the bug it causes, and name what you permanently give up by sharding.

Consistency, availability, and CAP intuition

State what CAP actually says rather than the popular misreading, decide what a given feature needs, and describe eventual consistency in terms a product owner would accept.

Queues, workers, and event-driven architecture

Decide what work belongs outside the request, explain what a queue guarantees and what it does not, and say why every consumer must tolerate seeing the same message twice.

WebSockets, polling, and streaming

Choose between polling, server-sent events and WebSockets for a given feature, and explain why persistent connections make scaling harder than request-response ever was.

Monoliths, modular monoliths, and microservices

Say what problem microservices actually solve, name what they cost, and argue for a modular monolith without it sounding like an excuse.

Design one system end to end

Take a design question from requirements to a defended architecture in under an hour, and hold your position under sustained challenge.

What a language model actually is, for engineers

Describe what happens between sending text and receiving a response, explain why the same input can give different outputs, and say precisely why a model states false things with confidence.

Tokens, context windows, and cost

Estimate the token cost of a feature before building it, explain what happens when a conversation outgrows the context window, and say why the same conversation gets more expensive with every turn.

Calling an LLM API, end to end

Made real calls and can read every part of the request and response, and you can say which failures need a retry, which need a fallback, and which must never be retried.

Prompting and context engineering

Write a prompt that specifies what you actually want, and you can debug a bad output by finding what the prompt failed to make explicit rather than by adding emphasis.

Structured outputs and schema validation

Make a model return data your code can rely on, and you can explain why a schema constraint at the API level is not a substitute for validating what arrives.

Streaming, latency, fallbacks, and routing

Stream a response to a user, explain why streaming changes perceived speed without changing total time, and design what happens when your primary model is unavailable.

Embeddings and vector similarity

Explain what an embedding represents, compute similarity between two pieces of text, and say precisely when semantic search beats keyword search and when it loses to it.

Chunking, indexing, and retrieval

Turn a set of documents into something searchable by meaning, and you can explain why chunking decisions determine retrieval quality more than the choice of vector database ever will.

RAG, and every way it fails

Build a complete retrieval-augmented pipeline and, more importantly, name which stage produced a bad answer rather than blaming the model.

Debug a broken RAG system

Take a retrieval system you did not build, find why it gives bad answers, and rank the fixes by what they would actually improve.

Tool calling: letting a model call your functions

Give a model a set of functions, understand exactly what it does and does not do when it picks one, and explain why the model never executes anything itself.

Tool schemas, validation, and tool errors

Treat tool arguments as untrusted input, decide which tools need approval before running, and return errors the model can actually recover from.

The agent loop

Write the agent loop from memory as ordinary code, name every place it can fail, and explain why an 'agent' is a while-loop around a model that can call your functions rather than a new category of software.

Workflow or agent, and when an agent is wrong

Decide whether a task needs a model deciding each step or a fixed sequence with model calls inside it, and defend the choice on testability, cost and failure behaviour.

Agent state, memory, and persistence

Say what an agent must remember, where each kind of state belongs, and how a long-running agent survives a process restart mid-task.

Human in the loop and approval flows

Decide which actions require a person's approval, design an approval that a tired human will actually read, and explain why approval fatigue makes over-asking as dangerous as never asking.

Multi-agent systems, and what they cost

Say what splitting work across several agents actually buys, name the four costs it adds, and recognise the cases where one well-scoped agent is plainly better.

MCP, and what it standardizes

Explain what problem the Model Context Protocol solves, describe its client and server roles, and say precisely what it standardizes and what it leaves entirely to you.

MCP servers, resources, and trust boundaries

Built a working MCP server, and you can name every trust boundary it introduces and who is responsible for each one.

Evaluating AI when normal tests don't work

Build an evaluation set for an AI feature, choose a grading method that fits the task, and explain why a passing test suite tells you almost nothing about a probabilistic system.

RAG evals and agent evals

Evaluate a retrieval pipeline stage by stage rather than end to end, and evaluate an agent on more than whether it eventually got the right answer.

Tracing, observability, and cost monitoring

Trace a single AI request through every model call, tool and retrieval, and answer why one user's request cost forty times the median.

Guardrails, prompt injection, and tool security

Explain why prompt injection has no complete fix, design a system that limits the damage when it succeeds, and identify every place untrusted text reaches a model in your own work.

Take apart a full AI system, end to end

Open an unfamiliar modern AI application, say what every piece does and why, name what would break first, and argue the alternatives. That was the point of all ninety days.