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're 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've 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's 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.
Most quizzes tell you which option was right, which teaches you almost nothing. Here, picking a wrong answer explains what's wrong with that specific answer. The misconception you had is the one worth fixing.
You don't mark your own homework and you don't 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.
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.
A degree teaches you to write the program. It doesn't 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're expected to absorb it, and most engineers do, slowly and expensively, by getting it wrong in production. 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 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 how production behaves.
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. Everyone's assumed to have this
skill and nobody's taught it.
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 isn't done when it compiles. It's done when it's 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've spent my career in, and it's the course I'd 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 had to learn, arranged so someone can grow through them in order.
This is the foundations course, and it exists so a language gap can't 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, fix it first rather than
push through. It's also the gentlest starting point on the site if you've 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've never written a line of it. Arrays and vectors, then the mathematics that models are 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's no PyTorch here on purpose: you write the forward pass, the backward pass and an attention head in numpy. That's 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 190 findings, and it says so when it doesn't recognize what you gave it. One HTML file, no dependencies, and nothing you paste leaves your browser. That's the only way to build something people put production tokens into. Open authlint.
There's no enrollment and no fixed order, so the useful thing to say is what each course assumes you already have.
If a course claims an exercise is graded, that claim should survive being checked. Here's what enforces it.
Straight up. 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 execute for real (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's the ground truth.
Saying it myself is more useful than letting you find out three streams in.
The dojos are complete enough to learn from and not yet ready for launch, and the gap between those two is what alpha testers find. The alpha closes on Sunday 25 October 2026. Feedback that arrives before then goes into the launch; after that the list of names is final and the courses move to their first release.
I'm looking for 10 to 15 people, and the ask is small. Forty-five minutes on the first three lessons of any course, then tell me three things: what confused you, what bored you, and what the grader got wrong. Carry on if you want to, but that's the whole ask. I can't pay you, though I'm glad to return the favor with a code review, a career conversation, or an introduction. Interested? Write to roniamdev@gmail.com and I'll set you up, any time before 25 October. Every tester is credited on the home page and on the home screen of the course they tested, with a link if they want one, and anyone who catches a real defect is named on the fix itself.