Bad machine translation is cheap until it ships

Nobody sets out to ship a bad translation. What happens is quieter than that: a team runs content through an engine, gives it a light review, sees fluent sentences come out, and reasonably concludes the job is done. The output reads fine. It goes live. Eight months later someone in the Seoul office mentions, carefully, that the onboarding flow is embarrassing.

By then the cost isn't a translation cost any more. It's a reprint, a release cycle, a polluted translation memory, and a market where the brand quietly underperforms for reasons nobody has connected to language.

This isn't an argument against machine translation. We use it, deliberately, where it earns its place — and we've written about exactly where that is. This is about the arithmetic on the other side: what it costs when the bet doesn't come off, and why that bill is so much larger than the saving that justified it.

1. Start with the saving, honestly

The discount is real. Post-editing a machine draft typically runs 30–40% below translating from scratch. But that discount applies to the translation line only — and translation is usually 55–70% of a localization quote, not all of it. Engineering, DTP, review and project management don't get cheaper because a machine wrote the first draft.

So on a programme quoted at $26,000, the honest saving from going MT-first is somewhere near $8,000. Worth having. Not worth very much risk.

Hold that number. We'll come back to it.

2. What "bad" actually looks like

The failure modes are specific and they repeat. In rough order of how expensive they are to discover late:

Notice what these have in common. None of them produce broken-looking text. Every one produces a confident, well-formed sentence that happens to be wrong.

3. Why nobody catches it in time

Human translation fails visibly. A translator out of their depth produces awkward phrasing, and awkward phrasing is a signal anyone can act on. Machine translation fails invisibly, because fluency and accuracy come apart. The surface is smooth whether or not the content underneath survived.

Three things then conspire:

• Post-editors anchor. Hand someone a fluent draft and ask them to fix it, and they fix words. They rarely tear down a sentence that already reads well to rebuild it the way they'd have written it from scratch. The cheaper the post-editing rate, the stronger this effect — you've priced the job so the only rational behaviour is a light touch.
• The reviewer usually isn't a linguist. In practice the check is done by a bilingual colleague doing a favour, or a regional sales contact with ten spare minutes. They catch typos. They don't catch a legal term that's 90% right.
• Nobody on the core team reads the language. This is the real one. The content is approved by people who cannot evaluate it, on the basis that it looks like the other languages, which also look fine.

So the defect ships, and the feedback loop runs through your customers.

4. Why the cleanup costs more than doing it properly

This is the part that surprises people. Fixing a bad localization is not the same job as doing it once, and it is not priced like it.

• You have to audit everything, including the good languages. You don't know which of your six locales are affected until someone qualified reads them. The audit is a cost you pay across the whole set to find problems in part of it.
• You can't post-edit your way out. When the problems are structural — register, terminology, scope — editing the existing text costs more than translating fresh, because the editor has to diagnose and unpick someone else's sentence before writing their own.
• Your translation memory is now contaminated. Every bad segment you approved is stored as an approved segment. Next quarter it comes back as a 100% match, gets charged at 25%, and nobody looks at it. The error propagates silently into every future project until someone cleans the TM — which is its own paid job.
• Everything downstream already consumed the bad text. The InDesign files were built. The app shipped. The manuals were printed. All of that gets redone at full price.

5. The arithmetic, on a real-shaped project

A 40,000-word product manual plus UI, into five languages. After match analysis, 32,000 weighted words per language.

• Human route, translation + revision @ $0.13 — $4,160 per language, $20,800 total
• MT-first route, post-edited @ $0.08 — $2,560 per language, $12,800 total
• Saved on the translation line: $8,000.

Two of the five come back weak. It surfaces after the manuals are printed and the release has shipped. The cleanup:

• Quality audit across all five languages, 6 hrs each @ $50 — $1,500
• Full re-translation of two languages, no TM leverage because the memory can't be trusted — $8,320
• Translation memory remediation, 8 hrs @ $55 — $440
• DTP rebuild, two languages × 120 pages @ $12 — $2,880

Cleanup total: $13,140.

You saved $8,000 and spent $13,140 putting two of five languages right. That's $5,140 underwater before the reprint, before the engineering time for a documentation release, and before you account for the months the wrong version was the only version your customers in those markets could read.

And note the asymmetry: it only took two locales going wrong out of five. The bet needs to come off almost everywhere to pay.

6. The costs that never appear on an invoice

Everything above is money you can see. These are the ones that don't show up in a line item:

• Support load. Documentation that doesn't match the product generates tickets, in a language your support team may also not read.
• Conversion. Hard to attribute cleanly, which is exactly why it goes unnoticed. A pricing page that reads slightly foreign doesn't produce complaints. It produces a conversion rate nobody questions because there's no local baseline to compare it against.
• Regulatory exposure. For medical devices, machinery, financial products and anything with a safety instruction, a mistranslation isn't a quality problem — it's a compliance problem with a different order of consequence. This is the tier where MT-first is simply the wrong tool, at any discount.
• Brand. We won't pretend to put a number on this. But the Korean user who finds your product stiff and slightly off doesn't file a bug. They just don't come back, and you never learn why.

7. Where machine translation genuinely earns its discount

Being fair about this matters, because the answer isn't "never":

• High volume, short shelf life, low stakes. Support knowledge bases, product feeds, internal documentation, user-generated content. Content where being 95% right at scale beats being 100% right on a tenth of it.
• Narrow, repetitive domains with an enforced termbase. If the vocabulary is controlled and the engine is constrained to it, the main failure mode is largely closed off.
• Gisting. Reading inbound content to understand it. Nobody is harmed by a rough draft used as a rough draft.
• As a genuine first draft with a genuinely funded review. MT plus a properly paid linguist is a real workflow. MT plus a review priced so low that only a light touch is rational is not a workflow — it's unreviewed machine output with a signature on it.

What stays off the list: UI strings, safety and legal content, anything regulated, anything going to print, and anything whose job is to make someone feel good about spending money.

8. Cheap insurance

None of this requires abandoning MT. It requires deciding where it's allowed, on purpose, before the content goes anywhere:

1. Tier your content in writing. Three tiers is enough: must be right, should be good, just needs to be understood. Assign a method to each tier once, and stop re-deciding per project.
2. Sample-audit before you scale. 500 words per language, read by an independent linguist against a simple error scale. It costs roughly $75 a language and it tells you which locales you can trust before you've committed 40,000 words to each of them. This is the single highest-return thing on this page.
3. Enforce terminology at the engine, not afterwards. Fixing terms in post-editing is paying someone to clean up a problem you could have prevented.
4. Quarantine MT output in your TM. Tag machine-origin segments so they can never silently return as approved 100% matches. If your tool can't do this, that's worth knowing now rather than in two years.
5. Put one native speaker in front of the running product before release. Not the file — the product. Four hours per language. Most of what matters is only visible in context.
6. Never let the printer be your QA step. If it's going to print, it gets a human pass. Paper is the one medium where a fix costs more than the original.

The short version

Machine translation moves cost rather than removing it. On the right content it moves cost out of the project and keeps it out. On the wrong content it moves cost downstream, where it compounds — into audits, re-translation, a contaminated memory, redone layout, reprints, and markets that quietly underperform.

The saving is visible on the quote. The bill arrives somewhere nobody is looking for it, denominated in things that are harder to count. Decide which tier each piece of content belongs to before you find out which kind you bought.