Nine interactive courses that run entirely in your browser: no install, no build, no dependencies, no account, no tracking. Every lesson ends with an exercise you complete in the page, and it has to pass. They are free because the alternative was letting what I learned stay in my head.
Every one of these is a reaction to something that was done to me while I was learning, or something I watched happen to an engineer I was responsible for.
The fastest way to lose someone is to skip the step you have forgotten was ever hard. Every course starts before the beginning. If a lesson depends on an idea, that idea has its own lesson first, and the course tells you which one and links to it.
An idea arrives in words you already have. Only once you know what it is for does the notation show up, and then it shows up in full. Meeting the formula second is the difference between reading it and understanding it, and it costs nothing but ordering.
Most quizzes tell you which option was right, which teaches you almost nothing. Here, picking a wrong answer explains what is wrong with that specific answer. The misconception you actually had is the one worth addressing, and it is usually a reasonable one.
You do not mark your own homework and you do not click "I understand". SQL runs against real sample data, JavaScript executes in a sandboxed worker, Python runs in the page, and a build gate executes every reference solution against its own assertions before any of it ships.
Coverage is easy and ordering is hard. Identity Dojo teaches sessions and cryptographic trust before OAuth, because a protocol you meet before its problem is just a list of steps to memorize. That ordering is the part that took the longest to get right.
Each course builds to one self-contained HTML file with zero dependencies. Save it, put it on a USB stick, open it on a plane. Nothing phones home, nothing expires, and nothing asks for your email address. The source is public.
A degree teaches you to write the program. It does not teach you the rest of the job, and the rest of the job is most of the job. Nobody sits you down and explains how a commit becomes a running service, how to read a log file at 3am when something is on fire, or what to do in the first ten minutes of an incident. You are expected to absorb it, and most engineers do, slowly and expensively, by getting it wrong in production. That was worth building for deliberately, so a large part of this material is operational rather than academic.
Git: Beginner to Master (8 lessons), Build Tools: Maven & Gradle (6), Deploying Java to the Web (6) and CI/CD: GitHub Actions & ArgoCD (6). The whole path a change travels, rather than the part that happens in your editor.
Reading Production: the Command Line for Logs (6 lessons) is grep, awk, sed and jq pointed at a real log file, because the first thing anyone asks in an incident is what the logs say and the second is whether you can actually get an answer out of them.
Running Identity (10 lessons) in Identity Dojo is incident response, migrations and the 3am page. Failure-First: Distributed Systems (5) starts from the assumption that things fail, which is the assumption production actually operates under.
Three streams of it in JS Dojo (13 lessons): reading a stack trace properly, breakpoints
and the scope pane, the Network panel, tracing an OAuth redirect end to end,
node --inspect, heap snapshots and CPU profiles. It is the skill everyone is
assumed to have and nobody is taught.
System Design & Tradeoffs (5 lessons) and Time, Testing, Reflection & the JVM (6). Senior work is mostly choosing between two defensible options and being able to say why, which is a different muscle from making something work.
The entire cloud-native path, 80 modules across Docker, Kubernetes, Envoy and Istio, is hands-on on your own machine. You package it, orchestrate it, proxy it and mesh it, because reading about a service mesh teaches you nothing about operating one.
151 lessons and modules of it, which is roughly a quarter of everything here. Code is not done when it compiles. It is done when it is running, observable, and someone other than you can keep it alive.
Each one is self-contained. The only ordering that matters is the one below, under "where to start".
Identity & access management, sequenced so concepts are grounded before the protocols that assume them. OAuth 2.0/2.1, OIDC, SAML, WebAuthn/FIDO2 internals, Active Directory and Kerberos, zero trust, plus a Running Identity stream on incident response, migration and the 3am page. This is the field I have spent my career in, and it is the course I would hand to an engineer joining my team.
Software engineering end to end: Java & the JVM, data structures & algorithms, web & HTTP, React, APIs, Spring, databases & SQL, concurrency, DevOps, and a senior-level architecture track. SQL exercises run against real sample data in a from-scratch in-browser engine. It looks eclectic because a career is eclectic: this is the set of things I actually had to learn, arranged so someone can grow through them in order.
This is the foundations course, and it exists so a language gap cannot block you.
A good part of the graded work in Dev Dojo and Identity Dojo is JavaScript, alongside Java,
SQL and shell, so if JavaScript is unfamiliar the answer is to fix it first rather than
push through. It is also the gentlest starting point on the site if you have never programmed
at all. It assumes nothing: values and
types before anything that manipulates them, the call stack before closures, the event loop
before a single promise. Then modules and npm, TypeScript, the Node runtime, files and
streams, a secured HTTP server and a capstone. Three streams are devoted to debugging:
breakpoints and the scope pane, the Network panel, tracing an OAuth redirect end to end,
node --inspect, heap snapshots and CPU profiles. Every exercise runs for real:
671 executed cases.
Machine learning starting from Python itself, on the assumption that you have never written a line of it. Arrays and vectors, then the mathematics that models are actually built from: linear algebra, calculus and gradients, logarithms, and a probability stream that runs from counting through distributions, Bayes, maximum likelihood, expectation maximization and the bias-variance decomposition. Then the models: regression, the classifier zoo, clustering, neural networks from the perceptron to the transformer, and reinforcement learning from the bandit to the algorithm that fine-tunes language models. There is no PyTorch here on purpose: you write the forward pass, the backward pass and an attention head in numpy, because that is what makes them yours. Every lesson opens in plain English and ends at textbook rigor.
Five interactive courses. Start with the fundamentals (pure concepts, nothing to install), then get your hands dirty: Docker, Kubernetes, Envoy and Istio are hands-on, on your own machine, and each begins with a step-by-step local setup guide. Lab files and course source live in the repository.
authlint came out of Identity Dojo and is the short version of it. Paste any artifact from an authentication flow, decode it, and see the errors. A JWT, a SAML response or assertion, a discovery document, a JWKS or an authorization URL. About sixty checks, and it says so plainly when it does not recognize what you gave it. One HTML file, no dependencies, and nothing you paste leaves your browser, which is the only way to build something people put production tokens into. Open authlint.
There is no enrollment and no fixed order, so the only thing worth saying is what each course assumes you already have.
If a course claims an exercise is graded, that claim should survive being checked. Here is what enforces it.
Worth being straight about this. Most exercises are checked by regex against the shape of your answer: they verify you wrote the right construct, not that your code runs correctly. SQL and JavaScript genuinely execute (sample data and a sandboxed worker), Python in ML Dojo runs for real in the page, and Java compiles and runs if you start the optional local runner. Every exercise ships a Run locally panel with exact commands, and that is the ground truth.
Saying it myself is more useful than letting you find out three streams in.