natemoon.io
intuitiveorton.com ↗v2 in betaRole Sole engineerSep 2024 – now

Intuitive Orton

A literacy platform for tutors who teach reading with the Orton-Gillingham method, an approach designed for dyslexic readers.

Tutors assess students sound by sound, follow their progress, and run live lessons where they drive the student’s screen and watch them write. Underneath is the Lexicon, a computable model of English spelling. v1, on Next.js and Fastify, is the app in production. v2 is a full rebuild on a new architecture, deployed to production as a beta.

v2 code
~196K lines TS
v1 code
~60K lines TS
Decisions
46 ADRs
Corpus
1.5M entries in, 78K rows out
NestJS · PrismaSocket.IO roomsNext.js 16 · React 19Render · VercelOpenAI Responses APIWiktionary · WordNetHeadless Chromium PDFsOpenAPI codegen

Line counts are hand-written TypeScript in git, tests included; generated API clients, type declarations and a vendored codegen package are excluded.

Status · Nov 2026

Live
The marketing site and blog at intuitiveorton.com, and the v1 app it signs people up to: assessments, per-student mastery graphs and live whiteboard rooms. v1 tells its users a new app is coming and that it shuts down in early 2027.
In beta
v2 (web app, staff console, API and the realtime rooms service) is deployed to production by a GitHub Actions release workflow, first run on 4 Nov 2026, and carries a beta badge. The site’s sign-up button still goes to v1, and I don’t quote user numbers here.
Built, not shipped
The 66,987 words from the corpus are imported but not yet segmented, so they aren’t in front of students. Blends and glued sounds exist as entities with their member lists still to be authored. Progress tracking across assessments in v2 is a written spec. Spreading rooms over more than one realtime process is deliberately deferred until a capacity monitor says one process is full.

The problem

Orton-Gillingham (OG) is structured, explicit, cumulative phonics instruction. A tutor teaches the letter–sound code of English one piece at a time, in a fixed order, and reviews each piece until it is secure. It was built for dyslexic children and is still widely used with them.

To plan a lesson, a tutor needs to know, sound by sound, what a student has been taught, what they can read and spell, and which words practise exactly those patterns and nothing they haven’t met yet.

Why it is hard

The unit of teaching is the correspondence: a grapheme (a letter or letter group) that spells one phoneme (one speech sound). The grapheme igh spells the sound /aɪ/ in night: five letters, three sounds, n·igh·t. English maps these many-to-many. c is /k/ in cat and /s/ in city, and /eɪ/ is spelled a, a_e, ai, ay, eigh and more. Some graphemes are split: in mate the a and the final e together spell /eɪ/, written a_e. Some pairings are irregular and taught by heart, like ai in said.

So a word list isn’t enough. To pick practice words, the software has to know which correspondences each word uses, letter by letter. Asking a language model each time isn’t enough either: its answers change between calls and are sometimes wrong, and a tutor can’t check them. The tool needs a computable model of spelling that every answer is validated against.

System architecture

v2 is a TypeScript monorepo of four deployed apps and shared packages. The rule throughout: the server and the validator decide, and clients and the model propose.

Web app
Next.js on Vercel. Students, assessments, live rooms, and PDF reports printed with headless Chromium.
Staff console
Next.js on Vercel. Where the Lexicon is edited; runs the validator and the solver in the browser.
API
NestJS, Prisma and Postgres on Render. Owns users, students, assessments and the Lexicon, and publishes an OpenAPI spec that generates the typed client.
Realtime
NestJS and Socket.IO on Render. Holds live rooms in memory and trusts only room tickets signed by the API. No Postgres; its one outbound connection is the key-value store for checkpoints.
Shared packages
The validator and solver as plain ESM, and the room protocol's schemas.
Lexicon and corpus
Canonical JSON in git, moved in and out of each database by restore and export jobs. An offline build turns dictionary dumps into the words waiting to be segmented.

Key engineering decisions

  1. Model English spelling as data, with one validator everywhereThe same import-free validateWord runs in the admin editor, the API and the seed script, so every layer of a word must agree with its letters before it saves.
  2. Derive a word's pronunciation from its segmentsSounds and spelling can't disagree. When the corpus is wrong, the segments win and the word is re-keyed.
  3. A solver enumerates; the model only ranks or diagnosesEvery model answer is re-checked against the inventory, and nothing is saved without a person approving it.
  4. One process owns each live roomPure reducers, snapshots for late joiners, and checkpoints with a flush on shutdown, so a deploy keeps every room.
  5. Build the word corpus mechanicallyA deterministic build from 1.5M Wiktionary entries, checked against standard word lists and a hand-checked gold set.
  6. Version the curriculum in git with derived IDsIDs are identical on every machine, and a restore reports the reviews it would undo before it writes.

