Hand you a problem you've never seen, and you name the pattern, write it correctly in Go, and say what it costs — while someone watches.
Which pattern? One tap.
“Return the k largest scores from a stream of a million results.”
By the end you can hold all three rounds: the coding problem, the “so how does that actually work?” follow-ups, and a system-design interview you steer yourself. Taught in Go, because Go shows the mechanism Python hides — interview in whatever language you like. Why that works →
One payment · no subscription · every future module included
Given a sorted array of integers, return the indices of two numbers whose sum is closest to a target.
Read it, name the pattern, write the Go, run it in the page, see why it works. Then the design round, on a 45-minute clock.
Understanding the algorithm was never the hard part. Writing it correctly, in twenty minutes, while someone watches, is — and that is the thing this trains.
A cold problem statement stops being a blank page. You hear the phrase that gives the pattern away, and you know which structure it wants before you write a line.
how · Problem → pattern index, clue callouts in every module
From nothing but a signature, you produce working code, say what it costs in time and space, and already know the off-by-ones and aliasing traps that usually sink people.
how · Cold-start exercises you write and run right in the page, then get reviewed
You ask the questions that surface the real requirements, put numbers on the design, name the two or three decisions that matter, and stay steady when the interviewer changes the constraints.
how · 19 mock interviews with scripted curveballs, scored at Senior and Staff+
Hash maps, B-trees, schedulers and compilers stop being black boxes. When an interviewer asks why, you have the mechanism, not a shrug.
how · The Broader CS track
What you learned in week one is not gone by week eight, because the key point of every module came back to you on a schedule.
how · Built-in spaced repetition
It's a narrow target on purpose. The course assumes a lot, and that's what lets it go deep.
Each one exists so that a part of the interview has already happened to you: the cold problem, the code under a clock, the “why?” follow-up, the design curveball, and remembering it all weeks later.
Every structure and algorithm is a step-through animation you scrub frame by frame — pointers moving, a tree being walked, a request flowing through a system. Not decoration; the actual mechanism.
Each module ends with exercises that start from nothing but a signature. The code ones you write in an editor on the page and run against the worked example, in your browser, with nothing to install. Then copy the check-prompt with your code into a fresh AI chat: it finds your failing input, states your complexity, and flags what isn't idiomatic Go. An interviewer with infinite patience, at 11pm.
The 19 case studies each generate a prompt that turns a fresh AI chat into your interviewer — it withholds the requirements until you ask, throws scripted curveballs, and runs you against a 45-minute clock. Pick who runs it: the silent one who steers you nowhere, the rusher who cuts you off, the sceptic who wants a number for every claim. A second prompt then scores the transcript in a clean chat, at both the Senior and Staff+ bars, so the model that coached you isn't the one marking you.
The key point from every module becomes a flashcard on an SM-2 schedule. What you learn in week one is still there on interview day — which is the entire problem with cramming.
Two dedicated indexes map the phrases you actually see in a problem statement to the structure or building block they imply. Reading the problem correctly is most of the interview, and almost nobody trains it.
Go shows the mechanism Python hides: you write the binary search instead of importing it. Build each structure once in a language that shows its work and you write it more correctly in every language afterwards.
Why we teach in Go →81 modules — this isn't a course that fills itself in later. 192 exercises, 19 mock-interview drills, and about 30 hours of lessons before you count the time you spend actually writing code.
After itTake a problem you have never seen from statement to working Go: pattern named, edge cases tested, complexity stated.
Turn concepts you already understand into correct, idiomatic Go under pressure — and learn to read a cold problem and know which pattern it wants.
After itAnswer the “but why?” follow-up: what a hash table, B-tree, scheduler or query planner is actually doing.
When the interviewer asks how it actually works, you have the mechanism, not a shrug: the structures databases and runtimes are built from, the proofs behind the patterns, concurrency, performance, operating systems and compilers.
After itDrive a 45-minute design interview: clarify, estimate, name the decisions that matter, and hold up under curveballs.
The method, the building blocks, and 19 full case studies. Each turns a fresh AI chat into an interviewer you choose — silent, rushed, sceptical — then scores the transcript in a second chat at the Senior and Staff+ bars.
The part that turns “I understand this concept” into “I can write it correctly, fast, while someone watches.”
I've been on both sides of the interview table: I've passed Senior-level coding and system-design loops, and I've run them as the interviewer and sat in the calibration afterwards. This course is the preparation I wanted and couldn't find — the translation from concept to correct code under pressure, plus the judgment to read a cold problem and know what it's asking for.
No résumé theatre. The two free modules, the free mock interview and the walkthrough above are the evidence — read them before you decide.
Two full modules with their exercises, a complete system-design case study you can run as a mock interview, and the reference pages the course is built around. No email, no signup.
Lifetime access. Every future module included, no extra charge.
£39 for the first 100 buyers, then £69.
Secure checkout via Lemon Squeezy · 2 full modules + a mock interview free to try first
Already bought it? Unlock with your licence key
What you're paying for is the ability to write it cold, and the judgment to know what to write. Concretely:
No. Go is the teaching language, not the answer language. It's used because it puts the mechanism back on the page — you write the binary search instead of importing it, and you can see when two slices share memory. Build each structure once in Go and you'll write it more correctly in Python, Java or C++ afterwards, which is where most readers actually interview. You don't need Go installed either: the samples are static reference, and there's a one-click Go Playground link for running your own solutions.
You should — and this course tells you exactly how, because that's the best use of an LLM there is: patient, specific feedback on the code you actually wrote, at 11pm, as many times as you like. What it won't do is decide what you should learn next, notice that you got heapify wrong three weeks ago and put it back in front of you today, or hand you a scrubbable animation of two pointers converging. It also won't tell you when its own answer is subtly wrong on a complexity bound or an off-by-one — and while you're still learning the material, you can't check it. This is the curriculum, the memory, and the verified reference. Bring your own tutor.
Yes. All 81 modules are written and available today — roughly 30 hours of lessons, 192 exercises and 19 mock-interview drills. "Future modules included" means additions on top of that, not the rest of the course arriving later.
About 30 hours of reading, and considerably more if you actually do the exercises, which is the point. Alongside a job, plan on a couple of months, with the spaced-repetition review holding what you've covered. You'll know you're ready when you can open an exercise you haven't seen, name the pattern in the first minute and pass the example without opening a hint, and when a mock interview's curveball makes you re-estimate instead of freeze.
No. One payment, lifetime access, and every module added later is included at no extra cost.
Engineers who can already code and understand the concepts, but want (a) fluency turning them into correct Go, and (b) the judgment to read an unfamiliar problem and know which pattern or building block it wants. It targets the Senior-to-Staff bar.
Any current frontier model, and the free tiers are fine — the prompts name no vendor, so Claude, ChatGPT or Gemini all work. They are written and checked against Claude, which is what I would reach for. The course gives you the exact prompt to paste; the site itself sends nothing anywhere, and your code never leaves your machine except when you choose to paste it.
Try the two free modules and the free mock interview first — they're complete, with working exercises and the full drill, not teasers. That's deliberately the trial, and it's why there's no automatic refund on a digital product you can evaluate in full beforehand. If something is genuinely wrong, email [email protected] and I'll sort it out.
Checkout and payment run through Lemon Squeezy, which is the merchant of record and handles all sales tax / VAT. The site never sees your card details.
These are the same React components the course renders — the diagram scrubs, the exercise grades, the prompt runs. Try them.
step 1: 1 + 11 = 12 — too big. Pull the right pointer in.
45-min clock · 6 phases · 4 curveballs · 11 facts withheld
Three levels of why, on everything.
[]int, move every 0 to the end while keeping the relative order of the non-zero elements. Do it in place, in O(1) extra space. Example: [0, 1, 0, 3, 12] becomes [1, 3, 12, 0, 0].func moveZeroes(nums []int) {// in place; keep the order of the non-zeros}