Skip to main content
info@drupalodyssey.com
Tuesday, November 17, 2026
Contact

Main navigation

  • Home
  • Services
  • Insights
  • Notebook
  • About
Search
Insights Articles

Future-Proofing Business Data: Structured Content Models vs. Page Builders

November 17, 2026

Here's a scenario I've seen play out more than once.

A local boutique hires someone to build their website. The developer picks a popular visual page builder — drag, drop, done. It looks great. The client is thrilled. Fast forward two years, they want a mobile app. New developer opens the database. Their entire "Business Hours" section is a block of raw HTML sitting in a single column: <div class="hours-block">Mon–Fri: 9–5</div>. No hours field. No API to call. Nothing a mobile app or AI search crawler can consume without scraping HTML and hoping nothing breaks.

That's not a Drupal problem. That's a content architecture problem — and the page builder sold it to them as a feature.

One framing note before the comparison. Drupal now has its own visual page builder, Canvas (formerly Experience Builder) [3]. This article isn't an argument against visual editing. The pattern this post is about is page builders that store content as layout markup: a serialized blob in a single database column, no meaningful field separation. That's the architecture we're comparing against.

Bottom Line for Stakeholders

Scenario Page Builder Structured Content (Drupal)
Redesign in 2 years Rebuild page by page Update templates; content untouched
Mobile app in 3 years Rewrite or scrape HTML JSON:API in core — one module install, read-only by default [1][6]
AI search visibility SEO plugin bolted on after the fact Structured fields map cleanly to Schema.org with a contrib module [2]
Platform migration Manual HTML extraction Field-to-field migration mapping instead of HTML extraction

What Gets Stored (The Fine Print Nobody Shows You)

Visual page builders store content as flattened HTML strings or tightly coupled layout metadata in a single database column. Fast on day one. That's the pitch, and it's true. What they don't show you is what happens when that content needs to live somewhere else — a different template, a mobile app, a voice assistant, a chatbot integration.

The answer is: it can't. Not cleanly.

Structured content modeling flips this. In Drupal, your "Location" entity doesn't store an HTML block called "Our Store." It stores an address field, a latitude/longitude field, a business hours field, a phone number field, an image field. Each piece is discrete, typed, and queryable. The CMS knows what your content means, not just how to display it.

Change the theme? Your data is untouched. Spin up a mobile app? JSON:API — a module in Drupal core, one install away — exposes every entity you've modeled as a clean, queryable endpoint [1]. It's read-only by default [6], which is usually exactly right for anything consuming data externally.

AI search crawler hits your site? Structured fields make mapping to Schema.org JSON-LD straightforward and reliable — via contrib like Schema.org Metatag [7] or Schema.org Blueprints [2] — instead of trying to scrape that meaning out of raw HTML.

That's the difference. Not features. Architecture.

The Drupal Way — Meaning Separate From Presentation

Here's how I approach this with clients starting from scratch.

For a typical business — a shop, a service provider, a restaurant — I model five to seven content types before writing a line of code:

  • Location — address, hours, lat/long, phone, service area taxonomy
  • Service — description, pricing tier, reference to Location, category taxonomy
  • Event — date, referenced Location, registration URL, image
  • Staff — name, role, bio, headshot
  • Testimonial — quote, attributed customer name, linked Service
  • Product — name, SKU, pricing, inventory flag, related Service
  • FAQ — question, answer, related Service or category taxonomy

Each one gets discrete fields, not a formatted text area where editors paste whatever they want. A Service entity has a pricing tier field, not a paragraph that mentions price somewhere in a block of HTML.

Twig templates and Layout Builder handle how this gets displayed.

Worth being clear about what Layout Builder actually is: it's a display configuration layer, not a content storage model. Structured fields stay structured underneath it. Change the layout completely — the data doesn't move. That's a fundamentally different architecture from a page builder that stores layout and content together in the same blob.

One caveat worth making explicit: Layout Builder's per-node overrides with inline, non-reusable blocks store content inside that node's layout — which is the same coupling you're trying to avoid. Use field blocks and reusable blocks. Keep inline-block content minimal. Prefer section defaults over per-node customization. The model holds up when you work with it the right way.

Layout Builder is a display tool. Structured content types are the foundation.

The Hidden Tax — A 3-to-5-Year Lifecycle View

I've watched this pattern play out enough times that I've stopped treating it as an edge case.

Year one or two: the page builder site launches fast, looks great, client is happy. The builder is winning every comparison, including cost. Fair enough — for a static brochure site that never changes and never needs to talk to another system, it might stay that way.

But few businesses stay static.

Year two or three: the redesign brief arrives. New brand direction. New content structure. The developer opens the page builder and discovers that every section of every page is a custom-built block — sixty pages, hundreds of custom blocks, no templating. The rebuild estimate is roughly twice what anyone expected. Nobody told the client that "flexibility" in the builder meant manual work at every touch point.

