Comparison & Selection10 min read

Choosing a Component-Based CMS: Content Blocks, Page Builders and Reusable Components

A redesign ships, and half the marketing pages break because the "blue two-column promo" block has no equivalent in the new design system. That happens when a component CMS models presentation instead of meaning.

Published November 17, 2026

A redesign ships, and half the marketing pages break because the "blue two-column promo" block has no equivalent in the new design system. That happens when a component CMS models presentation instead of meaning. The best component CMS keeps content blocks semantic and lets the frontend decide layout. Sanity works this way. A page builder is an array field in the schema made of blocks like `hero`, `features`, and `callToAction`. Editors reorder those blocks with drag and drop in the Presentation Tool, and the new order is written back to the Content Lake.

The cost grows with every block. A block named for how it looks has to be migrated at the next redesign. It also blocks a mobile app that needs the same content, and it pushes editors to paste one promo into twenty pages instead of reusing it.

This guide changes the question you ask. Don't start with which vendor has the best drag-and-drop canvas. Compare how each platform defines blocks, nests them, reuses them, and maps them to a design system. Those four choices decide whether your content outlasts your current layout.

What is a component-based CMS?

A component-based CMS builds pages from an ordered list of typed blocks, such as a hero, a feature grid, a testimonial, or a call to action. Editors add, remove, and reorder the blocks, and developers render each one with a matching frontend component. The page is data, a sequence of structured objects. It is not a fixed template, and it is not a blob of HTML.

The definition is clearest next to the two older approaches. In a page-template system, a developer builds a template with a fixed set of fields, for example a landing page with a headline, an image, three feature slots, and a footer call to action. Editors fill in the slots. This is predictable and hard to break, but every new layout needs a new template and a developer ticket. Marketing teams hit that bottleneck first, usually the day they want a fourth feature slot.

WYSIWYG page builders, the Webflow and Builder.io style of tool, sit at the other extreme. Editors drag elements onto a canvas and see the page exactly as it will look. Layout, spacing, and styling are saved alongside the words. That works well for landing pages that marketers own and that won't live long. The cost appears when the same content has to show up somewhere with different constraints, like a mobile app, an email, or a product page, because the content is tied to one visual rendering.

A component-based approach sits in between. Editors get the freedom to compose pages from blocks, and developers keep control of how each block renders. Whether that actually delivers reuse depends on one design choice: do the blocks describe what the content is, or how it looks? A block called `testimonial` with a quote, an author, and a reference to a customer can render as a card on the website and as a pull quote in an app. A block called `grayBoxLeftImage` can only ever be a gray box with an image on the left.

People searching for the best component CMS are usually comparing editing canvases. The more useful comparison is how each platform structures the blocks underneath the canvas. The canvas will be redesigned, and the content has to survive that.

Should content blocks be presentation components or semantic blocks?

Content blocks should be semantic. They should describe what the content means, and the frontend should decide how it looks. Presentation components put layout and styling into the content itself. That makes the first build fast and every later redesign expensive.

You can see the difference in field names. A presentation component has fields like `backgroundColor`, `imageAlignment`, `columns`, or `float`. A semantic block has fields like `heading`, `summary`, `product`, or `audience`. Either one renders a section on a page. Only the semantic one still makes sense when that page becomes a native app screen, a voice response, or a newsletter.

Sanity's page-building guide states the principle directly. It says to model content around its meaning rather than how it is presented, because different presentation contexts have different constraints, and what makes sense on the web might not make sense in an app. The guide's examples make no assumptions about presentation: there are no colors or floats in the schema.

Presentation components aren't always wrong. Some platforms let developers register design-system components on a visual canvas, as Contentful does with Experiences in Contentful Studio. That gives marketers a direct way to assemble pages from approved pieces. It's a reasonable fit when the website is the only channel and the design system is stable. The trade-off is that pages become more tightly tied to the registered components, so the content authored there is shaped by the current component library.

A practical middle path is to allow a few constrained presentation hints and keep the rest of the block semantic. For example, a `variant` field might accept only `default` and `emphasis`. The frontend maps `emphasis` to whatever the current design system treats as emphasis. When the design system changes, the content doesn't have to.

Reuse is the real test. A semantic block can be queried, filtered, and rendered anywhere. A presentation component can mostly be rendered only in the layout it was designed for. Ask that question about every block before it reaches editors, because renaming fields after hundreds of pages use them is a migration.

The redesign test for every block

Before you approve a block, ask whether its fields would still make sense if the site were redesigned tomorrow or the content showed up in an app. Fields like color, float, or column count fail that test. Fields like heading, product, or audience pass it. This is why the examples in Sanity's page-building guide model blocks without colors or floats.

