How it works

What we don't fix automatically (and why)

A raw machine-translation tool will rewrite anything you point it at, confidently, whether or not it actually knows the answer. That's the opposite of what you want from an audit you're paying for. Here's the specific discipline we build into the pipeline to avoid it — and what happens instead when we're not sure.

Published by the Localization Audit team · 2026-07-21

The failure mode we're avoiding

Ask most translation tools to fix a truncated sentence, an internally contradictory legal clause, or an ambiguous term, and they'll produce something fluent-sounding anyway. Fluent is not the same as correct. On a page a shopper reads for five seconds that's a minor risk; on a returns policy or a payment clause, a plausible-sounding wrong answer is worse than an obviously untranslated one — it looks trustworthy while being wrong.

The rule: flag it, don't guess it

Every sentence our pipeline reviews gets an explicit confidence call, not just a rewritten output. If a source sentence is cut off mid-word by a scraping artifact, or a clause reads as internally contradictory, or — on newer-market audits — a rewrite doesn't clear our own fluency self-check, it gets marked low-confidence and surfaced separately in the report instead of being silently folded in next to everything else.

This isn't a marketing claim about "human oversight" — it's a field on the actual decision record our pipeline produces for every sentence, carried through into the final report as a distinct callout. It's the same reason we caught our own bug during Danish-market testing: a report title that was hardcoded to say "NL/BE" even on a Danish run would have been an obviously wrong thing to ship silently, so the discipline of checking rather than assuming caught it before a report went out with the wrong market name on it.

What this looks like in practice

• Truncated content: a product description cut off by a crawler artifact gets flagged for the client to confirm the original text, not completed with a guess.
• Ambiguous legal clauses: a returns clause that reads as self-contradictory gets flagged for a human read against the original, not "cleaned up" into whatever reading seems most likely.
• New-market fluency: on markets we've just added support for, every rewrite decision is checked against a native-fluency rubric before it's allowed into a report; anything that doesn't clear it is marked low-confidence rather than passed through.
• Unverified public claims: the same discipline applies to what we publish, not just what we deliver in a paid report — see the honest caveat in our Danish-market piece, where we say plainly that the rewrite rubric isn't yet validated against a live Danish audit, rather than publishing a finished-sounding list before it's earned.

Why this is the trade-off we want

A shorter report you can trust completely beats a longer one you have to double-check line by line. The whole value of paying for an audit instead of running your copy through a translation tool yourself is that someone — and something — actually checked. If we can't stand behind a specific line, we say so, instead of hiding it inside something that reads fine.