The WordPress page builder vs block editor question looks like a question about editing. It is really a question about what your content is stored as, and what that costs the day you upgrade, script a change or leave.

The short version
  • A page builder is a storage format first and an editor second. WPBakery and Divi 4 write shortcodes into your pages. Cornerstone splits a page across the post, its own metadata and CSS generated per request. The block editor writes HTML with comment markers.
  • Shortcode residue is the real lock-in. Switch the builder off and pages show bracketed code. Pull them through the REST API and you get the same code.
  • Count before you panic. On a law firm's site we inventoried, 22.5% of pages carried builder markup and five tags made up 91% of it. That is a few converters, not a rewrite.
  • Builders are rarely the speed problem. The theme bundled with them and the plugins around them usually are.
  • Builders have major versions too. Divi 5 converts shortcodes one way only. Cornerstone has retired Global Blocks in favour of Components.
  • Our default for a new WordPress site: a custom theme, the block editor for content, patterns and locks for layout. For a site already on a builder: stop it spreading, and convert when a real rebuild trigger arrives.

Most of what we know about page builders comes from maintaining and migrating sites built on them. Demos show what a builder lets you make. Maintenance shows what it leaves in your database, and that is the half this piece is about.

22.5%
of one firm's pages carried builder shortcodes
5
tags made up 91% of that markup
4
records a Cornerstone page needs to agree
1-way
Divi 4 to Divi 5 conversion

What each builder actually saves

Strip away the drag-and-drop and every builder answers one question: when someone presses Save, what goes into the database?

What a saved page is With the builder switched off Who changes layouts Cost to leave
WPBakery Shortcodes such as [vc_row] in the page content Raw shortcodes on the page Editors, in the builder Convert every tag
Divi 4 Divi shortcodes in the page content Raw shortcodes Editors, in the builder Convert every tag
Divi 5 Block-format markup with Divi's own block names Not documented; we haven't tested it Editors, in the builder Unknown until tested
Cornerstone (Themeco Pro) A content wrapper, a JSON element tree, page settings, CSS compiled at request time Markup with generated class names and no stylesheet Editors, in the builder Rebuild templates and styles
Block editor HTML with comment delimiters; settings as JSON in the comment The HTML, for static blocks Developers set patterns and locks; editors work inside them Low
Custom theme with fields Field values; layout lives in theme code Your content, as data A developer Low for content, templates rebuilt

WordPress documents the block format plainly: blocks are distinguished by HTML comments that act as delimiters, their settings are stored as a JSON object inside that comment, and a static block's markup is saved to the database. That last part is why the block editor is the cheapest exit on the list. The saved HTML is still HTML when the theme, the plugin or WordPress itself is gone.

Elementor is the most searched builder of the lot, and it isn't in the table. We haven't inherited or maintained an Elementor site, and this piece is built from maintenance, so we've left it out rather than paraphrase its marketing.

Shortcode residue: what's left when you switch

Here is the start of a page from a deck builder's existing site, built before we were involved on a premium theme with WPBakery bundled in, fetched through the standard WordPress REST API. That route is the one any migration script or headless front end would use.