Try the segmentation solver: how a word gets its segments

port of packages/lexicon-validation/solve.js · the real inventory of 253 correspondences

Pick a word. The solver lists every way to split its spelling into correspondences from the inventory whose sounds join to exactly the word’s pronunciation. It runs in your browser.

night, /naɪt/: 1 valid segmentation

night
/naɪt/
1 valid segmentation
4 search states · 1.26 ms
ordered by fewest heart sounds (♥),
then fewest schwa sounds, then rarity
score (sum of ranks; 1 = most common)
1
n/n/igh/aɪ/t/t/
rarity 3
preferred
1 · Solver enumeratesEvery grapheme cover whose sounds join to exactly the known pronunciation, including split vowels like a_e, each checked by the same validator that guards a save.
2 · Model ranksWhen there are several, a model orders them and gives a reason a teacher can read.
3 · Or diagnosesWhen there are none, the solver’s furthest point goes into the prompt, and the model chooses missing correspondence, wrong pronunciation, or reject.
4 · Service re-checksEvery answer is validated against the inventory again. Nothing the model says is saved without a person approving it.

I ran this port and the production solver over all 66,987 queued words: the results are identical except for one 36-letter chemical name, where production stops at its 50-candidate cap. On the current inventory 46,182 words have exactly one candidate and need no model, 9,236 have several to rank, and 11,569 have none and would go to diagnosis.

The engine

The Lexicon: a computable model of English spelling.

The Lexicon turns the rules a reading tutor teaches into data the software can reason about. Each word is described in four layers: its segments (the correspondences it uses, in order), the sound units tutors drill as one piece, its morphemes (prefixes, roots and suffixes) and its syllables. Every layer has to agree with the spelling letter for letter. Assessments, blending boards and the word tools all read from this one model, so a rule fixed once is fixed everywhere.

Anatomy of a word: four layers, one spelling

schema: Word · WordSegment · WordMorpheme · WordSyllable · Blend · GluedSound
Spelling/kʌnstrʌktɪŋ/
c0
o1
n2
s3
t4
r5
u6
c7
t8
i9
n10
g11
Segmentscorrespondences, in decoding order
c/k/
o/ʌ/schwa
n/n/
s/s/
t/t/
r/r/
u/ʌ/
c/k/
t/t/
i/ɪ/
ng/ŋ/
Sound unitsblends and glued sounds, partial
str-3-letter blend
-ctfinal blend
ingglued sound
Morphemesmeaning, with origin
con-prefix
structroot · Latin
-ingsuffix
Syllablestype and stress
conclosed · unstressed
structclosed · primary
ingclosed · unstressed

Every unit shown exists in the inventory. The second segment uses o → /ʌ/, the Lexicon’s schwa correspondence for o (as in oven), because it falls in an unstressed syllable. The validator checks that segments, morphemes and syllables each cover all 12 letters exactly once and that the segments reproduce the word’s pronunciation. Blends and glued sounds sit on top once their member lists are authored: each must lie over exactly its member segments, in order. The example is illustrative: constructing isn’t in the Lexicon yet, though construct and constructed are in the queue.

50Phonemes29 consonants, 6 short vowels, 7 long, 6 r-controlled, 2 diphthongs
144Graphemesevery letter or letter group that spells a sound
253Correspondencesgrapheme → phoneme, ranked by frequency, each with an “as in” keyword, all human-reviewed; 70 are heart sounds (irregular pairings learned by heart, like ai in said), 17 have position rules
43 + 11Blends & glued soundsletter groups drilled as one unit (str-, -ct; ing, all), defined as ordered lists of correspondences; their member lists are still being authored
138Morphemes47 prefixes, 40 suffixes and 51 roots, roots tagged Latin or Greek; proposed by a model, awaiting review
6Syllable typesclosed, open, VCe, vowel team, r-controlled, consonant-le, each with stress
66,987Wordsqueued from the corpus, each carrying the pronunciation its segments must reproduce; not yet segmented
1Scope & sequencethe teaching order, versioned together with the inventory it points into
One grapheme spells one phoneme

The inventory never hides two sounds inside one unit. Blends like str- and glued sounds like ing are their own entities: ordered sequences of existing correspondences whose letters concatenate to the unit's text. Their pronunciation is derived from the members, never typed in.

ADR 0038
Nothing is authored twice

A word's pronunciation and irregularity are computed from its segments, so they can't disagree. A word that hasn't been segmented yet carries the pronunciation its segments must reproduce. If the corpus turns out to be wrong, the segments win and the word is re-keyed under its corrected pronunciation.

