Flow Trainer

Comprehension, not memorisation

The best technical interviews don't test whether you already know a system. They test how fast you can learn one you've never seen, while someone watches. That's a different skill, and it doesn't show up if you only practise on a language you already know.

So I built a trainer around two query languages that don't exist anywhere else: FLOW, a pipe-based syntax that reads left to right, and NEST, a nested functional syntax where the innermost call runs first. Same dataset behind both, same set of operations behind both, completely different shapes. You can't memorise your way through it, because the second language forces you to relearn the operations from scratch in an unfamiliar grammar.

The trainer's first level in FLOW: a challenge card with a goal and expected row count, an answer editor, a language toggle between FLOW and NEST, nine level markers, and an operations reference where most operations are still locked

How it works

Both languages are real, not decorative. Each has its own interpreter running entirely in the browser (FLOW is a straightforward pipe-stage evaluator, NEST needed an actual tokeniser and parser for nested function calls), executing live against a small two-table dataset. Nine levels per language build the same arc: filter, then select columns, then sort and limit, then group and aggregate, then derived columns, then a join.

Three design choices do the actual teaching:

An always-open scratchpad next to every challenge. No target, no grading, just a place to test a hypothesis against the real data before committing to an answer. That's the behaviour a live interview rewards and a static tutorial never asks for.
A cardinality trap. One level asks a question that looks like it should be answered by joining through the transaction table. Go that way and you get a confidently wrong number, because the join inflates and drops entities with no transactions. The correct path starts from the entity table directly, the same grain-reasoning mistake that separates people who understand a data model from people who can just write syntax.
An undocumented operation. At level eight, a new function appears with no description. You have to test it blind in the scratchpad before you can use it, which is what actually happens when someone hands you a system with no manual.

Every submission is checked against the expected output, so any correct path passes, not just the reference one. But if your working answer took more steps than necessary, the trainer tells you and shows the leaner path: the same follow-up a sharp interviewer asks once you've already got the right answer, can you do that in fewer steps?

A correct FLOW submission: the query runs live, the result table renders the four matching rows, and the feedback line confirms the answer is already the lean path while another hypothesis sits in the scratchpad below

The point

Clearing all nine levels in one language isn't the finish line. The closing screen tells you to switch languages and do the whole thing again from scratch, because the skill being trained was never FLOW or NEST specifically. It's learning an unfamiliar system fast: say the hypothesis out loud before you test it, check a piece of it in the scratchpad, and never bluff past a gap you haven't actually closed.

Stack

Single HTML file, no backend, no dependencies. Hand-rolled interpreters for both languages, running entirely client-side.