Discuss your task

Search

Start typing to search articles, cases, and services.

↑↓ navigate Esc close

How to Manage Content Translation in a CMS Without Chaos

Content translation in a CMS stops falling apart once three conditions are met: the language versions of a page are linked to each other at the data model level, every version carries a translation status, and an edit in the source language automatically marks the translation outdated. Without those three elements the second language version starts falling behind within the first few months, and nobody on the team can say which pages are already out of date. Everything else comes down to who translates and in what order the versions ship.

Across multilingual projects at Exceltic.dev we keep seeing the same gap. The technical side is done correctly: hreflang is in place, URLs are split by locale, the sitemap is built with alternates. The editorial side is documented nowhere - translation gets done by whoever happened to have time that week.

The design of the content management systems themselves makes it worse. The Strapi documentation states it directly: content is edited and published one locale at a time (Strapi Docs). Keeping versions in sync is not a CMS setting, it is a rule inside the team.

The technical markup of translations for search engines - hreflang, x-default, URL structure - we covered separately in the piece on a multilingual site on Astro and Next.js. This is a different layer: not how to tell a search engine about a translation, but who produces it and in what order the versions ship. Below are three working models for translation, the requirements for the data model, and the release order.

The failure looks almost identical everywhere. A site launches in two languages, both versions complete and current. Six months later the Russian one is three releases ahead: two new service pages, a rewritten pricing section, four updated articles. The English one knows nothing about it, and the only way to find out which pages have drifted is to compare them by hand.

Locale: a combination of language and region (ru-RU, en-US) for which the CMS stores a separate set of field values for one and the same page.

Why the second language version falls behind within six months

The second version falls behind not because of the volume of work, but because the translation has no owner. It is almost never assigned to a specific person with a specific deadline and gets done “when there is time”, which means never.

Then the drift mechanics kick in. An edit in the source language takes ten minutes and ships right away, while translating that same edit requires filing a ticket, waiting, and proofreading - so it gets postponed. Over a quarter, several dozen such edits pile up.

The second source of lag is that the problem is invisible. In a CMS without a translation status, an outdated English page looks exactly like a current one: published, all fields filled in, opens fine. The only way to know the text has drifted from the original is to remember it.

The third is priority. Traffic and leads come from the main language, and an edit there always feels more urgent. Translation loses that competition for as long as it stays a separate task instead of a mandatory step in the release.

Three models for content translation in a CMS and how they differ

There are three workable models, and the choice between them is driven not by budget but by how often the content changes.

The team translates in the CMS itself. Cheap, terminology stays under control, no external access needed. It works while there are few edits: translation competes with the marketer’s core tasks and loses to them. A reasonable ceiling is a few changed pages a month.

An external translator with CMS access. Faster, and it does not eat the team’s time, but it requires configured roles: the translator sees and edits only their own locale and has no publishing rights. Without that, unfinished text reaches the live site sooner or later.

Export and import through files or a translation service. Content leaves the CMS as a structured file, comes back translated, and is loaded back by field identifiers. The only model that scales to four languages and beyond, and the only one where translation memory works.

Translation memory: a database of previously translated fragments from which the service inserts a ready variant when the same text comes up again.

The price of the third model is infrastructure: export, import, and a strict binding of translated values to field identifiers. If identifiers change when the structure is edited, loading the translation overwrites the wrong fields, and that gets discovered on the live site.

What the CMS itself needs so the process does not break

The minimum set is three things: separation of values by locale, a link between a page’s language versions, and a translation status. Without any one of them the process rests on people’s memory.

Separation of values is implemented in two ways. The first is separate fields per locale inside a single document: the editor sees the original and the translation side by side. The second is a separate document per locale linked by a shared identifier: harder to set up, but locales can then have different structures and their own publishing cycle.

In Strapi, localization is enabled both at the content-type level and at the level of an individual field - some fields can be left shared across all languages. In other headless CMS platforms the choice comes down to the same pair of options, differing only in how deep the built-in support goes; check the implementation against the documentation of the system you pick (Strapi, Sanity).

The link between versions is a field that stores the identifier of the source document. That is exactly what makes it possible to build hreflang, the language switcher, and a report on untranslated pages.

Translation status: a field on a language version that shows whether its text is current relative to the present version of the source language.

A simplified field set for linking versions
{
  "_type": "page",
  "locale": "en-US",
  "translationOf": "page_a1b2c3",
  "sourceUpdatedAt": "2026-09-14T10:20:00Z",
  "translationStatus": "outdated"
}

If the site is still being designed, these three elements go into the schema right away - reworking the data model on live content is noticeably more expensive. We covered this layer using the example of an Astro and Sanity site architecture and in the description of a new site on a headless CMS.

What to do with pages that are not translated yet

An untranslated page is a decision you make once and write down. There are three options, and their consequences differ.

Show the default language text. The /en/ URL opens but contains Russian text. The user gets working navigation, the search engine gets a page whose language does not match what was declared. Google’s guide on localized versions states it directly: versions count as duplicates precisely when the main content has been left untranslated (Google Search Central).

