Developer roadmaps where every node is actually taught.
Every topic opens an original lesson built around one hand-picked free video. No tiers, no paywalls, no upgrade nags. An account saves your progress; that is the whole of it.
What a lesson looks like
Every node opens one of these: original prose built around a single hand-picked video, with what to take away and a way to check you actually got it.
How LLMs work- A language model is one enormous learned function that maps a sequence of tokens to a probability distribution over the next token.
- Generation is that function run repeatedly, each output appended to the input — which is why a long response costs far more than a long prompt.
Why is a model's output a distribution rather than a single answer?
Which roadmap should you start?
Two questions, and the catalog narrows to the roadmaps that fit.
Where are you starting from?
What are you interested in?
Start here
- AI AgentsSoftware that reasons, calls tools, and acts on its own, instead of a model that only answers one prompt. Thirty-three lessons from the agent loop through tools, memory, multi-agent architectures and the frameworks used to ship them, to evaluating and deploying agents safely.
- AI Data ScientistThe statistical and experimental reasoning that sits underneath modern AI work — distributions, hypothesis tests, causal inference, and A/B design — paired with the coding and EDA habits that turn raw data into a defensible answer, then into a model whose numbers can be explained to someone who didn't build it. Twenty-nine lessons from what the role actually is through shipping and communicating a result.
- AI EngineerBuilding products on top of models you did not train. Thirty-six lessons from what a token is through retrieval, agents, evaluation and safety, to the work of keeping an LLM feature alive in production.
- AI Product BuilderGoing from an idea to a shipped product by directing AI tools rather than writing every line by hand — picking a prototyping tool, working an AI coding agent on a real codebase, and still knowing enough HTML, React, and testing to judge what it hands back and ship it responsibly. Thirty lessons from problem definition through deployment and running costs.
- AI Red TeamingFinding the ways a model, its prompts, and the systems around it can be broken — before someone else does. Twenty-four lessons from prompt injection and jailbreaks through model extraction, poisoning, and agentic exploits, to the testing methodology and defenses a real engagement runs on.
- AngularComponents, templates, dependency injection, signals, RxJS, forms, routing, HTTP, state management, testing, and the production concerns of shipping an Angular application — the framework itself, not the TypeScript it's written in (`typescript`) or the JavaScript underneath that (`javascript`). Sixty-two lessons.
- API DesignHow to design, secure, document, and operate an API as a product with its own contract — not the transport or infrastructure underneath it. Resource modeling, versioning, pagination, and error contracts; OAuth2/JWT/API-key authentication and the full authorization-model taxonomy in practice; OpenAPI documentation and a testing discipline built specifically for APIs (contract tests, mocking, load testing); the OWASP API Security Top 10; and the compliance standards an API has to answer to. Twenty-one lessons that assume computer-science (HTTP, TCP/IP, DNS) and system-design (REST/gRPC/GraphQL mechanics, rate limiting, caching, load balancing, gateways, event-driven messaging, microservices) as a starting point and go one layer up — the contract a client depends on, not the mechanics underneath it.
- BackendThe practitioner concerns of writing the service behind the API, scoped to avoid the ground already taught in system-design, api-design, software-architect, and computer-science. Thirty-one lessons.
- Code ReviewThe craft of peer review itself — not the design judgment a reviewer applies (that's `software-design-architecture`/`software-architect`), but the practice around it: why review earns its cost, preparing a change so it's actually reviewable, what a reviewer should spend attention on, the etiquette of giving and receiving feedback without it turning adversarial, pushing the mechanical checks onto tools instead of people, and the failure modes (bikeshedding, rubber-stamping, review fatigue) that show up once a team does this every day.
- Computer ScienceThe layers above data structures and algorithms (see datastructures-and-algorithms) and short of system design (see system-design): how a CPU actually executes a program, how an operating system shares one machine among many programs, what a computer can and can't compute and how a compiler turns text into something that runs, how concurrent code stays correct, how bits become numbers and text, how patterns organize software, and how machines talk to each other over a network. Twenty-nine lessons that assume the core data structures and algorithms as a starting point.
- Data Structures & AlgorithmsComplete on its own: the core data structures and algorithms from the ground up (complexity, arrays/lists/stacks/queues, hash tables, trees and heaps, graphs, sorting, searching, recursion, greedy, backtracking, dynamic programming), then everything computer-science doesn't cover — advanced trees and range-query structures, disjoint sets and graph-structure algorithms, shortest-path algorithms that handle negative weights and heuristics, non-comparison sorting, the design techniques behind divide-and-conquer and randomization, advanced string matching, and the full interview pattern catalog: two pointers, sliding window, merge intervals, cyclic sort, top-k/two-heaps, subsets and permutations, classic DP, and the rest of what LeetCode-style problems are actually built from.
- FrontendHow the web works end to end, then the three layers every frontend sits on — HTML, CSS, and JavaScript in the browser — followed by the workflow, framework, and quality concerns that turn a page into a product. Deep language mechanics live in their own roadmaps (see javascript, typescript, react); this one is the generalist path and assumes none of them yet. Thirty-eight lessons.
- Inference EngineeringRunning a trained model efficiently in production, not training one. Thirty-two lessons from latency and throughput through hardware, serving software and the techniques that speed generation up, to running it all at scale.
- JavaScriptThe language itself — syntax, types, scope, functions, prototypes, classes, collections, the asynchronous model, modules, and the modern syntax and built-ins that make up idiomatic JavaScript — independent of any browser API or runtime. DOM manipulation, fetch, and browser storage are taught in `frontend`; the type system lives in `typescript`; Node's own runtime and module tooling live in `nodejs`. Thirty-nine lessons.
- Machine LearningBuilding and training models from data, not calling ones someone else trained. Thirty-three lessons from what learning from data means through classical models, evaluation and neural networks, to where deep learning picks up.
- MLOpsTaking a trained model from a notebook to something that keeps running in production: versioning data, tracking experiments, building the pipelines that retrain and redeploy it, and watching it once it is live.
- Prompt EngineeringMaster the art and science of crafting effective prompts for large language models. From basics to advanced techniques, learn how to communicate with LLMs to get reliable, structured outputs at scale.
- Software ArchitectWhat the architect role actually does above the code: making and recording trade-off decisions, the principles and patterns that keep a system coherent as it grows, the paradigms an architect has to reason across, security and data architecture, and the cloud and enterprise patterns a production system is actually assembled from. Twenty-six lessons that assume computer-science and system-design as a starting point and go one layer up from both — the job of choosing and defending a system's shape, not the mechanics of any one piece of it.
- Design Principles & PatternsThe heuristics that keep a design honest as it grows — DRY, KISS, YAGNI, composition over inheritance, coupling and cohesion — the discipline of noticing and fixing a design that's gone bad (code smells, refactoring, test-driven development), and the Gang-of-Four catalog of creational, structural, and behavioral design patterns as the recurring shapes those heuristics produce in practice. Fifteen lessons that assume object-oriented programming and SOLID as a starting point (see software-architect) and go one layer deeper than computer-science's single GoF survey lesson into the patterns themselves.
- System DesignHow a system is actually designed to handle scale: the estimation and tradeoff habits, the networking and API choices, load balancing, caching, data modeling and storage at scale, consistency/availability/consensus, asynchronous messaging, reliability patterns, architecture patterns, and observability and security at scale that a production system needs — closing with worked, end-to-end case studies of the classic system-design interview problems. Sixty lessons that assume the core data structures and algorithms, and general computer science, as a starting point (see datastructures-and-algorithms and computer-science).
- TypeScriptThe type system and the toolchain around it — everyday types, typing functions, structural typing, narrowing, generics, type-level programming, classes and decorators, modules and declaration files, and the practice of running TypeScript in a real codebase. The JavaScript language itself is taught in `javascript`; framework usage lives in `angular` and `react`. Sixty-four lessons.
Roadmaps
All 21Interactive graphs of what to learn and in what order. Pick a track and follow the nodes — each one opens an original lesson. Newest additions first; the rest are behind the link above.
- 0%AngularComponents, templates, dependency injection, signals, RxJS, forms, routing, HTTP, state management, testing, and the production concerns of shipping an Angular application — the framework itself, not the TypeScript it's written in (`typescript`) or the JavaScript underneath that (`javascript`). Sixty-two lessons.
- 0%TypeScriptThe type system and the toolchain around it — everyday types, typing functions, structural typing, narrowing, generics, type-level programming, classes and decorators, modules and declaration files, and the practice of running TypeScript in a real codebase. The JavaScript language itself is taught in `javascript`; framework usage lives in `angular` and `react`. Sixty-four lessons.
- 0%JavaScriptThe language itself — syntax, types, scope, functions, prototypes, classes, collections, the asynchronous model, modules, and the modern syntax and built-ins that make up idiomatic JavaScript — independent of any browser API or runtime. DOM manipulation, fetch, and browser storage are taught in `frontend`; the type system lives in `typescript`; Node's own runtime and module tooling live in `nodejs`. Thirty-nine lessons.
- 0%BackendThe practitioner concerns of writing the service behind the API, scoped to avoid the ground already taught in system-design, api-design, software-architect, and computer-science. Thirty-one lessons.
- 0%FrontendHow the web works end to end, then the three layers every frontend sits on — HTML, CSS, and JavaScript in the browser — followed by the workflow, framework, and quality concerns that turn a page into a product. Deep language mechanics live in their own roadmaps (see javascript, typescript, react); this one is the generalist path and assumes none of them yet. Thirty-eight lessons.
- 0%Code ReviewThe craft of peer review itself — not the design judgment a reviewer applies (that's `software-design-architecture`/`software-architect`), but the practice around it: why review earns its cost, preparing a change so it's actually reviewable, what a reviewer should spend attention on, the etiquette of giving and receiving feedback without it turning adversarial, pushing the mechanical checks onto tools instead of people, and the failure modes (bikeshedding, rubber-stamping, review fatigue) that show up once a team does this every day.
No tiers, no paywalls, no upgrade nags — one hand-picked video per topic, turned into a proper lesson, open to anyone who wants it. 21 of the 94 roadmaps in the catalog are live; Web development is next.
The formula library
All 80The maths the lessons lean on, each one written out, glossed in plain English, and cross-linked to the topics that use it.