// GET /wp-json/wp/v2/pages, content.rendered (fetched 2026-11-16)
[vc_row type=”full_width_background” full_screen_row_position=”middle”
 column_margin=”20px” equal_height=”yes” content_placement=”middle” ...

The plugin is active on that site and the public page renders normally. The API returns the shortcodes unprocessed anyway. WPBakery's own troubleshooting guide says that when a page shows raw shortcodes, "the most common reason is that WPBakery Page Builder is deactivated", and that shortcodes can also surface in blog excerpts. Notice the curly quotes, too. WordPress's typography filter has already rewritten the attribute quotes in the API output, so a converter has to read the raw database content, not the API.

This is the lock-in. It doesn't stop the site working. It means every builder page must be converted before its content can live anywhere else.

How big is that job? Usually smaller than the fear. For a law firm's rebuild brief, we enumerated every public page and post through the same API:

  • 77 of 342 pages (22.5%) carried WPBakery markup. None of the 617 posts did, so the blog carried no builder markup at all.
  • The builder pages held 2,394 shortcode occurrences across 13 distinct tags. The top five tags were 91.4% of them.
  • 42 of the 77 builder pages were one repeating template, and eight more were another. That left about 27 bespoke builder pages.

That inventory is what set the schedule. A plan that says "rebuild 342 pages" prices the wrong thing; the real work is converters for a handful of tags, two templates, and a couple of dozen pages a person has to look at. The inventory is also the first step of any move off WordPress, which our static migration write-up covers end to end.

Each option, honestly

WPBakery

Right when: you've inherited it, the site works, and the people who edit it know it. Some premium themes bundle it; the deck builder's site above runs the copy that shipped inside its theme.

Wrong when: you're starting anything new. Every page built in it becomes a conversion job later.

What people underestimate: how far the shortcodes travel. They sit in the REST API output, in excerpts, and in anything else that reads post content without running the builder.

What people overestimate: the cost of converting. The distribution is steep. A few tags do almost everything, and you can count them before anyone writes a line of code.

Divi

We haven't maintained a Divi site, so this column is Elegant Themes' documentation, not experience.

Right when: you're already on it and want a builder moving towards WordPress's own storage format. Divi 5 saves pages in "serialized block format", wrapped in comment delimiters like the block editor's, with block names such as divi/section.

Wrong when: you might want to go back. The documentation is explicit that you won't be able to convert block format back to Divi 4 shortcodes, and that WordPress revisions are the way to undo a conversion.

What people underestimate: the in-between state. Divi 4 shortcodes stay in place after the upgrade and convert only when a page is opened in the Divi 5 builder and saved. For a while, a site holds both formats, page by page. Shortcodes Divi 5 doesn't recognise get wrapped in a "Shortcode Module" rather than converted.

What people overestimate: what block format buys you on exit. Same syntax as the block editor is not the same as portable. The blocks are Divi's, and what they render with Divi removed isn't covered in the documentation or anything we've tested.

Cornerstone (Themeco Pro)

We maintain Seubert's insurance and surety site on Pro and Cornerstone: events, practice landing pages, a staff directory and a large library of content.

Right when: a team wants a real visual builder with dynamic data in it. Cornerstone's Loopers and dynamic content pull custom fields and queries straight into layouts, so an event page can render its date from a field instead of typed text.

Wrong when: you need to change pages by script. A Cornerstone page is four records that must agree: the post content, a _cornerstone_data element tree, _cornerstone_settings, and a generated style index. Hand-write one and the others contradict it. Its document API also reads a page back as a tree but expects a flat list of sections on save. Hand it the tree and it saves an empty page, and WordPress keeps no revision to restore from. We snapshot every page before a scripted write and roll back automatically if a check fails.

What people underestimate: how much of the theme the builder replaces. Pro's layout builder overrides the theme's template files, so a child theme's category.php can be dead code while a layout serves the archive. Layouts are stored as JSON in the post content under their own post status, not where a WordPress developer would look first. Pro also ships global paragraph and heading rules marked !important on a 14px root font size. When we built practice landing pages for Seubert, the templates had to drop the theme's stylesheets entirely to render at the intended scale.

What people overestimate: how fragile it is in daily use. Edited in the builder by people who know it, and scripted only through its own API with a snapshot first, it is a steady platform. Check the post's edit lock before any scripted change, though: someone with the builder open will overwrite your change on their next save.

The block editor

Our first-hand evidence in this piece comes from builder sites. For the block editor we're leaning on WordPress's documentation, and saying so.

Right when: content has to outlive the design. Static blocks save their HTML, so the content survives a new theme or a move off WordPress.

Wrong when: non-technical staff need to invent new layouts without help. Out of the box they get columns and groups, and good layouts come from patterns a developer has built.

What people underestimate: locking. The Block Locking API can stop blocks being moved or removed, and a contentOnly lock hides the design tools so editors change words and images, not structure. By default, administrators control the locks.

What people overestimate: the portability of dynamic blocks. WordPress documents that a dynamic block saves only a placeholder comment with its attributes and generates the HTML on the server. A plugin's dynamic blocks are as tied to that plugin as any shortcode.

A custom theme

Right when: the site has repeated page types (practice areas, people, locations, events) that should be data, not hand-assembled layouts. Seubert's landing pages read the staff directory, a custom post type with structured fields, so a team card updates when the person's directory entry does. Form IDs come from a per-environment setting, because staging and production numbers differ.

Wrong when: marketing needs to launch new page types every week without a developer. That is the case for a visual platform, and our platform comparison says which.

What people underestimate: how much builders duplicate. Every event post on the site we maintain carries its own copy of an "Upcoming events" section, because each was duplicated from one template post. In a builder, changing that section means opening every copy. When the events needed to sort by event date, we fixed it once at the query, which every copy runs through, rather than editing dozens of pages.

What people overestimate: rigidity. Pair a custom theme with the block editor and a set of patterns and editors keep the freedom they use day to day, without the freedom to break the template.

WordPress page builder vs block editor on speed

Speed is the argument people reach for first, and in our experience it's the weakest.

The builder is rarely the bottleneck. On the law firm's WPBakery site, our first crawl reported a slow server response. That was wrong. The site rate-limits rapid requests, and our crawler had tripped it. Measured properly, the server's first byte arrived in about a third of a second when cached and about one second when not. Performance was not that site's problem, and we withdrew the claim.

The bundled theme usually weighs more than the builder. On the deck builder's decks page, 39 stylesheets and scripts load. Two come from the WPBakery plugin. Most of the rest come from the theme it shipped with and that theme's companion plugins.

Generated CSS is fine for speed and awkward for everything else. Cornerstone compiles its CSS during a real front-end request and inlines it, and its markup carries class names like e122-e1 m3e-0. Cached, that is quick. Take the content out through the API, though, and those class names point at styles that only exist inside a live page render.

The real cost is theme CSS that fights custom work. Global !important rules mean every custom component starts by overriding the theme. That costs developer time, not milliseconds. Measure with real throttling and several runs before blaming any platform.

Who can change layouts, and who can break them

In the WordPress page builder vs block editor decision, this is the row that should decide most builds.

Task Builder site Block editor + custom theme Custom theme with fields
Fix a typo Editor Editor Editor
Rearrange sections on one page Editor Editor, within patterns Developer
Restyle one section everywhere Every copy, by hand One pattern or theme change One template change
Add a new page type Editor can fake it; developer to do it properly Developer Developer
Change 40 pages by script Builder API, snapshot first Parse the HTML blocks Update field values
Break the design by accident Easy Hard, if locked Very hard

A builder gives staff layout power, and that cuts both ways. They can build a landing page on a Tuesday. They can also build forty slightly different copies of one section, and whoever restyles it next has forty jobs.

The block editor with patterns and locks puts the layout decisions with whoever builds the patterns, and the daily decisions with editors. A custom theme puts structure entirely in code. That is right when the structure should never change by accident, and wrong when the business needs new layouts faster than a developer can ship them.

Testing changes on a builder site

We test plugins in WordPress Playground, a throwaway WordPress that starts from one command, before they touch a client's site. The lesson worth passing on: install the live site's output-rewriting plugins in the test site, at the same versions. On one build, an image-optimisation plugin's lazy loading rewrote every image on a custom-rendered page into a blank placeholder. The loader script that swaps the real images back in comes through the footer hook, and that page never printed it. The local test had passed because the plugin wasn't installed.

On Cornerstone, every scripted write follows the same pattern: dump the post content and builder data to files, make the change through the builder's own document API, then check the page length, a string unique to the new content, and a string from a section that should not have changed. If any check fails, the snapshot goes back. It is cheap, and it turns a wiped page into a non-event.

Builders have major versions too

A builder isn't a neutral editing layer. It is a dependency with its own release cycle, and its upgrades are your migrations.

  • Divi 4 to Divi 5 changes the storage format, page by page, one way.
  • Cornerstone's Global Blocks are now marked "Legacy feature" and replaced by the Component Builder. Sites built in the Global Block era still use them. The site we maintain keeps its staff directory in one, edited in the builder rather than by script because it is serialized builder state.
  • Themeco publishes a Pro 5 to Pro 6 migration guide. If your theme and your builder are the same product, a theme upgrade is a builder upgrade.

The block editor isn't immune. WordPress documents that when a block's saved markup no longer matches what its code produces, the editor flags a validation error, and block authors ship deprecations to handle old versions. The difference is that WordPress maintains core blocks itself, on the release cycle you already follow.

What to do with the builder site you already have

If you're on a builder today, the WordPress page builder vs block editor question is rarely answered by "rebuild now".

  1. Stop it spreading. New page types go in as theme templates or block patterns. Every builder page you don't create is one you never convert.
  2. Take the inventory. Count builder pages, distinct tags and repeating templates through the REST API. It is a script, not a project, and it turns a vague fear into a number.
  3. Keep the builder for what it's good at. If in-house designers use it well, let them. Just keep it away from structured content like people, locations and events.
  4. Convert when a real trigger arrives. A builder alone isn't a rebuild reason. Our rebuild rubric has the five that are. When one fires, the inventory is most of the migration plan.

Our defaults

A comparison that won't pick is a brochure, so:

  • New content-heavy WordPress site → a custom theme, the block editor for content, patterns for layout, locks where the design must hold. Structured content (people, locations, events) as data, not pages.
  • Inherited WPBakery or Divi site that works → keep it, freeze new builder pages, convert at the next genuine rebuild.
  • Cornerstone site with designers who use it → keep it. Script only through its document API, snapshot first, and check the edit lock.
  • A non-technical team must create new layouts weekly → don't bolt a builder onto WordPress to fake that. It is the case where the hub says Webflow.
  • Moving off any builder → inventory the shortcodes first, then price the converters and the bespoke pages, not the page count.

Related comparisons: Squarespace vs WordPress for service businesses: stay or go? · Webflow vs Astro: when a marketing site should leave Webflow

If you've inherited a builder site and want to know what leaving would really cost, or whether you should leave at all, send us the URL. Our WordPress development work starts with exactly that inventory.

Common questions

Is the WordPress block editor better than a page builder?

For storing content, yes. Blocks are saved as ordinary HTML with comment markers, so a paragraph stays a paragraph when you change theme or leave WordPress. For letting non-technical staff invent new layouts, a builder is stronger out of the box; the block editor only matches it once a developer has built patterns and locked the parts that must not move. Our default for a new WordPress site is a custom theme with the block editor for content, and a builder only when in-house designers genuinely need it.

What happens to my pages if I deactivate WPBakery?

They show raw shortcodes. WPBakery stores layouts as bracketed tags like [vc_row] and [vc_column] inside the page content, and without the plugin nothing turns them into HTML. WPBakery's own troubleshooting guide names deactivation as the most common reason pages display shortcodes. The same tags come through the WordPress REST API and can leak into excerpts, so any migration has to convert them first. Count which tags your site actually uses before you price that work, because a handful usually account for nearly all of it.

Does Divi 5 still use shortcodes?

Not for content saved in Divi 5. Elegant Themes says Divi 5 stores pages in serialized block format, the same comment-delimited structure the block editor uses, with Divi's own block names. Divi 4 shortcodes keep rendering after the upgrade and convert when a page is opened in the Divi 5 builder and saved. The conversion is one-way: the documentation says you cannot turn block format back into Divi 4 shortcodes, so WordPress revisions are your undo. Back up before a site-wide upgrade.

Do page builders slow down WordPress?

Less than people assume. The WPBakery site we measured most carefully was fast once its cache was warm, and an earlier slow reading turned out to be our own crawler tripping the site's rate limit. On another builder site, two of the 39 stylesheets and scripts on a page came from the builder plugin; most of the rest came from the theme bundled with it. Measure with real throttling and several runs before blaming the builder, and look at the theme and plugins first.

How hard is it to migrate a site off a page builder?

It depends on how far the builder spread, which a short script against the REST API will tell you. Pull every page and post through the REST API and count the builder tags. On one law firm's site, 77 of 342 pages used WPBakery and none of 617 posts did; five tags made up 91 percent of the markup; and 50 of those 77 pages came from two repeating templates. That turned a frightening rebuild into a few converters and about 27 pages a person needed to look at.

Should I rebuild my website just to get rid of the page builder?

Usually not. A builder is a reason to stop building new pages in it, not a reason on its own to start over. If the site works and staff can publish, keep it, create new page types as proper templates or block patterns, and convert the builder pages when a real rebuild trigger arrives, such as a platform that cannot do what the business needs next. When that day comes, the shortcode inventory you took earlier is most of the migration plan.

What about Elementor?

We left it out of this comparison on purpose. Elementor is the most searched WordPress page builder, but we have not inherited or maintained an Elementor site, and everything here comes from maintaining and migrating real builder sites rather than reading feature pages. The questions still apply to it: what does it save into the database, what is left if the plugin is switched off, who can change layouts, and what does it cost to leave. Ask its documentation those four before you commit.