Your team manages content in five languages across four markets. A product update has to go live this week. German is ready. French sits in an email thread. The Italian page still shows last quarter’s offer, and nobody is sure whether the Spanish URLs match the rest of the site.
What fixes this is one decision in the content model: which fields hold one value per language, and which hold a single value shared by every language. Three further decisions follow from it, and all four are cheaper to make before anyone builds:
- Which fields carry one value per locale, and which carry one value for all of them
- The locale list, including regional variants such as German for Austria and Germany
- The URL structure: path prefixes, subdomains, or a domain per market
- Whether locales publish together or independently
The demand is not in doubt. A CSA Research survey of 8,709 consumers across 29 countries found 76% favour buying a product whose information appears in their native language, and 40% rule out a purchase in a foreign language altogether.
Two companion pieces cover what this one leaves out. Translation workflows that don’t break your CMS is about the plumbing between a CMS and a translation tool. Hreflang breaks when you localize your URLs is about the language and region tags on live pages.
What is the difference between translation and localisation?
Translation is the text. Localisation is the text plus everything else a market needs, which is why Contentstack’s documentation defines localisation as “the process of adapting content for different locales”.
In practice the gap between the two words is a list of things that are not sentences:
- Date and number formats, including the thousands separator and the decimal mark
- Currency, and whether a market sees a different figure or the same figure converted
- Units, address and phone formats
- Imagery, where a photo that reads as aspirational in one market reads as odd in another
- Legal and regulatory notices, which differ by country rather than by language
- The offer itself, where a product or plan is not sold in every market
A content model that only has room for translated text pushes all of that into the frontend or into a spreadsheet. Both spellings of the word are in use, localisation and localization, and they mean the same thing.
A locale is a short code identifying a language, optionally with a region: de for German, de-AT for German as used in Austria. A fallback is the locale a system reaches for when the one a visitor asked for has nothing in a field. Both are settings in the CMS, and both decide what a visitor sees on a page nobody finished translating.
What goes wrong when each language is its own page?
One page per language, with nothing in the data linking the versions, is the arrangement that creates the work. Each language is a separate object. A change to a shared element has to be repeated in each copy, because no system knows the copies belong together, and keeping them in step is a job somebody does from memory or from a spreadsheet.
Two further difficulties come with it. Where the link between versions is maintained by a tool bolted on top rather than by the data model, that link is only as reliable as the tool. And where a page is stored as one blob of markup rather than as separate typed fields, there is no headline field or body field to address on its own, and no per-field constraint to carry. This is one of the reasons the time an editor loses to the CMS is worth measuring.
The cost of all this grows with languages multiplied by pages, which is why it feels manageable at five pages and does not at fifty.
How do I model multilingual content fields in a structured CMS?
Model it per field. One entry holds every language version, each translatable field stores one value per locale, and fields that are the same everywhere store a single value.

