1. How Software Actually Runs
From the text you type to electrons doing work
8 tracks, 56 modules, in the order they are meant to be taken. The 8 free preview modules below are fully playable — the animated diagram on this page is the same one paying learners work through.
How software actually runs, and the building blocks of every program you'll ever write.
From the text you type to electrons doing work
Variables, control flow, and functions — the grammar of every language
Arrays, objects and JSON — your general ledger for the digital world
The one interface that composes, scripts, and never changes out from under you
Everything between the browser and the server — DNS, TCP, TLS, and the anatomy of one request
A repeatable method, not luck — reproduce, read, isolate, and change one thing at a time
Data structures, algorithmic thinking, version control and testing — the craft under the craft.
Stacks, queues, hash maps and trees — and when each one wins
Why some code stays fast at 10,000 records and some collapses
Git as your audit trail; tests as your internal controls
A function that calls itself, the structure it was made for, and when a loop is plainer
Doing more than one thing at once without the folklore — sync vs async, the event loop, and the race
The skill nobody teaches and every professional needs — comprehending code you didn't write
The request lifecycle, React, APIs and databases — your working stack, understood deeply.
What actually happens in the 300ms after a user taps a button
Components, props, state — and the render cycle that ties them together
REST design, SQL thinking, and why indexes change everything
What logging in actually is — session, cookie, hash and the round trip a single user makes to sign in
The deceptively hard feature — multipart, server-side validation, signed URLs and serving files back safely
The engineering of a form that doesn't punish people — controlled inputs, dual validation and error handling in code
Scaling, data at scale, and event-driven architecture — including the ledger pattern you already use.
Vertical vs horizontal, load balancers, and why stateless wins
Caching, replication, and the trade-offs behind every fast system
Immutable events, projections, and queues — double-entry thinking for systems
Entities, keys and constraints — why a schema that doesn't reconcile is a set of books that doesn't balance
Expand, backfill, contract — schema evolution without downtime or data loss
Networks fail after the work is done — building safety into the retry, using payments as the example
Reengineering processes and translating them into software — where your accounting instincts become an unfair advantage.
Don't pave the cowpaths — redesign the process, then digitise
Actors, states and events — the translation layer between BPR and code
Approval gates, notifications, and audit trails that clients trust
Why two reports disagree, and how to build numbers people will sign their name to
Building software for work that has to answer to somebody
Migration and cutover — the change-management project wearing an engineering costume
Why some products feel world-class and most don't — the craft layer AI generates badly and users judge instantly.
Spacing, type and colour as a system — most bad design is inconsistency, not bad taste
Empty, loading, error and success — the four states AI-generated code always omits
Deciding what to build, what to refuse, and when to stop
Onboarding and activation — where the value proposition becomes real or is exposed as a claim
Naming, grouping and the list view — how people build a mental model of your product
Microcopy — the cheapest quality upgrade available to any software product
Security, DevOps and AI-native engineering — shipping systems people can bet a business on.
Authentication, authorization, and the mistakes that sink products
Environments, pipelines, and knowing your system is healthy
LLMs as components: prompts, RAG, agents, and cost discipline
Who you are, what you may do, and proving the database refuses everyone else
What must never reach the browser, and what you inherited the moment you installed that package
The constraint has moved from writing code to judging it
Stop learning about systems and build one. Follow a real app from empty repo to deployed, with auth, a database you can trust, payments and a live URL — your choice of two projects.
Install the handful of free tools and create the free accounts you'll build on — then verify each one before you touch Step 1.
The interactive walkthrough for this preview is being published.
Clone the template, wire your own Supabase, and deploy a live app to a real URL before you build a single feature.
Email + password auth with a session that survives a refresh and a gate a signed-out visitor can never slip past.
Your first tenant-scoped table, with isolation proven at the database by a runnable test — not trusted from the UI.
CRUD with the four states AI skips — idle, submitting, success, error — and never lose what the user typed.
Take a test payment, mark the account Pro through a webhook you can safely replay, and gate a feature at the server.
One app, many businesses — every client and invoice isolated to a workspace at the database, not by a WHERE clause you hope you remembered.
The centerpiece: never store a balance you can derive — record immutable events, replay them into the balance, and correct with a reversal, never an edit.
A DB-enforced state machine (draft → sent → paid), marking-paid that records a settling ledger event, and a public read-only pay-link a logged-out client can open.
Stripe on the pay-link, a webhook that records the payment to the append-only ledger idempotently, and a live URL — verified end to end.
profiles, collections and items under your own @handle — and RLS that makes 'private' provably private
cookieless anonymous reads + ISR + a per-collection OG card — and RLS, not a filter, hides the private lists
the S5 Stripe gate, applied to Shelf: private collections require Pro — enforced by a DB trigger, not the UI
robots + sitemap + a friendly 404, then a real deploy — where 'done' is the verified end state, not a tool saying OK
All-access opens all 56 modules from $24/mo and includes whatever is added while you are subscribed — access ends when you cancel. Or take a single module for $39, or lifetime access for $599 once, both of which are permanent.
See pricing