There's a pattern in every company that operates across borders. The English documentation is solid. The German version is three months behind. The Japanese version was translated once, by a contractor, and nobody has touched it since. The Brazilian Portuguese version doesn't exist yet, even though São Paulo is the fastest-growing office.
Everyone agrees this is a problem. Nobody has a good solution. Until now, localisation has been treated as a project — a one-time effort you budget for, execute, and then quietly neglect until the next big overhaul.
That approach is broken. Here's why, and what actually works.
Translation is not localisation
Let's get the terminology straight. Translation is taking text in one language and producing equivalent text in another. Localisation is making knowledge work in a specific market. They overlap, but they're not the same thing.
A translated document reads correctly. A localised document reads naturally. It accounts for cultural context, regional regulations, local tooling, and the way people in that market actually work.
This distinction matters because most documentation platforms treat localisation as a translation task. You write in English, press a button, and get output in French. Done. Except it's not done, because:
- The French team has a different deployment process that the English doc doesn't cover
- German compliance requirements add an extra approval step that doesn't exist elsewhere
- The Japanese office uses a different internal tool for the same workflow
- Brazilian Portuguese readers need context about local tax rules that aren't relevant anywhere else
A straight translation of the English doc is technically correct in all of these cases, and practically useless in all of them too.
The problem with document-level translation
Traditional localisation works at the document level. You have an English document. You translate the entire thing into German. When the English version changes, you send the entire thing for retranslation. This creates three problems:
1. It's expensive
If your onboarding guide has 15 sections and you change one paragraph, you're paying to retranslate all 15 sections. Multiply that by 8 languages and every edit becomes a budget conversation.
2. It's slow
Sending complete documents for translation takes time. Even with modern machine translation, the review cycle for a full document is significantly longer than reviewing a single changed section. Teams in other languages are always running behind.
3. It doesn't support unique content
This is the real killer. If the German version needs an extra section about DSGVO compliance, where does it go? In a document-level translation system, any content added to the German version gets overwritten the next time someone retranslates from English. The German team learns fast: don't add anything, because it'll be wiped out.
Block-level localisation: a different architecture
Rasepi doesn't translate documents. It translates blocks — individual paragraphs, headings, and sections — each tracked independently with its own identity and content hash.
Here's what this means in practice:
When you edit a single paragraph in English, Rasepi detects which block changed by comparing SHA256 content hashes. Only that one block is sent for translation via DeepL. The other 14 blocks in the document stay exactly as they were. Your translation cost drops by up to 94%.
When the German translator needs to add a DSGVO section, they add it as a new block in the German version. That block exists only in German. It doesn't affect the English source. It doesn't get overwritten when English changes. It's flagged as unique content so everyone knows it's intentional.
When the Japanese version needs a different structure — say, a numbered list instead of bullet points because that's the convention in Japanese technical writing — the translator can change the block type. The system tracks this as a "structure adaptation" and preserves it across future updates.
Each language version becomes a first-class document, not a shadow copy.
How it works, technically
Every block in Rasepi has:
- A UUID that persists across all edits and translations
- A content hash (SHA256) that changes when the text changes
- A position index so blocks stay in the right order
- A soft-delete flag so removing a block in English doesn't break alignment in other languages
When a translation block is created, it stores the source block's content hash. On every save, the system compares hashes. If they match, the translation is current. If they don't, the translation is marked as stale — and only that specific block needs attention.
This is the mechanism behind the 94% cost reduction. Most edits change one or two sections. The rest of the document, across all languages, stays untouched.
Unique content per language
This is where things get genuinely different from any other platform.
In Rasepi, each language version can contain:
- Translated blocks — direct translations of the source language, tracked for staleness
- Unique blocks — content that exists only in that language, added by the local team
- Structure-adapted blocks — same source content, different formatting or block type
A single document might look like this across languages:
| Block | English (source) | German | Japanese |
|---|---|---|---|
| 1 | Introduction | Translated | Translated |
| 2 | Setup steps | Translated | Structure adapted (numbered list) |
| 3 | — | DSGVO compliance (unique) | — |
| 4 | Deployment | Translated | Translated |
| 5 | — | — | Local tooling note (unique) |
| 6 | Troubleshooting | Translated | Translated |
Every team gets exactly the documentation they need. No compromises. No workarounds. No one-size-fits-all limitations.
Freshness tracking across languages
Each language version tracks its own freshness independently. The English source might score 94 (recently reviewed, all links valid, high readership). The French version might score 71 (two stale blocks, one broken link specific to the French content). The Japanese version might score 88 (all translations current, but readership is declining).
This per-language freshness tracking means:
- You know exactly which languages need attention
- Stale translations are surfaced automatically, not discovered by accident
- AI tools can factor in language-specific freshness when serving answers
- Dashboards show content health broken down by language, not just by document
The business case
Companies that operate across languages face a simple reality: your documentation is either an asset or a liability in every market you serve.
When your Berlin team is working from a German translation that's three months behind the English source, they're making decisions based on outdated information. When your Tokyo office can't add local context to shared docs because the translation system would overwrite it, they stop using the wiki and create their own shadow documentation. When your São Paulo team doesn't have docs in Portuguese at all, onboarding takes twice as long.
The cost isn't just translation fees. It's:
- Slower onboarding in non-English markets
- Duplicated effort as teams maintain parallel documentation in local tools
- Knowledge silos that form when the official wiki doesn't serve everyone
- Compliance risk when region-specific requirements aren't captured
- Lost trust in the documentation system itself
Block-level localisation solves all of these, not by making translation cheaper (though it does), but by making every language version a living, maintained, trustworthy document.
Getting started
If you're running a multilingual team on any documentation platform today, here's a quick gut check:
- Pick your most important document. Check it in every language. Is each version current?
- Ask your non-English teams: do they trust the translated docs? Do they use them?
- Look for shadow documentation. Are teams maintaining local wikis, Notion pages, or Slack pinned messages because the official docs don't serve them?
- Calculate your translation spend. How much are you paying per update, and how much of that is retranslating content that didn't change?
If the answers are uncomfortable, you're not alone. Most companies don't discover the gap until it causes a real problem — a compliance issue, a botched deployment, a new hire who spent two weeks following outdated instructions.
Multilingual knowledge isn't a nice-to-have. For any company that operates across borders, it's the foundation of how teams align, make decisions, and ship. The question is whether your documentation platform treats it that way.
Every language deserves to be a first-class citizen in your knowledge base. Not a copy. Not a shadow. A real, maintained, trusted document.
That's what Rasepi delivers. Block-level translation, unique content per language, independent freshness tracking, and a 94% reduction in translation costs. All automatic. All from day one.