DatoCMS documents the switch as per-field: “Each field is localized individually, so you can pick and choose which specific content needs to be translated and which does not”. Once one localised field exists in a model, the record form shows one tab per locale.
Storyblok puts the same switch on the field inside the block, where you “select the field and choose Translatable in the block’s Edit field tab”. Its documentation notes that all field types except Blocks support translations, which is worth knowing before you plan to translate a nested block.
Sanity offers the choice at two levels, describing field-level localisation as “a single document with content in many languages” and document-level localisation as “a unique document version for every language”.
Which fields go which way is a content decision. A starting point that holds up:
| Field | Default choice | Why |
|---|---|---|
| Headline, body, CTA label | One value per locale | The words are the product |
| Slug | One value per locale | Readable URLs are part of the local experience |
| Meta description, page title | One value per locale | Search results are read in the local language |
| Image with text in it | One value per locale | The text inside the asset needs translating too |
| Image without text | One value for all | Changing it once should change it everywhere |
| Product ID or SKU | One value for all | It identifies the same thing in every market |
| Author, publish date | One value for all | Facts about the entry rather than about a language |
| Price | Depends on the market | One currency can be shared, a market-specific figure cannot |
The slug is not always an ordinary field. In Storyblok it comes from an app: the “Translatable Slugs app stores a separate slug per language on each story and folder”. Check where your platform keeps it before promising the SEO team localised URLs.
A reference field needs its own decision. A link to something with one identity across markets, such as the product behind a product page, is a shared value, and a translation step that rewrote it would break the link. A link to language-specific content belongs per locale.
Document-level translation, one document per language joined by references, is the right answer for some content. Sanity recommends it for documents with “unique, language-specific fields and no common content across languages” and for content written as Portable Text, its rich-text format. Contentstack works this way by default: “When you localize an entry, it no longer inherits values from its fallback language and becomes an independent version”, and that entry then keeps its own version history and publishing status.
The question for your own model is how much of an entry is genuinely the same in every market. A product page with shared imagery, a shared SKU and translated copy wants field level. A market-specific landing page that shares nothing wants document level.
Do CMS platforms have AI translation built in, or do you still need a separate tool?
On several platforms the first pass now runs inside the editing interface. This part of the subject keeps changing, so read the current docs rather than last year’s comparison.
Storyblok’s documentation states that it “supports AI translations in dozens of languages and locales, letting editors generate machine-based translations in the Visual Editor” and lists 48 languages, with a per-field version as well as a whole-story one. The same manual says that “AI Translations is part of Storyblok Labs and is still in beta”.
DatoCMS routes the work to a provider you choose. Its AI Translations plugin “integrates leading AI providers”, naming OpenAI, Google, Anthropic and DeepL, and works on one field, a whole record, selected records or a whole model. It needs a project with at least two locales and your own API key, and its documentation notes “No translation memory: Each translation is independent”.
Sanity ships AI Assist with two translation APIs that mirror its two localisation strategies, “document-level or field-level translation”. The configuration takes a style guide of up to 2,000 characters, which is where brand voice goes. It is a paid feature on the Growth plan and up.
Contentstack documents the assembly rather than a feature. Its guide builds the translation step out of connectors: a workflow trigger, an action that fetches the entry, a translation action, and a Localize Entry action to write the result back. Its advice inside that guide is that “it’s recommended to translate content on a per-field basis”, the same field-level principle arriving from the automation side.
Let the first pass be AI and have a human edit it. That is how we run our own content pipelines and the agentic marketing automation work we do for clients, where a person reviews each significant step and signs off the result before it ships.
One modelling requirement sits underneath all of these. A translation step can only treat a headline as a headline, with its own length limit and its own context, if the headline is a field of its own.
Can a CMS trigger a translation job in a TMS automatically when content is published?
Yes. In the documented recipes the trigger is a workflow stage or a publish event rather than the publish button. A translation management system is the workspace translators use; three parts of the handoff matter at model level: what fires, what carries the locale, and what the CMS stores.
Contentstack documents a full loop. A workflow with Draft, Ready for Translation and Translation Complete stages drives it. The trigger fires when an entry reaches “Ready for Translation”, an action fetches the content, the translation step runs field by field, and a Localize Entry action writes the result into the target locale before a final step moves the entry to the completion stage. The returning text has to be written to the intended entry and the intended locale, which is what the Localize Entry step is for.
Sanity documents the same shape with webhooks on both legs: a webhook sends the document to a translation service, and a webhook from that service writes the translation back. DatoCMS fires webhooks on record lifecycle events including publish, and its event table covers the per-locale case, where a record is “selectively published” in one locale while other locales still hold unpublished changes. Storyblok’s own apps cover the file-based route, with Export Translatable Fields and Import Translatable Fields apps for third-party services.
Four things have to exist somewhere for any of this to work, and they are requirements for your setup rather than features you can assume:
- A stable identifier per entry that survives the round trip
- A locale code per value, in the exact spelling both systems agree on
- A way to see which translations are current, outdated or missing
- A record of which source version each translation was made from
The fourth is what tells you later whether the French page is translated or was translated once. If the integration itself is what keeps breaking, the sibling post covers those failure modes.
How do you handle German for Austria and Germany without duplicating the page?
Give the variant its own locale, point its fallback at the base language, and override only the fields that genuinely differ. The variant is a column of values rather than a copy of the page.
DatoCMS documents the pattern with three English locales, where you “write each product page once in base English, and only override the handful of fields that actually differ by region”. In its example the product name and the shipping line change by region, and the description is written once and inherited. The fallback can be a chain, tried in order from the closest variant to the broadest: English (Australia), then English (UK), then base English.
Other platforms document their own fallback behaviour, and the details differ enough to read first. Storyblok sets a fallback language per request, with a caution in its documentation that the language code uses underscores rather than hyphens. Contentstack lets you “define a fallback language for every language you add to a stack”, returns that content only when the request asks for it, and caps the depth: “You cannot create a fallback-language chain deeper than one level for non-master languages.”
The URL question comes next, and it is a model question as much as a routing one.
| URL strategy | Looks like | What the model has to carry |
|---|---|---|
| Path prefix on one domain | example.com/de-at/ |
A locale code per entry and a translated slug per locale |
| Subdomain per market | at.example.com |
The same, plus a host-to-locale map outside the CMS |
| Domain per market | example.at |
The same again, plus per-domain sitemaps and separate verification |
One domain with path prefixes keeps the model simplest, since every locale is one entry under a different prefix. A domain per market earns its cost when markets are run by different teams with different offers, and it brings overhead in redirects, certificates and search-console properties. The language and region relationships belong in the content model, and the tags get generated from it, which the hreflang post covers in full. Changing it after launch means remapping the URLs it applies to, so decide before launch.
What breaks as the number of pages grows?
The failures here are quiet rather than loud. Each one is a specific mechanism, and each one has a counter in the model.
A field added after launch exists in one locale. Somebody adds a subheadline to the page type in week 30. It is filled in the source language and empty in nine others, and if the field carries no validation, nothing says so. The counter is to treat a model change as a multilingual event: DatoCMS makes the point from the other direction, warning that adding a locale later enforces existing field validations for every locale, so records already created are marked invalid until the gaps are filled.
A shared asset changes once and is wrong in three markets. Changing a shared image changes it everywhere, including in the market where the old one was there for a legal reason.
A fallback hides an untranslated page. A locale falls back to the base language, the page renders in fluent English, and nobody reports a problem since nothing looks broken. Months later somebody notices the section was never translated. The counter is a way to see translation completeness per locale, and somebody whose job it is to look at it.
A component gets reordered in one language only. Field-level translation keeps the structure shared, so this belongs to the folder-level and space-level approaches. Storyblok is explicit about the tradeoff, describing folder-level translation as a structure that “duplicates some content, but allows customization of each locale based on the story components’ structure and order”. Per-market layout freedom means maintaining the layouts separately.
Publishing drifts out of step. A field-level model does not force simultaneous publishing, though a platform default can. Storyblok’s documentation states that “by default, publishing a story publishes all language versions simultaneously”, and offers a setting called Publish individual translations. DatoCMS has an optional-locales setting and an “Only publish specific content” option, which lets a team finish Germany without waiting for Belgium. Sanity ties it to the strategy: field level publishes all languages at once, document level each independently. Decide which behaviour you want and set it.
A short list to run against your own setup:
- Can you name, per field, whether it is translated or shared?
- Does adding a field to a page type tell anyone that nine locales are now incomplete?
- Can you see, without opening pages, which locales are complete, outdated and missing?
- Do you know which locales are currently serving fallback content to real visitors?
- Can one market publish without waiting for the others, and is that what you want?
- Does your locale code spelling match in the CMS, the frontend and every integration?
How long does a multilingual CMS implementation take?
A headless migration runs 12 to 18 weeks from discovery to go-live on a typical project, and the Eversports Manager migration ran six months. The range is wide because three things move it: page types, languages, and the integrations that have to keep working.
What moves it most is which of those is new. Retrofitting a single-language model can mean work in the content model, the routing and the URLs, depending on how much content is localised. A model that already carries a locale reduces that to the new locale’s content and configuration. If a multilingual future is plausible, model for it before the first launch, and launching into a new market becomes a smaller job. Our own estimating process is written up in how a headless migration gets estimated.
How does this work in practice?
When we migrated Eversports Manager from WordPress to Storyblok, multilingual content was one of the core requirements. The company operates across seven European markets, in German, English, Spanish, French, Italian and Dutch.
The setup uses Storyblok as the headless CMS with Next.js on the frontend. Every page is built from reusable content blocks, and each block has translatable fields for the six languages, so the structure of a page is shared and only the values differ per locale. The marketing team publishes across markets without a coordination round.
The project took six months end to end. What changed day to day work was the structure: one entry per page instead of one page per language.
Where should you start?
Start with the field list. Take one page type that matters, write down every field, and mark each one translated or shared. The arguments that come out of that exercise are the design conversation, and they are cheaper on paper than in a migration. Strict data models make editors faster makes the broader case for doing this work up front.
Then settle the other three decisions in writing before anyone builds: the locale list including regional variants, the URL structure, and whether locales publish together or independently. All three are expensive to change after launch.
If you are weighing platforms, the 5-step plan for evaluating a CMS gives you a structure for the assessment, and reusing content across channels and markets covers how the same decisions govern email and social. CMS vendor lock-in is worth checking while you still have a choice.
If you are considering a move to a headless CMS, a headless audit gives you a picture of what a migration would involve for your setup: timeline, effort, risks and expected outcomes. If you already know you need to move, our headless migration service handles the transition from a legacy CMS to a headless, multilingual-ready architecture.