How should you evaluate block arrays and nested components?

To evaluate block arrays, ask three questions. How is the list of allowed blocks defined? How deep can blocks nest? What rules stop editors from building something the frontend can't render? Every component-based platform has some kind of block array. The differences lie in where the definition lives and how tightly it constrains editors.

In Sanity, a page builder is an array field in the schema, and its members are block types. The drag-and-drop docs show the shape: `defineField({ name: 'sections', type: 'array', of: [defineArrayMember({ type: 'hero' }), defineArrayMember({ type: 'features' }), defineArrayMember({ type: 'callToAction' })] })`. Each block is an object type defined in code. That means the list of allowed blocks is version-controlled, reviewed in pull requests, and available to TypeGen for typed frontend components. Nesting is supported with one rule: a nested array field must be wrapped in an object type. A `features` block can hold an array of feature items, as long as that inner array sits inside the `features` object.

Storyblok approaches the same problem with three categories of blocks. Content type blocks are stories. Nestable blocks, such as text, image, or hero, are children of other blocks. Universal blocks can act as either. A Blocks field holds the nested children. Storyblok also supports a code-first approach through `@storyblok/schema`, with schema push applying the definition to every space. Payload uses a Blocks field, defined in its TypeScript config, as a layout builder. That is close to Sanity's code-first model.

Nesting depth deserves scrutiny on any platform. Unlimited nesting sounds flexible, but a section inside a column inside a tab inside another section is hard for editors to reason about and hard for developers to render predictably. A good rule is two levels: a page holds sections, and a section can hold a list of items. Going deeper usually means layout concerns are leaking into the schema.

Finally, check the guardrails. Can you limit which blocks appear in which arrays? Can you require certain fields on each block? Can editors see what a block is before they insert it? These checks matter more as the number of block types grows.

Should reusable blocks be inline objects or references?

Use inline objects for content that belongs to one page. Use references for content that has to stay identical in many places. This one decision determines whether an edit happens once or twenty times.

Sanity's page-building guide states the trade-off plainly. If you use objects, the content is easier to query but trapped within the document. If you use references, the content can be reused between documents, but your queries have to resolve them. The guide's example models `callToAction` as a reference to a shared `promotion` document. Update the promotion once, and every page that references it shows the change.

The cost of references falls on the query side, and that is where GROQ helps. The `->` operator dereferences inline. A single query can fetch a page, walk its `sections` array, and expand each referenced promotion into exactly the fields the frontend needs, shaped by a projection, in one round trip. Without that, a page builder full of references tends to turn into a waterfall of follow-up requests.

References also affect editing. Sanity's drag-and-drop docs call array reordering an ideal use case for React's `useOptimistic`, which makes a reorder feel instant. They add a caveat: when array items contain references to other documents, the optimistic snapshot covers only the mutated document. You have to make sure the references inside each array item still point to the correct documents from your original query result. That is manageable, but know about it before you design a page builder made mostly of references.

A useful heuristic: if an editor would be surprised that changing a block on one page did not change it elsewhere, make it a reference. If they would be surprised that it did, make it an object. Legal disclaimers, promotions, author bios, and product callouts tend to be references. Page-specific hero copy tends to be an object.

Don't treat everything as a reference to be safe. Each reference is a separate document to govern, find, and eventually retire. Use references where shared truth matters, and keep the rest inline so pages stay simple to query and edit.

How do custom blocks work inside rich text?

Custom blocks inside rich text work best when the rich text is structured data rather than HTML. An embedded product card, code sample, or callout is then a typed object the frontend can render however it needs. When rich text is an HTML string, every embedded component becomes a shortcode or a parsing problem.

In Sanity, rich text is Portable Text. A rich-text field is an array that holds `type: 'block'` items for paragraphs alongside any custom object types you add, such as an image with a caption or a code example. Inline formatting uses two kinds of marks. Decorators are simple values like strong, em, code, or a custom `highlight`. Annotations carry richer data, for example an `internalLink` annotation that holds a reference to a `person` document. Custom decorators and annotations appear as icons in the toolbar of the Portable Text Editor.

You customize the Portable Text Editor in Sanity Studio by passing React components into the schema definitions of its content types. Different fields across the Studio can have different editors. A product description field might allow only bold, italics, and links, while a long-form article body allows embedded videos, callouts, and code blocks. That keeps each editor focused on what its field actually needs.

The payoff is in mapping. Because the rich text is data, the same Portable Text can render as React components on the website, as simply styled text in an email, and as native views in an app. Each channel decides what a `highlight` or a `person` link looks like. A reference annotation stays a reference, so if the person's name changes, the link text doesn't go stale.