Year three to five: the mobile app RFP. The loyalty program integration. The chatbot that needs to answer "what are your hours?" without parsing HTML. The agency opens the CMS. The content is HTML. The bill for the "free" page builder comes due: re-enter everything, or pay someone to model and migrate it.

I'd do it differently for almost every client on that path. Not because Drupal is always the right answer — for a genuinely static five-page site with no growth horizon, it might not be. But once your business data needs to mean something to another system, you want it stored that way from day one.

Omnichannel and AI Readiness — Without Going Headless

Here's where the architecture conversation stops being theoretical.

AI search engines — ChatGPT, Perplexity, Google's AI Overviews [4] — work better when content is structured. The issue isn't that they can't parse HTML; they can. The issue is that raw HTML doesn't tell them what things are. An hours-block div and a price-block div are both divs. Typed fields — a business_hours field, a price field — remove that ambiguity. JSON-LD served from those fields makes it explicit.

Structured data also complements your Google Business Profile listing [5] and can make your pages eligible for rich results in search [8]. Those aren't things you bolt on after the fact with a plugin scraping your content. They're the natural output of a well-modeled site.

Here's the caveat I give every client who reads "omnichannel" and imagines an expensive decoupled architecture: you don't need to go headless to get most of this. A traditional coupled Drupal site with a solid content model covers most of the omnichannel benefit. JSON:API is in Drupal core [1] — one module to enable, and your content is queryable. Most businesses don't need a Next.js frontend. They need a content model.

My Actual Playbook — Model First, Build Second

Content modeling is where the real architecture work happens. Most of it takes place on paper or a spreadsheet, before anyone touches Drupal's UI.

Step 1: Audit your content. What distinct "things" does your business talk about? Not pages — things. Locations, services, events, staff, products, testimonials. Each "thing" is probably a content type.

Step 2: Define the fields. For each content type, list every piece of discrete information that belongs to it. If you'd ever want to display it separately, filter by it, or pass it to another system — it's a field, not a paragraph.

Step 3: Build in Drupal. Use core field types or Paragraphs where composition is needed. Avoid embedding formatted HTML in plain text areas. That's how you build the same trap you're trying to escape.

Step 4: Model the relationships. A Service entity should reference a Location entity. An Event should reference a Location. Taxonomy terms for service categories, location types, product lines — these aren't tags bolted on for SEO; they're the connective tissue of your content graph.

Step 5: Let the display consume the model. Twig templates, Layout Builder, Views — these work with your content model. Never model backward from a design mockup. The design changes. The data model shouldn't have to.

The upfront time is real. Editorial training takes a few hours. The payoff is a site that doesn't require a rebuild every time the business changes direction.

The page builder isn't the villain here. The wrong architecture for the job is.

Structured content modeling in Drupal isn't harder to use once it's built; for editors who've worked in both, it's often more consistent — fewer decisions at entry time, more predictable output. And for the business that commissioned the site, it's the difference between owning their data and being trapped by it.

Mapping out a content model or evaluating whether your current setup will hold up over a 3-to-5-year horizon? That's exactly the kind of architectural direction I work through with clients.

Map Out Your Content Model

Found a better approach for business data modeling? Share it with the community — the more real patterns we have on record, the better the starting point for the next build.

Sources

[1] https://www.drupal.org/docs/core-modules-and-themes/core-modules/jsonapi-module - JSON:API core module — documentation covering what the module does and how to enable it
[2] https://www.drupal.org/project/schemadotorg - Schema.org Blueprints module for Drupal
[3] https://www.drupal.org/project/canvas - Drupal Canvas (formerly Experience Builder) — Canvas contrib project page on drupal.org
[4] https://blog.google/products-and-platforms/products/search/generative-ai-google… - Google AI Overviews launch, May 2024
[5] https://support.google.com/business/answer/7091 - Google Business Profile, local ranking factors
[6] https://git.drupalcode.org/project/drupal/-/blob/11.x/core/modules/jsonapi/conf… - JSON:API read-only default — jsonapi.settings: read_only: true in Drupal 11.x core config
[7] https://www.drupal.org/project/schema_metatag - Schema.org Metatag module for Drupal — integrates Schema.org structured data into the Metatag ecosystem
[8] https://developers.google.com/search/docs/appearance/structured-data/intro-stru… - Google Search: Introduction to structured data
Author

Ron Ferguson

 

Next Blog

Ad - Header (728*90 AD)

Ad - Sidebar (300 x 600 AD)

Ad - Sidebar (300 x 250 AD)

Newsletter

Subscribe my Newsletter for new blog and tips.

Menu

  • Home
  • Services
  • Insights
  • Notebook
  • Portfolio
  • Resources
  • About

Legal

  • Privacy Policy
  • Terms & Conditions
  • Disclaimer
  • Cookies

I specialize in custom development, performance tuning, and reliable maintenance, delivering clean code and strategic solutions that scale with your business. Ready to discuss your project?

E: info@drupalodyssey.com
Fort Worth, TX

© 2026 All Rights Reserved.

Proud supporter of active military, veterans and first responders.