Learn
Long-form courses and essays on architecture, AI systems engineering, and the discipline behind shipping production software. Free to read; this is what I'd want a senior engineer joining my team to know.
Architecture & Systems
Designing systems that scale and last.
- Advanced~7 hour read
Software Architect: mindset, language, practice
A full course for a senior engineer who wants to think and talk like an architect: trade-offs, boundaries, data, distributed systems, quality, communication, and AI-native work.
- Introductory~20 minute read
Architect is a way of thinking
Express course on software architecture. Nine chapters on how to look at a problem where today's decision shapes the next three years. Essence only — images over definitions, questions over answers.
- Introductory~25 minute read
Scaling is widening the bottleneck
Express course on system design and scaling — what scaling means, vertical vs horizontal and stateless servers, load balancers, caching and CDNs, read replicas and sharding, queues and async, and how to scale sanely. Each with one picture and a concrete example. Essence only: measure over guess.
- Introductory~25 minute read
Patterns are the shapes systems take
Express course on software architecture patterns. The known shapes a system can take — layered, hexagonal, microservices, event-driven, CQRS, and more — each with one picture, a concrete example, and the price it charges. Essence only: examples over theory, problems over hype.
- Introductory~25 minute read
Design patterns are a shared vocabulary
Express course on the classic design patterns. The Gang of Four catalogue — Factory, Builder, Adapter, Decorator, Strategy, Observer, and the rest — each with one picture, a concrete example, and an honest note on when not to use it. Essence only: examples over UML.
- Introductory~25 minute read
Protocols are how programs talk
Express course on the data-exchange protocols modern apps run on — TCP/UDP, HTTP/1-2-3 and TLS, REST, GraphQL, gRPC, WebSocket, SSE, webhooks, message queues, Kafka, MQTT, and the formats on the wire. Each with one picture, a concrete example, and when to use it. Essence only: examples over RFCs.
- Introductory~25 minute read
A database is the system's memory
Express course on databases and data stores — relational/SQL, document, key-value, wide-column, graph, time-series, search, vector, and object storage, plus ACID/BASE/CAP, indexes, replication, and sharding. Each with one picture, a concrete example, and when to use it. Essence only: examples over benchmarks.
AI Engineering
Building reliable products on language models.
- Introductory~25 minute read
An LLM predicts; you engineer the rest
Express course on building with large language models — what an LLM really is, prompts, context engineering, RAG, tools and agents, evals, guardrails, cost, and shipping reliably. Each with one picture, a concrete example, and when to use it. Essence only: engineering over magic.
- Intermediate~25 minute read
The model only knows what's in the window
Express course on context engineering — the discipline of assembling exactly the right text into a model's context window. Why the window is all it knows, prompt versus context engineering, the system prompt and few-shot examples, relevance over completeness, the window as a budget, and context rot. Each with one plain picture, a concrete example, and the right word. Essence only: LLM quality lives in what you put in front of the model, not in clever wording.
- Intermediate~25 minute read
Letting the model think before it answers
Express course on reasoning models and test-time compute — why letting a model work through the steps before answering improves hard problems, and when it's worth the cost. Chain-of-thought, reasoning models, spending more compute at answer time, when reasoning helps, the cost of thinking, and why reasoning isn't truth. Each with one plain picture, a concrete example, and the right word. Essence only: thinking longer makes a model better at hard problems and wasteful on easy ones.
- Intermediate~25 minute read
From chatbot to component
Express course on structured output and tool use — turning a language model from a chatbot that emits prose into a dependable component your code can build on. Structured output and schemas, validating at the boundary, function calling and tools, designing good tools, and MCP. Each with one plain picture, a concrete example, and the right word. Essence only: to build software on a model you need output your code can trust and a safe way for the model to act.
- Intermediate~25 minute read
Meaning as coordinates
Express course on embeddings and vector search — turning meaning into numbers so 'find things like this' becomes 'find nearby points.' How embeddings place meaning in space, similarity as distance, the vector database, semantic search, the many uses beyond search, and the pitfalls. Each with one plain picture, a concrete example, and the right word. Essence only: embeddings are the quiet engine behind search, RAG, recommendations, and more — meaning made computable.
- Intermediate~25 minute read
Fix retrieval before you blame the model
Express course on RAG and grounding — why you hand the model facts instead of trusting its memory, chunking, embeddings and vector search, why retrieval quality is the whole game, grounding and citations, evaluating RAG, and building it well. Each with one picture, a concrete example, and when to use it. Essence only: in RAG the model is rarely the problem — your retrieval is.
- Intermediate~25 minute read
Three ways to teach a model your world
Express course on prompting, RAG, and fine-tuning — the three ways to give a model knowledge or behaviour it doesn't have by default, and how to choose. Why the model doesn't know your world, prompting, RAG, fine-tuning and LoRA, the key distinction (form versus facts), and the decision ladder. Each with one plain picture, a concrete example, and the right word. Essence only: most people reach for the most expensive option first, and fine-tuning is rarely what they actually need.
- Intermediate~25 minute read
Models that see and hear, not just read
Express course on multimodal AI — models that take images, audio, and video, not only text. How a model 'sees,' what multimodal unlocks, combining modalities in your product, generation across modalities, and the new pitfalls. Each with one plain picture, a concrete example, and the right word. Essence only: the same engineering you learned for text applies, plus new powers and new traps when the model can perceive more than words.
- Intermediate~25 minute read
Talking to AI, not typing
Express course on voice and realtime AI — building products you speak to instead of type to. The voice pipeline of speech-to-text, the model, and text-to-speech; the latency challenge; turn-taking and interruptions; and end-to-end realtime models. Each with one plain picture, a concrete example, and the right word. Essence only: voice means listen, think, and speak fast enough to feel like a conversation, and the hard part is doing it in real time.
- Intermediate~25 minute read
AI that runs on the device, not the cloud
Express course on on-device and edge AI — running models right on the phone, laptop, or sensor instead of in a data center. Why local matters, how models get small enough to fit, the capability trade-off, specialization over size, and the hybrid pattern. Each with one plain picture, a concrete example, and the right word. Essence only: a small model running locally unlocks privacy, offline use, instant response, and zero per-call cost — at the price of raw capability.
- Intermediate~25 minute read
Pay for intelligence by the token
Express course on the economics of building with AI — why every model call costs money and time, and how to keep it affordable. Tokens and the bill, why the frontier model isn't always the answer, routing by difficulty, caching, trimming and batching, and the latency-cost-quality triangle. Each with one plain picture, a concrete example, and the right word. Essence only: cost and speed are design constraints, and the cheapest model that clears the bar usually wins.
- Intermediate~25 minute read
An agent is a loop you have to engineer
Express course on building reliable AI agents — what an agent really is, why it works only ~57% of the time by default, context and memory, tools and the real world, orchestration and decomposition, the leash that keeps it safe, and the evals that get it to production. Each with one picture, a concrete example, and when to use it. Essence only: reliability is the product, and it comes from the loop, not the model.
- Intermediate~25 minute read
When one agent isn't enough
Express course on multi-agent orchestration — splitting work across specialized agents coordinated by an orchestrator, and when that beats a single agent. Why one agent that does everything does nothing well, the orchestrator pattern, specialized workers, handoffs, the sequential/parallel/hierarchical patterns, and the multiplied failure modes. Each with one plain picture, a concrete example, and the right word. Essence only: many agents can be more capable — and reflexive multi-agent multiplies the ways it breaks.
- Intermediate~25 minute read
Assume the model gets tricked
Express course on AI and LLM security — why a model can't tell your instructions from an attacker's, prompt injection, the agent attack surface, data leaks, the blast-radius defense mindset, guardrails and validation, and operating securely. Each with one picture, a concrete example, and what to do. Essence only: you can't make the model un-trickable, so secure what a tricked model can reach.
- Intermediate~25 minute read
Designing for a model that's sometimes wrong
Express course on AI product design — building a user experience on top of a component that is confident, fluent, and sometimes wrong. Setting honest expectations, showing the model's work, keeping the human in control, failing gracefully, and closing the feedback loop. Each with one plain picture, a concrete example, and the right word. Essence only: the model is fallible by nature, so the design — not the model — is what earns the user's trust.
- Intermediate~25 minute read
Building AI you can answer for
Express course on AI governance and regulation — building AI you can stand behind as the law and your own responsibility catch up. Risk tiers, the EU AI Act's shape, documentation and audit trails, the human accountability gap, and transparency and responsible AI. Each with one plain picture, a concrete example, and the right word. Essence only: governance is mostly unglamorous and doable — know where you're high-risk, show how it decides, and keep a human accountable. (Not legal advice.)
- Intermediate~25 minute read
Without an eval, you're tuning by vibes
Express course on evaluating AI systems — why a non-deterministic component needs a test suite, what to measure, building an eval set, how to grade (including LLM-as-judge), step-level evals for agents, offline versus online evaluation, and building it well. Each with one picture, a concrete example, and when to use it. Essence only: you can't improve what you don't measure, and reaching 95% is most of the work.
CS Foundations
The building blocks every engineer should own.
- Introductory~25 minute read
How the web actually talks
Express course on networking and the web — how machines find each other and exchange messages, from DNS and IP to TCP, HTTP, and HTTPS. Each idea with one plain picture, a concrete example, and the right word so the jargon finally clicks. Essence only: every page load is a conversation, and once you know the words it stops being magic.
- Introductory~25 minute read
The right shape makes the hard part easy
Express course on data structures and Big-O — organising data so the operations you do most are fast, and the notation for talking about speed. Big-O, arrays, hash maps, stacks and queues, trees and graphs. Each with one plain picture, a concrete example, and the right word. Essence only: choosing the right structure is often the whole difference between instant and unbearably slow, and Big-O is how you see it coming.
- Intermediate~25 minute read
Doing many things at once
Express course on concurrency and async — juggling tasks versus running them in parallel, threads and processes, blocking versus async and the event loop, race conditions, locks and deadlock, and safer patterns like message passing. Each with one plain picture, a concrete example, and the right word. Essence only: doing many things at once is how software stays fast, and the bugs all come from two things touching the same data at the same time.
- Introductory~25 minute read
Don't compute what you can remember
Express course on caching — keeping answers close so you don't redo the work, from browser and CDN to in-memory stores and the CPU. Hits and misses, hit ratio, TTL and staleness, invalidation and eviction, and the traps like stampedes. Each with one plain picture, a concrete example, and the right word. Essence only: caching is the biggest speed trick in computing, and keeping it fresh is its hardest problem.
- Intermediate~25 minute read
Leave a message, don't wait
Express course on queues and event-driven systems — why one service should drop a message instead of calling another and waiting. Producers and consumers, brokers, pub/sub, events versus commands, the resilience and scaling it buys, and the new hard parts like duplicates and ordering. Each with one plain picture, a concrete example, and the right word. Essence only: decoupling work in time is how systems stay fast and survive failure.
- Intermediate~25 minute read
Measure first, then make it fast
Express course on performance — why you measure before you optimise, what actually makes software slow, and how to fix it without guessing. Latency versus throughput, finding the bottleneck, the biggest real-world wins, tail latency and percentiles, and premature optimisation. Each with one plain picture, a concrete example, and the right word. Essence only: intuition about slowness is usually wrong, so profile, fix the one thing that dominates, and measure again.
- Intermediate~25 minute read
If you can't see it, you can't fix it
Express course on observability — how a running system tells you what it's doing through logs, metrics, and traces. The three pillars, what each one answers, the four golden signals, alerting and SLOs, and how to instrument without drowning in noise. Each with one plain picture, a concrete example, and the right word. Essence only: in production you can't attach a debugger, so you build the system to explain itself.
- Intermediate~25 minute read
It works on my machine, so ship the machine
Express course on CI/CD and containers — automating the path from a developer's laptop to production, and packaging an app so it runs the same everywhere. Continuous integration, continuous delivery, the pipeline, containers and images, orchestration, and safe deploys like canary and rollback. Each with one plain picture, a concrete example, and the right word. Essence only: shipping should be boring, automated, and identical everywhere.
- Introductory~25 minute read
Tests are how you change code without fear
Express course on testing — code that checks your code, and the real reason it pays off: letting you change things tomorrow without breaking what works today. Unit, integration, and end-to-end tests, the test pyramid, mocks and stubs, TDD, coverage, and flaky tests. Each with one plain picture, a concrete example, and the right word. Essence only: the point of tests isn't proving correctness once, it's the freedom to change without fear.
- Introductory~25 minute read
Never trust the input
Express course on web security fundamentals — why almost every vulnerability comes from trusting data that came from outside. Injection and SQL injection, cross-site scripting, CSRF, hashing passwords, least privilege, and defense in depth. Each with one plain picture, a concrete example, and the right word. Essence only: treat all external input as hostile until proven safe, and know the handful of classic attacks that punish forgetting it.
- Introductory~25 minute read
The cloud is someone else's computer
Express course on cloud computing and serverless — renting computers instead of buying them, and paying only for what you use. The service models (IaaS, PaaS, SaaS), elasticity and pay-as-you-go, regions and availability, managed services, and serverless. Each with one plain picture, a concrete example, and the right word. Essence only: the cloud isn't a buzzword, it's renting compute on demand — a set of clear trade-offs between convenience, control, and cost.
- Introductory~25 minute read
Git: a save button with a memory
Express course on Git and version control — recording every version of your project and letting a team work without overwriting each other. Commits and the staging area, branches, merging and conflicts, remotes and push/pull, plus undo, history, and rebase. Each with one plain picture, a concrete example, and the right word. Essence only: most of the fear around Git is just unfamiliar words — learn them and it becomes a calm safety net.
- Introductory~25 minute read
Who are you, and what may you do?
Express course on authentication and authorization — proving identity (passwords, MFA, passkeys), staying logged in (sessions vs JWT), delegated access (OAuth2, OIDC, API keys), permission models (deny-by-default, RBAC, ABAC, ownership), the common ways auth breaks, and how to do it right. Each with one picture and a concrete example. Essence only: standards over DIY.