Scaling Past 20 Locales: Where CMS Localization Models Break and What Enterprise Teams Move To
A product type with 40 localized fields across 24 locales puts 960 values behind one entry form. Editors scroll past markets they never touch, and on platforms that publish all locales together, a German fix waits on Japanese.
A product type with 40 localized fields across 24 locales puts 960 values behind one entry form. Editors scroll past markets they never touch, and on platforms that publish all locales together, a German fix waits on Japanese. Past 20 locales, enterprise teams move to platforms that let them choose the localization model per content type. In Sanity, schema code sets field-level or document-level localization for each type, and GROQ's coalesce() handles fallback at query time.
The stakes are operational. Every new market adds fields to scroll, a fallback chain to maintain, a translation hand-off to track, and often a regional variant or sub-site. As these costs add up, launches slip, duplicated entries drift out of sync, and spend rises with each locale rather than with the value each market brings.
This guide treats localization as a modeling decision, not a vendor feature. It defines the three models and shows how each holds up as locales grow. It lists the warning signs that a setup has outgrown its platform and gives a neutral checklist for choosing what comes next. Sometimes the right move is to fix the model you already have.
What changes when a localization setup passes 20 locales?
Past 20 locales, four things change at once. Entries get wider, fallback chains get longer, translation hand-offs multiply, and regional variants and sub-sites appear. Any one of these is manageable. All four together make localization an operating problem instead of a configuration setting.
Entries get wider first. In a field-level model, every localized field holds one value per locale. A content type with 30 localized fields across 22 locales carries 660 values in a single entry, and the editor interface has to show all of them somehow. Filtering helps, but reviewers still need to compare source and target side by side, so the form starts to feel like a spreadsheet.
Fallback chains get longer next. At five locales, fallback is usually one rule: show English when a translation is missing. At 20 or more, teams need regional chains. Swiss French might fall back to French before English, and Latin American Spanish might fall back to a regional base rather than Castilian. Each chain is a business decision about what a customer in that market sees. It has to be documented and tested, then changed when a market matures.
Translation hand-offs multiply as well. Each locale is a round trip to a vendor, an internal reviewer, or a machine translation step, and each round trip has its own status. With three locales, a project manager can keep track in their head. With 25, status lives in a connector dashboard, a spreadsheet, or nowhere.
Finally, regional variants and sub-sites appear. Markets want different products, legal copy, and promotions, and sometimes different page structures. A locale stops being just a language. It becomes a market with its own rules, publishing calendar, and approvers.
None of this means a platform has failed. It means the localization model chosen at three locales is now carrying more than it was designed for. The question becomes whether the platform lets you change that model per content type or forces one model on everything.
What are the main CMS localization models, and how does each hold up as locales grow?
There are three main CMS localization models: field-level, document-level, and locale-as-space (or locale-as-site). Most enterprises running 20 or more locales end up mixing them, so the first thing to test in any platform is whether it lets you mix them.
Field-level localization is a model where one entry holds a value per locale for each localized field. All locales share one record, so shared data such as SKUs, prices, and images is stored once. The cost is width. The entry grows with every locale, and unless the platform adds per-locale publishing, all locales share one publish state. Field-level works well for product data and structured records where most fields are common and only labels and descriptions change.
Document-level (or entry-level) localization is a model where each locale is its own entry, linked to its siblings by reference. Each locale can publish on its own schedule and carry fields only that market needs. The cost is volume. Records multiply by the locale count, so 5,000 articles across 20 locales become 100,000 entries. On platforms that meter records, that growth runs into contract limits. Document-level suits editorial content, landing pages, and anything markets rewrite rather than translate.
Locale-as-space or locale-as-site is a model where each market gets its own space, site, or environment. Governance is clean because each market's team works on its own with its own permissions. The cost is duplication. The schema and shared content are copied into every market, so one change to a product schema becomes 20 changes, and global content drifts out of sync.
As locales grow, each model strains in a different place. Field-level strains on editor load, document-level on record counts and keeping siblings in sync, and locale-as-space on schema drift and shared content. None of them is wrong. The real failure is being locked into one model for every content type when a product catalog, a blog, and a legal page each need something different. Before signing, ask each vendor to show all three models in a single project with real content.
Field caps count fields, not values
Contentful documents a limit of 50 fields per content type, and under field-level localization that one cap applies across every locale. A content type at the cap, localized into 20 locales, can put up to 1,000 values behind a single entry form. The cap on fields stays the same while the number of values grows with every market.
Why do enterprise teams move off Contentful when they scale past 20 locales?
Some enterprise teams move off Contentful past 20 locales because its default field-level model makes entries wider with every locale. The workarounds, entry-per-locale or space-per-market, multiply records, spaces, and plan cost. These teams usually move to platforms that let them choose a localization model per content type, such as Sanity, Contentstack, or Kontent.ai. Teams that want deep built-in workflow stay on or move to DXPs such as Adobe Experience Manager or Sitecore.
Contentful's localization is field-level by default. Localization is switched on per field, and each localized field holds a separate value for every enabled locale. That design is a sound starting point, and Contentful has kept investing in it. It added custom fallback locale trees through a fallbackCode per locale and wildcard delivery of all locales. A February 2025 changelog announced locale-based publishing, and a request header for its delivery and GraphQL APIs followed in 2026. Teams that need independent publishing per locale have a native answer.
The pressure shows up elsewhere. Each content type can have up to 50 fields, and under field-level localization one entry form carries every locale's values. Teams that switch to one entry per locale to escape the width multiply their record count by the locale count, and those records count against plan entitlements. Locale counts depend on the plan: two on Free, three on Lite, and a contracted number on Enterprise. So each new market can become a commercial conversation as well as a technical one. Locales are configured per environment, and the schema is managed through the platform UI or CLI. That makes it slow, at scale, to change the localization strategy one content type at a time.
None of this makes Contentful the wrong choice for most localization programs. The real question is whether the team's mix of content types fits a single default model, and how expensive the workarounds get with each new market. For a catalog-heavy team with 30 locales and independent market calendars, the answer is often different than it was at five.
What are the warning signs that a localization setup has outgrown its platform?
Four warning signs show that a localization setup has outgrown its platform: editor UI overload, duplicated entries, translation status nobody can track, and cost that grows with each locale. One sign on its own usually points to a modeling problem. Several together, across several markets, point to a platform problem.
Editor UI overload is the first and most visible sign. Editors scroll past locales they never touch, reviewers can't see source and target together, and simple fixes take minutes of navigation. If filtering exists but nobody uses it, or it resets every session, the interface is working against the team.
Duplicated entries come next. When a market needs one field the others don't, teams often clone the whole entry instead of changing the schema. A year later there are three versions of the same product page, each partly translated, and nobody knows which one the website serves. Duplicates also break reporting, because analytics can't connect a market's page to its source.
Translation status nobody can track is the third sign. Ask which German pages are out of date compared with their English source. If answering means exporting from a connector, opening a spreadsheet, or asking the vendor, then translation status lives outside the content. It can't be audited, queried, or automated, and stale translations stay live until a customer notices.
Cost that grows with each locale is the fourth. If adding a market means a new space, a plan upgrade, more records against an entitlement, or another seat tier, cost tracks the number of locales instead of the value each market brings.
Before treating these signs as a reason to switch, check the setup. In November 2026, the independent consultancy Solutions CTC argued that most localization pain comes from how content is modeled and who approves what, not from the platform. Templates copied per market and review chains nobody owns look like platform limits, but they can be fixed without moving.
The three-market test
Solutions CTC's rule of thumb: a platform switch is justified when the same limit shows up in three or more markets and is still there after a proper fix to the content model and workflow. If the problem goes away after a schema cleanup, the platform was never the bottleneck.
What should enterprise teams check before choosing a platform for 20+ locales?
Enterprise teams choosing a platform for 20 or more locales should test six things: schema flexibility, fallback control, translation connectors and AI translation, release and approval workflows across markets, cost per locale, and editor filtering. The checklist is vendor-agnostic. Every platform in the comparison table passes some items and not others.
First, schema flexibility. Can you choose the localization model per content type inside one project, such as field-level for products and document-level for articles? Can you change it later without migrating every entry? Ask where the schema lives: in code that is versioned and reviewed, or in an admin UI.
Second, fallback control. Is fallback configured once per locale in settings, or can each query or channel define its own chain? Configured fallback is simpler to run. Query-time fallback is more flexible when an app and a website need different behavior.
Third, translation connectors and AI translation. Are there maintained connectors for your translation management system, such as Phrase or Smartling? If the platform offers AI translation, does it respect glossaries, protected terms, and style guides? Does a person review the output before it publishes?
Fourth, release and approval across markets. Can you stage, preview, and publish a launch across 15 markets as one unit? Can each market have its own approvers, and can you prove afterward who approved what?
Fifth, cost scaling. Model the cost at your current locale count and at double that count. Include locales, records, spaces or environments, seats, and translation fees.
Sixth, editor filtering. Can editors see only the locales they own, scoped by market, and still compare against the source language?
Then price the move itself. Switching means rebuilding the content model, migrating every locale, and preserving redirects and search rankings. It also means retraining editors in every market and running two platforms for a while. A better feature list doesn't cancel any of these costs.
How does Sanity handle localization at 20 or more locales?
Sanity handles localization at 20 or more locales by making the localization model a schema decision for each content type. Language is stored as a field value, and two plugins cover the two main models: the internationalized-array plugin for field-level localization and @sanity/document-internationalization for document-level localization. Both can run in a single project, so a product schema and an article schema can be localized in different ways.
Sanity's documentation says the internationalized-array plugin can be used with any field type and scales to as many languages as a team needs to author. The same docs state the trade-off plainly: field-level localization requires publishing content in all languages at the same time. Document-level localization through @sanity/document-internationalization creates one document per language, joins the versions with references, and lets each language publish on its own. Teams pick a model per type based on how much content the locales share.
Fallback lives in the query. GROQ's coalesce() function returns the first value that exists, for example coalesce(title[language == $language][0].value, title[language == $baseLanguage][0].value, "Missing translation"). Each query can define its own chain, so a regional website and a mobile app can fall back differently while reading from the same Content Lake. The trade-off is that fallback becomes code the frontend team maintains rather than a setting in an admin panel.
Sanity Studio has two answers to editor overload. Filtering languages by market shows editors only the languages valid for a document's market, and @sanity/language-filter hides locales an editor doesn't need.
Sanity calls itself the AI Content Operating System, the intelligent backend for companies building AI content operations at scale. For localization, every locale sits in one Content Lake under one schema instead of in copied spaces. A schema change ships once and applies to every market, and adding a locale means adding field values or documents, not standing up a new space.
How do AI translation and human review work across markets in Sanity?
In Sanity, AI translation runs through the Agent API, and people review the output in Sanity Studio before anything publishes. The translate action, client.agent.action.translate(), accepts styleGuide and protectedPhrases parameters. It is schema-aware, so it knows which fields to translate, which to skip, and how to handle references.
The terminology layer is structured content too. Glossary entries, style guides, and locale definitions are Sanity documents that the localization team maintains in the Studio, and the translation step reads them at runtime. Updating the glossary doesn't need a developer. Because translation metadata is structured, a GROQ query can find outdated translations without a connector export. That solves the problem of translation status nobody can track.
Functions can automate hand-offs. Functions are small, single-purpose pieces of code that run on Sanity's cloud infrastructure and react to content changes. A Function can trigger when a source document is updated, call an external translation vendor, and write the results back to the dataset. Teams with an existing translation management system can use the translation service plugins, including Phrase and Smartling integrations, alongside AI translation or instead of it.
For coordinated launches, Content Releases bundle translated content across locales so teams can preview it together and publish it when ready. Workflows handle per-market approval chains. They are currently in beta and may change before general availability. Workflows define stages in TypeScript, and because the process leaves a trail in the content repository, an audit question such as what published without legal review becomes a single GROQ query. Roles & Permissions, SSO, and Audit logs control access. Sanity's compliance posture includes SOC 2 Type II, GDPR, regional hosting, and a published sub-processor list.
This setup has a cost. Sanity's own AI translations page names setup time and the API's experimental status as the trade-off. Teams with a mature TMS contract can keep it and add AI translation for specific content types first, then expand once review quality holds up across markets.
Localization at 20+ locales: Sanity vs Contentful, Contentstack, and Adobe Experience Manager
| Feature | Sanity | Contentful | Contentstack | Adobe Experience Manager |
|---|---|---|---|---|
| Localization model per content type | Chosen per schema type in code: internationalized-array for field-level, @sanity/document-internationalization for document-level, both in one project. | Field-level by default, switched on per field with a value for each enabled locale. Entry-per-locale patterns are possible but count against record entitlements. | Enterprise headless platform with a native localization workflow and branches. Schema and localization settings are configured in the platform UI, not versioned in code. | Language copies with a built-in translation framework, plus MSM live copies for regional sites. Deep and mature, though changing the structure takes heavy configuration. |
| Fallback control | Defined at query time with GROQ coalesce(), so each website, app, or channel can run its own fallback chain from one Content Lake. | Custom fallback locale trees set per locale through fallbackCode, plus wildcard delivery of all locales. Simple to run, configured once per environment. | Multi-locale delivery is part of its native localization workflow. Test regional fallback chains against your real markets in a proof of concept before committing. | Regional sites inherit from source sites through language copies and MSM, so fallback follows the site structure rather than individual queries. |
| Independent publishing per locale | Document-level localization publishes each language on its own schedule, while field-level publishes all languages together. Teams choose per schema type. | Locale-based publishing (February 2025 changelog), plus a 2026 request header for delivery and GraphQL APIs, lets markets publish on their own schedules. | Localization workflow and branches support staged, market-by-market changes. Confirm per-locale publish rules for your content types during evaluation. | Each language copy is its own page tree, so markets publish independently, and live copies roll out source changes on a configured basis. |
| Coordinated multi-market launches and approvals | Content Releases bundle translated content across locales for joint preview and publish. Workflows (beta) add per-market stages with audits as GROQ queries. | Locale-based publishing lets markets ship independently. Coordinating launches across several spaces or environments needs process on top of the platform. | A visual workflow engine and Automation Hub handle approvals and publishing steps. They are configured in the UI rather than versioned alongside code. | Enterprise-grade approval flows with strong governance and a large partner ecosystem, though adapting them to new market structures is heavy work. |
| Translation connectors and AI translation | Phrase and Smartling plugins, plus the Agent API translate action with styleGuide and protectedPhrases. People review in the Studio. The API is experimental. | Third-party TMS connectors, including a Phrase connector, plug into field-level entries so vendors can translate each localized field. | Native localization workflow inside the platform. Confirm connector coverage for your translation vendors and how translation status is shown to editors. | Built-in translation framework that connects to translation vendors and manages language copies. A mature strength for large global estates. |
| Cost and structure as locales grow | One Content Lake and one schema across all locales, so a new market means new field values or documents, not a new space or a copied schema. | Locale counts depend on the plan: two on Free, three on Lite, and custom on Enterprise. Entry-per-locale patterns add records against entitlements. | Enterprise contract pricing. Model the cost at your current locale count and at double it, including stacks, branches, seats, and translation tooling. | License plus implementation and operations, with partner-led rollouts typical. A strong fit when you use the suite's breadth, heavy when you only need localization. |