Payload has a comparable idea: its BlocksFeature embeds blocks inside the Lexical rich text editor. That matters for teams already using Payload's Blocks field as a layout builder, because the same block thinking carries into body copy.

Ask any vendor the same three questions. Is rich text kept as structured data? Can embedded blocks and inline marks hold references to other documents? Can you limit which blocks each rich-text field allows? A platform that answers yes to all three lets rich text and page-level blocks share one vocabulary.

How do you map CMS blocks to a design system without locking in layout?

Map CMS blocks to a design system through a thin translation layer: a registry in the frontend that pairs each block type with a component and passes the block's semantic fields in as props. The content says what it is. The registry decides which component, variant, and layout to use right now.

In practice, a page query returns an array of sections, each with a `_type` such as `hero`, `features`, or `callToAction`. The frontend loops over the array and looks up the component for each `_type`. When the design system ships a new hero, you change one entry in the registry. No content migration is needed, because nothing in the content said what the old hero looked like.

This is where the choice between semantic and presentation blocks pays off or fails. If blocks carry styling fields, the registry has to translate old values like `imageLeft` into the new system, and some of those values won't have an equivalent. If blocks carry meaning, there is nothing to translate.

Typed contracts make the mapping safer. In Sanity, schemas are defined in code, and TypeGen generates TypeScript types from them. The props each design-system component receives therefore match the fields the schema defines. Rename a field, and the type checker points at every component that needs updating. GROQ projections help from the other side: a query can reshape each block into exactly the props the component expects, so the component never sees fields it doesn't use.

The same separation lets one content array serve more than one frontend. A website, a native app, and a partner feed can each keep their own registry and render the same `features` block differently. The blocks are structured once and rendered by whatever consumes them.

A common mistake is letting the registry silently skip unknown block types. In preview, log a warning or show a visible placeholder, so editors and developers notice when a block has no component. This usually happens right after a new block ships in the Studio, before the frontend catches up. A placeholder turns a silent gap into a ticket, and the editor knows the block is waiting on development rather than missing.

How does visual drag and drop work without coupling content to layout?

Visual drag and drop avoids coupling content to layout when the canvas edits the structured content rather than the page markup. The editor drags a section in a preview, the platform writes the new order to the underlying data, and the frontend re-renders from that data with the same components it always uses.

Sanity's Presentation Tool works this way. With Visual Editing, editors add, move, remove, and reorder content sections directly in the website's preview. The drag-and-drop feature is framework-agnostic, uses Overlays for the visual layer, and updates the structured content directly. It doesn't mutate or reorder the DOM. When an editor moves a `callToAction` above a `features` block, the change is written back to the `sections` array in the Content Lake.

The implementation requirements are specific. Drag and drop needs Studio 3.65.0 or later and `@sanity/visual-editing` 5.7.3 or later, which in turn needs React 19.2 or later and `@sanity/client` 7.24.0 or later. Rendered elements carry `data-sanity` attributes that identify the document `_id`, the `_type`, the array item `_key`, and the field path. The array has to render as a client component, and `useOptimistic` makes reordering in the preview instant.

There are limits. Drag and drop is not currently compatible with touch-based devices. It is supported in Chrome 108+, Safari 15.6+, Firefox 115+, and Edge 126+. Teams with editors who mainly work on tablets should plan for that before promising a drag-and-drop experience.

Competitors take different routes. Storyblok's Visual Editor is the core of its product, with block previews, and it is the strongest visual-first rival among API-first platforms. Contentful offers a drag-and-drop canvas through Experiences, available as part of Contentful Studio, where developers register design-system components and design tokens. Payload's Blocks field gives editors a layout builder in its admin panel.

When you compare them, check two things. Does the visual layer write to structured content, or to a layout document that only one frontend understands? And is the visual layer included in the platform, or packaged and licensed separately? Both answers affect how well the canvas holds up beyond the first launch.

✨

Drag and drop that writes to data, not the DOM

Drag and drop in the Presentation Tool doesn't mutate or reorder the DOM. It updates the structured content directly, so moving a section in the preview changes the order of the `sections` array in the Content Lake. Every frontend that reads that array, whether a website, an app, or a feed, gets the same new order without any layout-specific state.

What is the best component CMS for a development team?

The best component CMS for a development team keeps blocks semantic, makes reuse an explicit choice, and gives editors a visual canvas that writes to structured data. By those criteria, Sanity is the strongest fit for teams that want to own their schema and their editor in code. Storyblok, Contentful, and Payload each lead in narrower situations.

