Learning roadmaps

Seven modules on the layer a product needs the moment it has a customer, and the only one where being wrong costs money rather than uptime. What authorization, capture, settlement and payout actually are and who is entitled to decline each of them. How you become someone allowed to take a payment at all, and whether you want a gateway or a merchant of record. What a checkout hands to an attacker. Then the part nobody sequences: minor units, the webhook that is the only thing that knows, idempotency, entitlement state and a double-entry ledger that reconciles. Subscriptions on a card and under India's e-mandate framework. Declines, dunning, refunds and chargebacks. Marketplaces, splits and payouts. And what spending authority an AI agent may be granted.

1. 01How Money Actually Moves5 lessons
2. 02Becoming a Merchant & Choosing the Stack5 lessons
3. 03Checkout & the First Payment5 lessons
4. 04Money in Your Database5 lessons
5. 05Subscriptions, Usage & Recurring Money5 lessons
6. 06Failure, Fraud & Disputes5 lessons
7. 07Platforms, Payouts & the Agentic Money Path5 lessons

Ten modules on the layer that decides whether anyone ever arrives. It starts where no other SEO course does: what a crawler actually fetches, why your page is stored as a posting list rather than as a page, the arithmetic BM25 does to decide one document beats another, and PageRank as an eigenvector over a link graph. Then how an AI answer is really assembled - embeddings that match a page sharing none of your words, retrieval and grounding, one question fanning out into a dozen searches, and how a passage becomes a citation. Only then the practice: robots.txt and the AI crawlers, rendering and canonicals, Core Web Vitals and the page an agent sees, intent and topic architecture, content with evidence behind it, links and mentions and entities, and measuring any of it honestly across two consoles when the click may never happen. It ends with the part SEO courses skip - what a visit is worth, and the loop that turns one user into another.

1. 01How Search Actually Works5 lessons
2. 02How AI Answers Are Built6 lessons
3. 03Being Retrievable At All6 lessons
4. 04Structure a Machine Can Read5 lessons
5. 05Intent and Topic Architecture5 lessons
6. 06Content With Something Behind It5 lessons
7. 07Authority, Mentions and Distribution5 lessons
8. 08Measurement5 lessons
9. 09Turning a Visit Into a User5 lessons
10. 10The Growth Loop5 lessons

Thirteen modules for someone whose agent already works on the happy path. It starts by replacing the word 'agent' with a loop - model, tool call, result, repeat - and asks the question almost nobody can answer about their own system: what did the model actually receive on turn three. Then tools and function calling, schemas and argument validation, and what goes wrong when there are forty of them. MCP end to end: hosts and clients and servers, tools and resources and prompts, stdio against streamable HTTP, and building, testing and distributing a server yourself. Context engineering as a budget rather than a window - compaction, memory that is not a vector database, retrieval into the loop, and context rot. Planning and decomposition, and when planning makes an agent worse. Multi-agent orchestration, including the case for one agent. Then the parts that decide whether it survives contact with users: least privilege and sandboxing, prompt injection through tools and the lethal trifecta, evaluating a trajectory rather than an output, where the tokens go, and tracing a run you have to reproduce. It stops where inference-engineering starts: how the model is trained or served is not this course.

1. 01What an agent actually is5 lessons
2. 02Tools and function calling5 lessons
3. 03MCP: the protocol5 lessons
4. 04Building an MCP server4 lessons
5. 05Context engineering5 lessons
6. 06Planning and decomposition4 lessons
7. 07Multi-agent orchestration5 lessons
8. 08Permissions and sandboxing4 lessons
9. 09Untrusted input in a loop4 lessons
10. 10Evaluating agents5 lessons
11. 11Cost, latency and caching5 lessons
12. 12Observability and debugging runs4 lessons
13. 13Shipping an agent5 lessons

Eight modules on the half of machine learning that runs in production. How a token is actually produced, why the GPU spends most of its time waiting, what the KV cache costs, how batching and scheduling fill the machine, how quantisation and speculative decoding shrink the work, and what a fleet of GPUs costs per million tokens. Then the two workloads that changed the job: serving agents, where hundreds of turns share one enormous prefix, and serving models that think before they answer.

1. 01The Generation Loop11 lessons
2. 02The Hardware Floor12 lessons
3. 03The KV Cache11 lessons
4. 04The Batch12 lessons
5. 05Fewer Bytes, Fewer Steps12 lessons
6. 06The Fleet12 lessons
7. 07Serving Agents12 lessons
8. 08Thinking Costs Tokens12 lessons

Twelve modules from ingestion to the warehouse: SQL for engineers, modelling, batch and streaming pipelines, orchestration, quality, vector databases and the RAG pipeline, versioning, feature stores, and preparing data for a foundation model. All 85 lessons are written; the curation is still filling in behind them, and each lesson says where it stands.

1. 01The Modern Data Stack7 lessons
2. 02SQL for ML Engineers7 lessons
3. 03Data Modeling7 lessons
4. 04Batch Processing at Scale7 lessons
5. 05Streaming & Real-Time7 lessons
6. 06Warehouses & Lakehouses7 lessons
7. 07Orchestration7 lessons
8. 08Data Quality & Monitoring7 lessons
9. 09Vector Databases & RAG Pipelines7 lessons
10. 10Data Versioning & ML Reproducibility7 lessons
11. 11Feature Engineering & Stores7 lessons
12. 12Data for LLMs & Foundation Models8 lessons

Eleven modules for someone who has shipped something live by prompting and does not read code. It opens on the mathematics - why latency goes vertical near saturation, Little's Law, why an average hides the tail, availability as multiplication, and feedback with lag. Then what deployment and a server actually are; the network, from the speed of light as a floor through DNS and TLS to the edge; the machine, from processes to containers to what boots when a function is invoked; the real options for where code runs and what each costs; state and consistency, taught from the Cambridge distributed systems lectures; access and blast radius, where every documented vibe-coding catastrophe actually landed; releasing; detecting failure; how systems fail; and what scale costs.

1. 01The Language of Systems6 lessons
2. 02What Deployment Is5 lessons
3. 03The Network5 lessons
4. 04The Machine5 lessons
5. 05The Types, Compared5 lessons
6. 06State and Consistency5 lessons
7. 07Access and Blast Radius5 lessons
8. 08Releasing5 lessons
9. 09Detecting Failure5 lessons
10. 10How Systems Fail5 lessons
11. 11Scale, Cost, and Limits5 lessons

Seven modules on the part of a product that knows who someone is. It starts with the four things a "user" quietly collapses - identity, credential, session and authorization - and takes each one seriously: how a password, a code and a passkey differ in what they can be stolen by, why a lifted session cookie walks past MFA and passkeys alike, and what OAuth actually delegates. Then permissions, from roles to relationships, through the access-control bug that sits in almost every generated CRUD layer, and out into teams, organizations and the three ways a SaaS keeps one customer's data away from another's. After that the parts nobody writes down: what the account lifecycle really has to touch when somebody asks to be deleted, why signup is not activation, and that a notification system is a distributed system with queues, retries and a provider that throttles. It ends on support and privileged access - letting somebody help a user without creating an invisible super-admin - and on the question 2026 added, which is what authority an AI agent may exercise on a user's behalf.

1. 01Identity & Authentication6 lessons
2. 02Permissions & Organizations5 lessons
3. 03User Data & Lifecycle4 lessons
4. 04Onboarding & Activation4 lessons
5. 05Communication & Notifications5 lessons
6. 06Support, Admin & Trust5 lessons
7. 07Building the User System5 lessons