Hide it from navigation while keeping the URL reachable. The most common choice and the one whose consequences are hardest to notice: the page exists, but there are no internal links to it. It gets into the index through the sitemap and lives there as an orphan.

Return a 404. Honest toward the user, but it breaks external links and the expectations of the language switcher. If the translation existed earlier and was then taken down, a 301 to an available version is more correct.

A working rule: a localized URL appears together with the translation, not before it. Until then the language switcher points to the section or the home page of the relevant locale. The untranslated URL goes into neither hreflang pairs nor the locale’s sitemap - Google ignores the tags entirely anyway if the two pages do not reference each other reciprocally.

A release order that keeps versions from drifting apart

The order exists for exactly one reason: so that version drift is caught by the system rather than by a person six months later. Four steps cover it.

1. An edit in the source language marks the translation outdated

The one item that has to work without human involvement. The modification date of the source document is compared against the modification date of the translation, and on a mismatch the translation status switches automatically to “outdated”.

2. The translation is proofread before publication, not after

Proofreading is done by a native speaker or by the person responsible for the market. Product terms, plan names, prices, and legal wording get checked - those often differ between countries more than the text itself does.

3. Both versions ship together or with a declared lag

Releasing several locales in a single action from the CMS interface is usually not possible, so “together” means a window: the same day or the same working week. If synchronicity is impossible, the lag is fixed in writing - for example, the translation ships within five business days.

4. Regular reconciliation runs off a report, not off memory

Once a month or once a quarter, pull a list of pages with the “outdated” status, sorted by traffic. Pages with traffic get fixed first, not everything at once.

On a typical project of 60-80 pages with two locales, the first reconciliation uncovers drift on roughly 15-25% of pages - this is an estimate from comparable projects, not a figure measured on your site. Working through it takes one to two weeks of a translator’s time, after which the load drops to a few pages a month: drift gets caught by status right away.

Common mistakes

  • Translating only the page body and forgetting title, description, and Open Graph fields - in search results the page stays in the source language.
  • Storing the translation as a separate copy of the document with no link to the original - six months later you can build neither hreflang nor a drift report.
  • Giving the translator publishing rights - unfinished text reaches the live site.
  • Keeping navigation, buttons, and form labels in code rather than in the CMS - any edit requires a developer and a release.
  • Starting the translation before the source page is approved - the text gets translated twice.

Who this applies to

A process at this scale is needed by companies whose site lives in two or more languages and whose content changes at least once a month: a product SaaS with Russian and English versions, the marketing site of a European company, a bilingual blog. If there are a few edits a year, a spreadsheet with statuses and one responsible person is enough. It applies separately to companies building a site for a specific foreign market: there the version differs not only in language but in prices, service lineup, and legal wording, so “translate the page” and “prepare a version for the market” are tasks of a very different size.

Frequently asked questions

How do you organize content translation in a CMS if the team is small?

Start with the model where the team translates in the CMS, plus the two mandatory elements in the schema: a link between language versions and a translation status. That is enough while up to five to seven pages change a month. Assign translation to one person and make it part of releasing a page rather than a separate item on a list. When translation starts falling behind consistently, move to an external translator with limited rights in the CMS - and you will not have to change the data model at that point.

Can you publish machine translation without proofreading?

As a draft, machine translation saves a noticeable share of time, but publishing it without proofreading is risky for two reasons. The first is terminology: plan names and offer wording get translated literally and stop matching what the sales team says. The second is legal and pricing blocks: refund terms, warranties, and taxes are worded differently in different countries. The working setup is machine translation plus proofreading by a native speaker.

What do you do if a page is translated but the original has changed since?

The translation status should switch automatically to “outdated” the moment the edit in the source language is saved. What happens next depends on the scale of the change: for an edit to a single paragraph you update only that paragraph, for a rewritten section you redo the translation. If the CMS has no such status, a pair of fields replaces it: the original’s modification date and the translation’s modification date - comparing those two dates gives the same result.

Who should own translation, marketing or development?

Marketing owns content and deadlines, development owns the technical capability for the process. In practice development builds locales, version links, and translation status into the CMS once, and then stays out of it. If every translation requires a code edit or a release, the work has been divided incorrectly - navigation, button labels, form copy, and meta fields should all be editable in the CMS.

Key takeaways:

  • Three elements in the data model - locales, version links, and translation status - decide more than the choice of translator
  • The working model is chosen by how often edits happen, not by budget: up to a few pages a month the team handles it, beyond that you need an external translator
  • An untranslated page should not have a localized URL or appear in hreflang pairs
  • Version drift gets caught by a status report, not by a manual check once every six months

If you have a site in two or more languages and the second version is already falling behind - describe your current CMS and how translation works today to the Exceltic.dev team. We will look at the data model, tell you what is missing for statuses and version links, and estimate the scope of work.

More articles

All
Get in touch your way
WhatsApp Telegram

Before you go: a free estimate

Describe your task in a few words and we propose a solution, a stack and a quote with timelines.

Three areas with one team: software, web development and CRM implementation. Over 100 projects, and the project is run directly by an engineer, in Russian and English.