AEM vs Headless CMS: Multi-Site in Contentful and Storyblok

Multi-site content architecture has always been a core challenge in enterprise CMS implementations. Managing multiple brands, markets, and languages within a single platform is not primarily a feature question; it is a structural one. The way a CMS models hierarchy, governance, and localization has long-term consequences for complexity, scalability, and operational overhead.
Multi-Site Manager (MSM) remains one of Adobe Experience Manager's (AEM) strongest enterprise capabilities. From our experience working on large global AEM programs, MSM addresses a very real operational need: how do we manage multiple sites, dozens of markets, and multiple languages while maintaining central governance and controlled propagation of change?
The model is well established. A global blueprint is typically defined under language-masters. Live Copies are created per market. Language copies sit under each market. Rollout configurations determine what propagates and when. Inheritance can be selectively broken where local deviation is required. For organizations operating complex global platforms, this hierarchical model provides clarity and control. Governance is embedded directly into the content tree. Structural relationships enforce alignment. At scale, it remains a powerful mechanism.
Modern headless CMS platforms such as Contentful and Storyblok do not attempt to replicate this model. Instead of expressing governance through hierarchy and inheritance, they move it into content modeling and references. Shared content is defined once and reused through structured relationships. Market and language variations are modeled as data attributes rather than structural copies. The problem is the same, multi-site governance at scale, but the architectural approach is fundamentally different.
The Enterprise Scenario
To understand how these architectural differences play out in practice, it helps to anchor the discussion in a concrete scenario. To make the comparison tangible, we will use a simplified but realistic enterprise example:
- 3 global websites
- 5 markets per website
- 10 languages per market
- 100 pages per site
- Central governance
- Local content ownership
This setup reflects the kind of scale many enterprise platforms operate at. It is intentionally simplified, but structurally representative. Using this example model allows us to compare how AEM, Contentful and Storyblok handle multi-site governance, localization, and structural growth under similar conditions.
AEM: Hierarchical Multi-Site Architecture
In AEM, multi-site architecture is fundamentally hierarchical. A global blueprint is defined under language-masters or blueprints, from which Live Copies are created per market. Under each market, separate language copies are created. The content tree itself expresses governance and propagation. Conceptually, the structure looks like this:
/site-a
/language-masters
/en [HeroComponent, TeaserComponent]
/fr [HeroComponent, TeaserComponent]
/us (redirect to /us/en)
/en [HeroComponent, TeaserComponent]
/ca (redirect to /ca/en)
/en [HeroComponent, TeaserComponent]
/fr [HeroComponent, TeaserComponent]In this model, structure and governance are tightly coupled. The content tree itself defines relationships, responsibilities, and propagation behavior. It is worth noting that even with Edge Delivery Services (EDS), AEM remains structurally hierarchical. While EDS simplifies rendering and reduces component complexity, the underlying content tree, MSM model, and inheritance mechanisms remain. The architectural philosophy does not fundamentally shift away from hierarchy; it becomes lighter, but not modeling-driven in the headless sense.
If we apply our simplified enterprise scenario, the structural implications become clear. For one site with 100 pages operating across 5 markets and 10 languages, we can end up with 5,000 page instances. Across three sites, that results in 15,000 pages. This multiplication happens because, in AEM, language is structural. Each language represents its own page tree. Markets are inherited trees derived from a central blueprint. Governance is enforced through hierarchical relationships rather than through explicit modeling.
MSM manages this complexity through controlled rollout and fine-grained inheritance rules. When selective inheritance is operationally critical, when rollout governance is embedded in business processes, or when markets frequently override central components while still relying on structural alignment, this model remains extremely effective. AEM is particularly strong in organizations where hierarchical governance aligns naturally with how teams are structured and how responsibility is distributed across markets and regions.
Contentful: Schema-Driven Multi-Site Architecture
Contentful approaches multi-site architecture without inheritance. There are no Live Copies and no hierarchical rollout mechanisms. Instead, structure is defined explicitly through content types and structured entries. In a simplified model, we would define a Page content type with fields such as site, market, slug, references to reusable sections, and localized fields for each supported language. Markets are not modeled as pages, but as attributes or references. Languages are configured at the field level through Contentful’s native localization system.
Conceptually, the structure no longer expands vertically in a tree. Instead, it becomes a collection of structured entries that exist on the same structural level, with hierarchy expressed explicitly through references rather than through tree depth:
Page Entry
site: site-a
market: us
slug: home
title: { en, fr }
sections: [HeroRef, TeaserRef]
Page Entry
site: site-a
market: ca
slug: home
title: { en, fr }
sections: [HeroRef, TeaserRef]There is no blueprints branch. There are no market subtrees. Each page-market combination is represented as a structured entry, and language variations live inside the same entry as localized field values. If we apply our enterprise example, the structural difference becomes measurable. For one site with 100 pages operating across 5 markets, we create 500 entries. Across three sites, this results in 1,500 entries in total. Languages do not multiply entries. They multiply fields within the same entry. One practical difference is that this model is less visually obvious. In hierarchical systems like AEM, structure is visible in the content tree, while in schema-driven systems like Contentful it is defined in the content model.
However, instead of managing 15,000 structural page instances, we manage roughly 1,500 structured entries with localized values. In Contentful, language is treated as data rather than as structure. Governance follows this shift. There is no inheritance and no rollout engine. Shared content is modeled through references. Structural evolution happens through content type changes rather than hierarchical propagation. Blueprint logic does not disappear; it moves into the content model, where content types define the structure all pages must follow. Contentful is particularly strong when localization volume is high, when structure is relatively stable, and when governance needs to be enforced through modeling discipline rather than hierarchical enforcement.
Storyblok: Variant-Based Multi-Site Architecture
Storyblok combines component-based modeling with variant isolation. Its primary content entity is called a Story. In most implementations, a Story represents a page, although it can also represent reusable content blocks. While it still provides a content tree for organization, governance is not enforced through hierarchical inheritance. Instead, structural control is expressed through components and a concept called Dimensions.
A Dimension allows structured variants of a Story. In a multi-site context, this can be used to represent markets. For example, we can define a Market dimension with values such as US or CA. Rather than creating inherited copies of a page per market, we create variants of the same story within that defined dimension. Conceptually, it can look like this:
Story: Home
Dimension: Market = US
title: { en }
components: [Hero, Teaser]
Story: Home
Dimension: Market = CA
title: { en, fr }
components: [Hero, Teaser]Markets are variants, not inherited trees. Rather than inheriting pages through a blueprint, separate stories are created for each market and associated with a dimension value. Dimensions help organize and isolate these variants without relying on hierarchical inheritance. The structure of the page is defined by its component composition, and shared content is reused through references rather than through rollout. If we apply our enterprise example, the scaling pattern mirrors Contentful. For one site with 100 pages operating across 5 markets, we manage 500 stories. Across three sites, that results in 1,500 stories in total.
Languages are handled through field-level localization. As with Contentful, language is treated as data rather than as structural duplication. Governance therefore shifts from inheritance to modeling discipline. There is no rollout engine and no structural propagation mechanism. Shared content is referenced and page structure is defined by components. Market isolation is handled through Dimensions rather than through Live Copies. What functions as a blueprint in AEM is distributed across component schemas and reusable stories rather than centralized in a hierarchical parent. Storyblok is particularly strong when marketing teams require visual composition control, when layout flexibility matters, and when a component-driven design system is already in place. It balances structured governance with editorial flexibility in a way that is visually intuitive while remaining architecturally explicit.
Contentful vs Storyblok: A Subtle but Important Difference
Although both Contentful and Storyblok are headless platforms, their structural models are not identical. Contentful is conceptually flat. Entries exist within a space and are organized primarily through content types and references. Any hierarchy that appears in navigation is modeled explicitly through relationships between entries rather than implied by folder depth. The content tree, where it exists, is largely an organizational convenience rather than a governance mechanism.
Storyblok, by contrast, still provides a visible page tree composed of folders and stories. Editors can navigate content in a way that feels structurally similar to traditional CMS systems like Adobe Experience Manager. However, that tree mainly serves editorial organization rather than governance. Markets are not isolated through inherited subtrees, but through Dimensions, which attach variant values such as market or brand to individual stories. Structural reuse is not achieved through rollout, but through shared components and references.
In practical terms, this means Storyblok can feel more familiar to teams coming from hierarchical systems, while still operating on a modeling-driven governance approach under the hood. Contentful, on the other hand, encourages a more explicitly structured and reference-driven mental model from the outset. Both approaches remove inheritance and rollout, but they differ in how visible structure is presented to editors.
The Often Overlooked Shift: Frontend Responsibility
One of the most significant differences between hierarchical CMS architectures and headless models is not visible in the content structure itself. It appears in the frontend layer.
In AEM, URL structure typically reflects the content tree. Markets and languages are expressed structurally in the hierarchy. Inheritance mechanisms influence fallback behavior. Preview and authoring are tightly integrated into the platform because the rendering layer and content layer are coupled.
In headless architectures, these responsibilities move. Routing is implemented explicitly in the frontend application. Market detection and language handling must be defined in code. The frontend application must determine which market and language a user belongs to (based on the URL, domain or browser settings) and then request the corresponding content variant from the headless CMS. Fallback behavior is no longer implied by structural inheritance; it must be modeled intentionally. Preview integration requires coordination between the CMS and the rendering layer.
Headless architectures simplify backend hierarchy, but they increase architectural responsibility on the frontend side. The system becomes more explicit and more flexible, but also more dependent on disciplined frontend implementation. That shift should not be accidental. It is an architectural decision, not just a tooling change.
Visual Editing: Different Philosophies, Same Goal
Visual editing has historically been one of AEM’s strongest differentiators. The ability to edit content directly within the context of the rendered page has long been central to its value proposition, and with the introduction of the Universal Editor, this capability has been extended into headless scenarios as well. In AEM, visual editing is tightly coupled to the page structure. Components rendered in the page correspond directly to editable elements within the authoring interface. Because hierarchy and rendering are closely connected, authors operate within a structurally governed environment.
Storyblok takes a similarly visual-first approach, but in a headless-native way. Stories are rendered in a real-time preview, and editors compose pages by assembling predefined components visually. The editing experience is tightly integrated into the concept of components and blocks. This makes visual composition one of Storyblok’s strongest differentiators, particularly for marketing-driven teams that prioritize layout control within structured constraints.
Contentful historically focused more on structured content modeling than visual editing. Its newer visual editing capabilities provide in-context field editing and preview integration, allowing editors to see changes within the rendered page. However, layout composition is typically governed more strictly by the content model. The editing experience reflects that emphasis: structured and predictable, but less composition-driven than Storyblok.
The architectural distinction is subtle but important. In AEM, visual editing is an extension of hierarchical governance. In Storyblok, it is an extension of component-based modeling. In Contentful, it is layered on top of a schema-driven system. All three platforms support visual workflows. The difference lies in how deeply visual editing is embedded into their structural philosophy.
Architectural Comparison Summary
AEM: Hierarchical Governance
Structure lives in the content tree. Markets are created through Live Copies and languages create separate page hierarchies. Governance is enforced through inheritance and rollout propagation. Visual editing is tightly integrated into the page structure, allowing authors to edit components directly within the rendered page.
Contentful: Schema-Driven Governance
Structure lives in the content model. Pages are entries defined by content types, and markets and languages are represented as attributes and localized fields. Governance is enforced through the schema rather than hierarchy. Visual editing exists through preview and in-context editing, but layout composition is typically constrained by the content model.
Storyblok: Variant-Based Governance
Structure lives in components and dimensions. Pages are stories composed of components, while markets are isolated through dimension variants rather than inherited trees. Visual editing is a central part of the platform, allowing editors to compose pages directly through a real-time component-based interface.
Conclusion
At its core, the difference between AEM and headless platforms like Contentful and Storyblok is not so much about features anymore. It is about where governance lives. In AEM, governance is embedded in hierarchy. Structure defines relationships, propagation, and responsibility. The system scales by expanding trees across markets and languages. Multi-Site Manager remains one of the strongest hierarchical governance models available in enterprise CMS platforms, and in organizations where inheritance and controlled rollout are central to operations, it continues to be highly effective.
Headless platforms centralize governance differently. Structure is defined in the content model. Reuse is handled through references. Variations are expressed through attributes or dimensions rather than inherited trees. Instead of expanding hierarchy, the system scales by expanding structured data. This shift reduces structural duplication and can simplify localization at scale, but it also requires a higher degree of modeling discipline and stronger frontend ownership. The trade-off is not simplicity versus complexity. It is where that complexity resides.
The right architectural choice depends on how an organization thinks about governance, how it handles localization, how mature its development capabilities are, and how intentionally it designs its content models. Choosing between AEM, Contentful or Storyblok should therefore not begin with feature comparisons. It should begin with content architecture. Evaluating a multi-site strategy across markets and languages requires clarity around global versus local boundaries, intentional content modeling, and a deliberate decision about where structural responsibility should live.
We work with enterprise teams to design multi-site architecture intentionally, even before selecting or migrating platforms. By clarifying governance, localization strategy, and structural boundaries upfront, organizations reduce long-term complexity and avoid expensive architectural corrections later. At enterprise scale, sustainable success is defined less by the CMS features than by the quality of the content model and the engineering discipline used to implement it.


