Here's a sentence from my German vocabulary app:
Tom rief Mary an.
It means "Tom called Mary", and the app shows it as an example of the verb anrufen, to call. Look at it again, though. "anrufen" isn't in it. The verb is split in two, the stem has changed its vowel, and Mary is standing in the middle.
Getting that right for 6,000 words and about 450,000 sentences turned out to be most of the work behind Wortnest, a free German vocabulary app I built while learning German myself. So instead of a feature tour, this post follows one word, anrufen, from the page where I first met it to the screen. Each stop is a decision, and I got a few of them wrong first.


anrufen starts as a line in the word lists at the back of my German course books. Those lists gave me the first 3,133 words, and that is all the books do here. The work starts after.
The line becomes a Word with the ID verb:anrufen. Nouns carry their article, so der See (lake) and die See (sea) are noun:der:See and noun:die:See, two different words.
There's no auto-increment and no row number. You can mark a word as known or to learn, and those marks are stored under this ID. If I add words and rebuild, row 412 might be a different word tomorrow, and someone's "known" would quietly move to a word they've never seen. An ID made from the word itself survives any rebuild. If two entries ever produce the same ID, the build fails on purpose.
A word list says which words matter, and not much more. Translations, pronunciation and full inflection tables come from Kaikki, a machine-readable dump of English Wiktionary. The German part is a 99 MB JSON Lines file, streamed line by line at build time.
For anrufen, Wiktionary adds what the next stop needs most: every form of the verb. ruft an, rief an, angerufen, anzurufen.
Example sentences come from Tatoeba, a collection of sentences written and translated by volunteers. It has about 785,000 German sentences. Around 498,000 have a direct English translation. After dropping very short and very long ones, pre-1996 spellings like daß, and a list of words I don't want in a learner's app, 451,029 are left.
Each one goes through spaCy's small German model, de_core_news_sm. This is its real output for our sentence:
Tom rief Mary an.
rief lemma: rufen pos: VERB dep: ROOT
an lemma: an pos: ADP tag: PTKVZ dep: svp → rief
The coarse tag calls "an" an ADP, the same as the preposition. The fine tag gives it away: PTKVZ is a separated verb particle, and the svp dependency points at the verb it belongs to. That pair is how the pipeline knows this "an" is the second half of anrufen.

The lemma is the weak spot. The small model got "rief" right here, but it often doesn't. It turns "isst" (eats) into "issen", which isn't a word. In "Rufst du ihn je an?" it decides "Rufst" is a proper noun, someone called Rufst. So the pipeline reads Wiktionary a second time, for every inflected form of every word, and maps each form back to its Word. That sentence is on anrufen's card anyway, with both pieces linked.
The result is stored as character spans, so the app can highlight both pieces:
{
"text": "Tom rief Mary an.",
"links": [{ "wordId": "verb:anrufen", "spans": [[4, 8], [14, 16]] }]
}
Then there's the rule that shaped everything else, written at the top of the linking module: a wrong link is worse than a missing one. A link tells a learner "this is how the word is used". If it's wrong, it teaches something false. A missing link only costs one example. So when a form could belong to two words and no explicit rule decides, nothing is linked. Some rules do decide. gehört is hören (heard) when a form of haben is in the sentence, and gehören (belongs) otherwise.
How do you know the links are right? In each review round, 200 random sentences are checked link by link. After fixing what a round finds, the next round uses a new random seed, because measuring again on the sample you just fixed is grading your own homework.
The first round found 11 wrong links out of 1,113, so 99.0%. After the fixes, a fresh sample gave 4 out of 1,082, 99.6%. It looked done.
It wasn't. 200 sentences say very little about a mistake that hits one small group of words. So I diffed the old and new rules over the whole corpus, every link that changed. That turned up possessive seine linked to Ihr (formal "your") in 5,231 sentences, and gehört sent to gehören in 1,172. Neither had shown up in a sample.
Since then a rule change comes with a corpus diff, and the review runs again after big changes. The latest round, on the full 6,000 words: 6 wrong and 2 missed out of 1,232 links, 99.5%. Half of the wrong ones are names, like the Los in Los Angeles. Two honest caveats. The reviews were done by Claude in a coding session, not by a native speaker. And known gaps stay known: weiß meaning white still links to wissen (to know) in about 39 sentences.
anrufen has more sentences than a card can show, so its card shows 30, easiest first. "Easy" is computed: each word in a sentence costs something by how common it is, from 0 for the most common to 4 for rare ones, and 5 for a word the app doesn't have, since you can't look it up. Names, numbers, pronouns and articles are free.
Taking the 30 easiest had a funny failure. The card for die Uhr (clock) filled all 30 places with "Uhr" and never showed the plural, "Uhren". So now every form takes a turn, round-robin. Rare forms like anrieft only get the places the common forms leave, so they can't push out "Ich rufe dich an".
The first version showed 200 words. They were picked by a hash of their IDs, so every build gave the same 200, and that was enough to get the card, the filters and the linking right before scaling up.
The first 3,133 words came from that course-book list. The rest came from wordfreq, a word frequency list, up to 6,000. Frequency lists are noisy: English words, names, slang. The rule that cleaned up most of it was simple. A frequency word with fewer than 3 example sentences gives way to the next candidate. 528 words were swapped out like that, mega and fake among them.
Those first words already had a level. The other 2,866 got one, estimated by an LLM from the word, its class, its translation and its frequency, and the app shows them with a ≈, as in "≈B1". It's an estimate, and it says so.
The pipeline writes two kinds of files:
lexicon.json with all 6,000 words, about 250 KB gzipped. The app loads it once.anrufen's file is 766572623a616e727566656e.json, which is verb:anrufen in hex. Plain IDs as file names would break on a Mac, whose disk is case-insensitive by default: pronoun:Ihr (formal "your") and pronoun:ihr (her) would be the same file.
The React app (Vite, TypeScript) only reads these files. There's no API call for word data and no database query. A service worker caches the word list, so once loaded the app works offline, and words you've opened keep their sentences. Your marks stay in localStorage. A small Fastify API with Postgres exists only to sync my own marks between devices.
The data build, pnpm data, takes about 40 seconds (the spaCy parse is cached under a hash of its inputs), runs every test and prints only what changed: words added, removed or changed. Two builds from the same input give the same files, and the input dumps are pinned by sha256. When "nothing changed" is the answer you expect, a report that says only that is the best review tool I've found.
All of this was invisible to search engines, because the app is one <div id="root">. So the build also writes a plain HTML page for every word that has sentences, like /word/anrufen/: the word, its forms, the 10 easiest sentences and a button that opens it in the app. No framework and no hydration. That's 5,540 pages and a sitemap, written by the same TypeScript functions the app uses to show a word, so the two can't drift apart. The 460 words without sentences get no page, since a page with nothing on it is noise.

Wortnest is free, has no ads and needs no account: wortnest.aliozendev.com. If you speak German, open a few words and look at the highlighted links. If one is wrong, I'd like to hear which. That's exactly the kind of mistake a 200-sentence sample misses.
And if you've handled lemmas for German strong verbs better than "read Wiktionary's tables", how did you do it?
Wortnest was built with Claude Code, which also estimated the levels and reviewed the link samples.