ADR 0032 · 0043 · 0044
Every layer is anchored to letters

Segments and morphemes both point at character indices, not just surface text. That one decision handles allomorphs (im- as a form of in-), elision (hope → hop in hoping) and doubling (running) without a special rule for each.

ADR 0006
One validator, three runtimes

validateWord is a pure, import-free module. The same physical code runs in the admin editor in the browser, in the NestJS API, and in the seed script, and it returns stable error codes such as SEGMENT_OVERLAP, MORPHEME_COVERAGE and SYLLABLE_STRESS.

packages/lexicon-validation · validateWord has 35 issue codes
Rooms where the server holds the truth

Devices send commands; one server process decides what happened. Live in the v2 beta.

Each classroom activity is a pure reducer, a side-effect-free function (state, command, actor) → events | reject, registered as a plugin. The server checks the sender’s role and the command’s schema first. A device that joins late or reconnects gets a snapshot of the current state in one message, not a replay of every past event.

One process owns each room and checkpoints it to key-value storage at most every 2 s, with a full flush on SIGTERM, so a deploy keeps every room. The one high-frequency stream, a stroke in progress, is validated and relayed without being reduced; a stroke’s start and end still go through the reducer, so a snapshot holds every finished stroke.

Before choosing this I compared how Figma, tldraw, Liveblocks, Discord and Slack hold room state. Each pins a room to a single owner rather than sharing it across stateless servers.

apps/realtime/src/core · ADR 0016 · 0017 · 0039 · docs/research/realtime-scaling.md
A deterministic corpus from 3.4 GB of Wiktionary

Every queued word's pronunciation comes from a rebuildable pipeline, not from hand entry or a model.

The build reads 1,499,161 entries from the Kaikki dump of English Wiktionary and joins them with Open English WordNet and wordfreq. A versioned table normalizes each IPA transcription (the International Phonetic Alphabet dictionaries use to write sounds) to the Lexicon’s 50 phonemes. Two builds from the same inputs produce identical files, and a manifest records each source’s size and ETag and the table’s hash.

It produced 78,158 spelling–pronunciation rows; 0.33% contain a sound outside the phoneme set. It covers 312 of 315 Dolch words and 995 of 1,000 Fry words (the standard high-frequency word lists of early reading instruction). The misses are contractions like don’t and words Wiktionary transcribes only in British English. A gold set of 77 hand-checked spellings runs as the test suite.

packages/lexicon-corpus · manifest.json · docs/plans/word-corpus.md
The model is evidence, not authority

The model only chooses among answers the solver proved valid, or names one of three fixes.

The segmentation advisor (steps 2 and 3 of the pipeline above) calls the OpenAI Responses API with strict JSON-schema outputs. For a diagnosis the whole inventory goes first in the prompt, as the same bytes for every word, with a prompt_cache_key, so OpenAI can serve that prefix from its prompt cache from one word to the next. Cached tokens are logged on every call.

The retries are my own, with exponential backoff and the SDK’s retries off. A refusal or a truncated answer becomes a typed error, and the editor keeps the solver’s order. A “missing” correspondence that the inventory already has is rejected before anyone sees it. The service persists nothing.

Status: the solver and advisor are in the staff console of the current production release. The 66,987-word queue they serve has not been worked through yet.

apps/api/src/modules/language/segmentation-advice · ~750 lines of specs
Curriculum data with real version control

The curriculum is diffable data, and no ordinary edit can undo a human review.

The Lexicon lives as canonical JSON in git. Row IDs are uuidv5(entity + naturalKey), a UUID hashed from the row’s identity, so the same word has the same ID on every machine and in every database.

A restore replaces the whole language graph in one transaction. It first reports what it would erase or un-review, then asks you to type yes; --dry-run reports and touches nothing. Against production it runs as a manual GitHub Action that defaults to a dry run.

Ordinary API writes only move a row’s review state toward human-reviewed. Going back takes a deliberate act: re-flagging a single correspondence, or restoring an earlier version.

ADR 0004 · 0010 · lexicon/ · apps/api/prisma/lexicon/restore.mjs
Next case studyConvo →Live group chat that runs in episodes. A creator goes live, followers get a push, and the room fills in seconds.
Contact

Hiring a senior or staff engineer?

I’m looking for senior and staff roles where system design, production ownership and AI-native engineering matter, especially at companies building with frontier models. Email is the fastest way to reach me.

Email meResume (PDF)
Email
nathaniel.c.moon@gmail.com
GitHub
github.com/nathanielmoon ↗
LinkedIn
in/nathanielmoon ↗