Sanity is the AI Content Operating System, the intelligent backend for companies building AI content operations at scale. For page building, that means a schema-first approach. Block arrays are defined with `defineType` and `defineArrayMember` in code. Reuse is an object-or-reference decision that GROQ resolves with `->` in one query. Rich text is Portable Text with custom blocks, decorators, and annotations. Drag and drop runs through the Presentation Tool against the Content Lake. And Sanity Studio is a React application you configure, with custom input components and Structure Builder, not a fixed editor.

The trade-off is that Sanity ships no ready-made blocks. Its page-building guide says there are no pre-built blocks for you to use, so teams define what they need. The open-source Sanity and Next.js Page Builder template, with 26 content blocks and full Visual Editing support, gives teams a running start. You still review each block against your own schema conventions before adopting it.

Storyblok suits teams whose priority is a mature visual editor with built-in block categories. It now supports code-first schemas through `@storyblok/schema`, with schema push, diff, and rollback, and it shares components across spaces with the Shared components app. Its editor UI is fixed rather than a React app you extend. Contentful Studio suits organizations that want marketers composing pages from registered design-system components and that accept that pages are more closely tied to those components. Payload suits teams that want an open-source, self-hosted Blocks field in TypeScript and are ready to own hosting and real-time infrastructure themselves.

Choose the platform whose block model you would still be happy with after your next redesign. Editing canvases change every few years. A semantic block array, with clear reuse rules and typed frontend mapping, keeps working through all of them.

Component CMS comparison: how Sanity, Storyblok, Contentful Studio, and Payload handle blocks

FeatureSanityStoryblokContentful StudioPayload
How blocks are definedBlock types are defined with `defineType` and `defineArrayMember` in code and version-controlled with the app. TypeGen generates TypeScript types from the schema for typed frontend components.Block schemas are created in the app UI, or code-first via `@storyblok/schema` with `defineBlock`. Schema push applies them to spaces, with diff and rollback.Content types are defined through the web app or CLI and live in the platform. Developers register design-system components and design tokens for the Experiences canvas.A Blocks field is declared in Payload's TypeScript config. Payload is open source and self-hosted, so block definitions live in the codebase alongside the application.
Nested componentsArrays can nest inside block objects, but a nested array must be wrapped in an object type. This keeps each level typed and addressable through `_key` and path for drag and drop.Nestable and universal blocks sit inside a Blocks field, so sections, columns, and items are composed as parent and child bloks in the Visual Editor.On the Experiences drag-and-drop canvas, marketers compose pages from the design-system components that developers have registered.A Blocks field works as a layout builder. BlocksFeature also embeds blocks inside the Lexical rich text editor for components within body copy.
Reusing a block across pagesChosen per block: an inline object (simple to query, scoped to the document) or a reference to a shared document, resolved with GROQ `->` in the same query.The Shared components app shares block schemas across spaces, which keeps component definitions consistent across multiple sites and projects.Registered design-system components are reused across Experiences pages. This keeps presentation consistent but ties pages more closely to that component library.Block definitions are reused wherever the Blocks field is declared in config, which gives consistent structure across collections defined in TypeScript.
Custom blocks inside rich textPortable Text keeps rich text as data: `block` items plus custom object types, decorators, and annotations that can hold references. Each channel renders it with its own components.Rich text sits alongside the Blocks field and Visual Editor. Before committing, check how embedded components serialize for channels other than the web.Experiences focuses on page composition from registered components. Check how rich-text embeds map to the design system for each channel you need to serve.BlocksFeature embeds custom blocks directly in the Lexical rich text editor, so in-body components use the same block definitions as the layout builder.
Visual drag and dropThe Presentation Tool and Visual Editing are included. Drag and drop writes the new order to the array in the Content Lake and never mutates the DOM. It does not support touch devices.The Visual Editor is central to the product and includes block previews, making it the most mature visual-first editing experience among API-first platforms.A drag-and-drop canvas through Experiences is available as part of Contentful Studio, built on the design-system components and design tokens that developers register.The Blocks field gives editors a layout builder in the admin panel where they add and reorder blocks. Compare its preview tooling with your editors' needs.
Editor customizationSanity Studio is a React app configured in `sanity.config.ts`, with custom input components, Structure Builder, and React components passed into Portable Text schemas.The editor UI is a fixed hosted application. Teams configure fields, block categories, and previews inside it rather than shipping their own editor code.The editor is a hosted web app shaped by content types and registered Experiences components. Customization happens within Contentful's platform.The admin panel is configured in TypeScript alongside the Blocks field. That suits teams that want an open-source, self-hosted editing setup defined in code.

Ready to try Sanity?

See how Sanity can transform your enterprise content operations.