A 100% match came back to me last week that I'd have failed on sight if I'd typed it fresh. It sailed through as a locked, pre-translated segment — no charge, no review, green checkmark. The only reason I caught it is that I remembered writing the ugly thing myself, three projects ago, at eleven at night, for a different client with a different tone. The tool did exactly what it was told. It served me back my own mistake and called it a saving.
That's the part of QA that gets no attention. We test the file. We run the batch checks, we chase the false positives, we argue with the checker about whether a genitive suffix is really a spelling error. Meanwhile the thing actually deciding half the output — the translation memory — sits underneath the whole job, unaudited, treated as ground truth because it happens to be old.
The memory is not a fact, it's a habit
For a widely-served language, the TM is a crowd. Dozens of translators, revisers, and clients have passed through it, and the sheer volume smooths out individual bad calls. For Turkmen it's usually one person. Me. So the memory isn't a shared standard — it's a diary of my choices, including the ones I've since changed my mind about.
That matters more than people think. Terminology drifts. Five years ago I might have rendered a UI term one way; a client later insisted on another; a third project pulled from the first TM and reintroduced the abandoned term as a clean 100% match. Nobody flagged it, because a 100% match by definition raises no flag. The tool assumes that if the source is identical and the target already exists, the target is correct. For a single-vendor language that assumption is only as good as my worst night at the keyboard.
Context matches — Trados calls them ICE, memoQ has its own flavor — are supposed to fix this by requiring the surrounding segments to match too. They help. They don't help when the same short string means two different things in two different products and the surrounding segments happen to be boilerplate. "Apply" in a settings screen and "Apply" on a job form are the same source and the same neighbors. The memory doesn't know the difference. I do, and only if I'm looking.
Fuzzy discounts pretend the change is small
Here's where the grid actively works against Turkmen. Fuzzy match percentages are computed on surface characters. Turkmen is agglutinative — meaning changes ride on suffixes, and a single suffix can flip a whole clause. A source segment that's 95% identical can require a target that's rewritten past recognition because the one changed word governs case and agreement across the sentence.
So I get a 95% match, a discounted rate, and a target I have to demolish. The reverse also happens: two segments that look 80% similar to the algorithm need almost no change from me, because the difference is a proper noun the tool got scared by. The percentage is measuring the wrong thing. It measures how the strings look, not how much work the target needs. For English pairs the correlation is loose but usable. For Turkmen it's noise dressed up as a number, and that number sets my pay and skips my review.
What auditing the memory actually looks like
I've started treating TM maintenance as billable work and saying so out loud, because the alternative is compounding rot. A few things that pay for themselves:
Run QA against the memory, not just the file. Most tools let you QA a TM export. Do it. You'll find inconsistent terminology, orphaned tags, double spaces baked into a hundred segments, target strings that got saved with the source's punctuation. It's grim reading. It's also the cheapest quality win available.
Don't blindly lock 100% and context matches on a first job for a client whose TM you inherited. An inherited memory is a stranger's habits, and possibly a machine's. I'd rather read those segments and charge a token rate than certify someone else's guesses under my name.
Keep terminology in a termbase, not just in the TM. The TM remembers whole segments; it doesn't enforce a term the way a termbase check does. If the settled word for a concept lives only inside old segments, the drift never stops. Pull it out, define it, let the checker actually catch violations.
Version the memory per client and per product. One giant TM feels efficient. It's how the settings-screen "Apply" ends up on a job form. Separate memories cost a little organizational overhead and save you from cross-contamination you'll never notice until a client does.
The uncomfortable truth is that for a language with one supplier, the TM isn't quality assurance. It's memory in the plain sense — it remembers whatever I put in, including the tired, the rushed, and the since-revised. The tool trusts it completely. That's precisely why I can't.