Custom WordPress Theme vs Page Builder: Field Data and One Page Built Five Ways

Custom WordPress theme vs page builder comes down to who edits the site and how long it has to last: a page builder suits non-developers who make new layouts often, and a custom theme suits sites that must last and follow a design system. Speed adds a warning. In HTTP Archive's September 2026 real-user data, 36.3% of sites detected running Elementor passed all three Core Web Vitals on mobile, against 48.3% of WordPress sites overall and 62.8% of sites detected using the Site Editor. That is a correlation across sites, not a test of the tools.
That data cannot see custom themes, so we also built one test page five ways on a local WordPress 7.1.4 and measured each build with Lighthouse 13.6.0. On Elementor with its Hello Elementor theme and free classic widgets, the page transferred 242 KB in 32 requests. On our custom theme it transferred 95 KB in 9. Beaver Builder Lite transferred 89 KB, but on an unstyled page with no web font. All five builds had median scores of 98 to 100 in this lab, so on a simple page the builder's cost showed up in bytes and requests, not in the score. When we deactivated Elementor or Beaver Builder, the page text stayed on screen as plain HTML. When we switched away from our custom theme, none of the page's own copy was left.
Keplaris ran this test and wrote the custom theme in it, build E. We also sell custom WordPress themes as part of our WordPress and custom web development work, so weigh our verdict with that in mind. That is why the test theme's code is printed in full below.
The limits of this test. Part of the field gap comes from hosting and audience, not from the builder. The lab is one small page on one Apple M1 Max with no CDN, no page cache and free tiers only, so read its bytes, requests and DOM before its timings.
Custom WordPress theme vs page builder: the short answer
Pick a page builder when non-developers need to make new layouts often and the site is small or short-lived. Pick a custom theme when the site has to last, follow a design system and stay lean as it grows. In between sits the block editor with a block theme, which gives editors layout freedom inside limits a developer sets.
| Factor | Custom theme | Block theme with core blocks | Page builder |
|---|---|---|---|
| Who changes layouts | A developer; editors fill the fields or blocks the developer defined | Editors, within patterns and presets the theme sets | Editors, with few limits |
| When it wins | Long-lived sites, a design system, structured content | Editors need some layout freedom and lean core output | Frequent new layouts with no developer on hand; small or short-lived sites |
| Main cost | Developer time for every new kind of layout | Time to set up patterns and locking; fewer ready-made widgets | Extra scripts and requests; in our one-page local lab, 110 KB of JavaScript on Elementor with free classic widgets, against 6 KB on our custom theme. Pro licences |
| What leaving cost in our removal test | Page copy lived in field data; nothing of it showed after a theme switch | Page copy lived in post_content as blocks; all of it showed after a theme switch | Elementor and Beaver Builder Lite, tested: text, links and images stayed as plain HTML, layout went. Divi 4 and WPBakery store shortcodes (vendor docs, not measured) |
| Detected sites passing all 3 Core Web Vitals on mobile, HTTP Archive, September 2026 | Not detectable | Site Editor 62.8%; Twenty Twenty-Five 44.6% | Elementor 36.3%, Divi 41.4%, WPBakery 38.7%, Beaver Builder 53.4% |
Several top-ranking comparisons mention a hybrid of custom theme and blocks as a third option, and none we read measures it. In field data the Site Editor group passed Core Web Vitals more often than any builder we pulled. That does not make it a free win: the Twenty Twenty-Five row shows how much the site behind the tool matters.
Custom theme, block editor (Gutenberg) or page builder: what each is and where it stores your layout
A custom theme is a theme written for one site, classic or block-based, that renders pages without a builder plugin. A page builder is a plugin (sometimes bundled with its own theme) that gives editors a drag-and-drop canvas and stores the layout in its own format. The third option is the block editor (Gutenberg), WordPress's core editor; with a block theme and the Site Editor, which WordPress also calls full site editing, it lays out headers, footers and whole pages from core blocks. The block editor is not a page builder plugin: it ships in WordPress core and there is nothing to deactivate. Bricks is the reverse case: its own site calls it a "visual site builder theme", so on Bricks sites the builder is the theme layer.
Where a tool stores your layout decides how hard it is to leave. We measured storage for the five builds in our lab and took the rest from vendor documentation:
| Option | Free tier | Where the layout is stored | Source |
|---|---|---|---|
| Custom classic theme with ACF fields (our build E) | Yes, ACF free | Page copy in post meta, one row per field plus ACF's reference rows; markup in the theme's template files; post_content empty | Measured |
| Block theme, Site Editor (build A) | Yes, core | post_content as HTML with block comments; header and footer as template part posts tied to the theme | Measured |
| Elementor (builds B and C) | Yes | JSON in post meta (_elementor_data), plus a plain HTML copy of the text, links and images in post_content | Measured |
| Beaver Builder Lite (build D) | Yes | Serialized node data in post meta (_fl_builder_data), plus an HTML copy in post_content | Measured |
| Divi 4 | No | Shortcodes in post_content | Elegant Themes, not measured |
| Divi 5 | No | A format that "mimics WordPress's native blocks" | Elegant Themes, not measured |
| WPBakery | No | Shortcodes | WPBakery developer docs describe its elements as shortcodes; storage not measured |
Elegant Themes' own explainer says Divi 4 "used WordPress's native shortcode system to organize its builder elements" and that "if you have ever disabled Divi and visited a page you built with the Divi Builder, you would have seen these shortcodes." The same Divi 5 storage post says "Divi 5's new storage format mimics WordPress's native blocks"; it does not say what a page shows when Divi 5 is turned off. WPBakery's developer documentation describes its elements as shortcodes.
If the real question is whether WordPress is the right CMS at all, coupled or headless, that is a separate decision, and our WordPress vs headless CMS comparison covers it.
Do page builders slow down WordPress? What real-user data shows
In real-user data, sites using the most common builders pass Core Web Vitals less often than WordPress sites overall, and the gap is in loading. Elementor origins passed all three metrics on mobile at 36.3%, WPBakery at 38.7% and Divi at 41.4%, against 48.3% for WordPress and 62.8% for the Site Editor group.
Source: CrUX real-user data via the HTTP Archive Technology Report, mobile, origins, month 2026-09-01, pulled 2026-11-09 from cdn.httparchive.org/v1 (the latest month the API returned that day). "Passed all 3" means good LCP, INP and CLS at the 75th percentile of page loads. HTTP Archive assesses an origin with no INP data on the remaining metrics, which is why the INP counts are smaller. Rows are grouped, core WordPress first and then builders in alphabetical order; this is not a ranking.
| Technology detected (HTTP Archive) | Mobile origins, Sept 2026 | Passed all 3 Core Web Vitals | Good LCP | Good INP | Good CLS | Good TTFB (not a Core Web Vital) |
|---|---|---|---|---|---|---|
| WordPress (all) | 2,658,175 | 48.3% | 55.4% | 90.3% | 87.3% | 22.9% |
| WordPress Block Editor | 543,833 | 52.0% | 60.4% | 90.4% | 86.6% | 25.0% |
| WordPress Site Editor | 49,586 | 62.8% | 68.2% | 90.3% | 93.1% | 29.2% |
| Twenty Twenty-Five | 3,012 | 44.6% | 50.1% | 79.4% | 92.2% | 18.7% |
| Beaver Builder | 28,327 | 53.4% | 58.3% | 95.3% | 89.7% | 22.9% |
| Breakdance | 5,273 | 56.3% | 61.0% | 94.1% | 93.3% | 22.1% |
| Bricks | 10,701 | 54.8% | 59.3% | 92.5% | 93.9% | 23.8% |
| Divi | 150,144 | 41.4% | 48.5% | 94.5% | 81.0% | 18.4% |
| Elementor | 877,513 | 36.3% | 41.0% | 88.3% | 88.7% | 15.2% |
| Hello Elementor | 244,654 | 37.6% | 41.6% | 89.7% | 91.3% | 15.7% |
| Oxygen | 11,306 | 51.3% | 60.6% | 92.2% | 85.1% | 23.3% |
| WPBakery | 217,664 | 38.7% | 44.9% | 91.9% | 83.6% | 17.1% |
"Mobile origins" counts origins with enough data for the overall pass rate. Each metric has its own count, and INP has the fewest: Twenty Twenty-Five's INP figure comes from 2,094 origins. TTFB is not a Core Web Vital; it is in the table because it shows the hosting confound in the next section.
Elementor's lower pass rate is not one bad month. Its best month in the 13 to September 2026, at 37.7%, was still below WordPress's worst, at 45.0%.
In this data the gap is in loading, not interaction: INP was good on 88% or more of origins for every builder in the table, while LCP was good on 41.0% of Elementor origins against 55.4% of WordPress origins overall. Slow LCP usually means heavy pages, slow servers or both. HTTP Archive's median mobile home page on Site Editor origins weighed 1,971 KB with 396 KB of JavaScript, against 2,940 KB and 710 KB on Elementor origins.
Is it the builder or the site behind it? Hosting, rank and sample checks
Part of the gap is the builder, and part is who uses it and where they host. The table above cannot separate the two, so here are three checks on it.
Hosting. TTFB mostly reflects hosting and caching more than the builder, yet TTFB was good on 15.2% of Elementor origins and 29.2% of Site Editor origins. Some of the Core Web Vitals gap likely comes from hosting and the kind of site that tends to use each tool.
Rank. Restricting to the top million origins by CrUX rank changes some results:
| Technology detected | Top-1M origins, Sept 2026 | Passed all 3, top 1M | Passed all 3, all origins | Passed all 3, 13-month range, all origins (2025-09 to 2026-09) |
|---|---|---|---|---|
| WordPress (all) | 110,537 | 50.1% | 48.3% | 45.0% to 49.5% |
| WordPress Block Editor | 25,207 | 51.5% | 52.0% | 48.1% to 53.7% |
| WordPress Site Editor | 1,789 | 59.4% | 62.8% | 59.6% to 64.0% |
| Twenty Twenty-Five | 74 (small sample) | 52.7% | 44.6% | 38.6% to 46.4% |
| Beaver Builder | 688 | 56.5% | 53.4% | 50.9% to 54.8% |
| Breakdance | 165 (small sample) | 49.7% | 56.3% | 52.2% to 57.7% |
| Bricks | 410 (small sample) | 46.3% | 54.8% | 51.7% to 55.7% |
| Divi | 2,315 | 40.4% | 41.4% | 38.7% to 43.1% |
| Elementor | 25,844 | 36.7% | 36.3% | 33.4% to 37.7% |
| Hello Elementor | 5,905 | 37.5% | 37.6% | 35.1% to 39.2% |
| Oxygen | 415 (small sample) | 46.0% | 51.3% | 49.4% to 53.2% |
| WPBakery | 7,061 | 38.4% | 38.7% | 34.8% to 39.4% |
Bricks, Breakdance and Oxygen beat WordPress overall across all sites, then fell below it within the top million, on samples of 165 to 415 origins. That pattern suggests their lead reflects who uses them as much as the tools themselves. Elementor, Divi and WPBakery sat below WordPress in both cuts. Beaver Builder sat above it in both, on 688 origins in the top million.
What a "block theme" row means. The Site Editor group passed at 62.8%, but origins detected with Twenty Twenty-Five passed at 44.6%, and their INP good rate of 79.4% is the lowest in the table. A block theme is not a guarantee; what is built on it still matters.
Three more caveats. These are correlations across sites, not a test. Detection runs Wappalyzer on the home page, and labels overlap: Hello Elementor sites are also Elementor sites, and many Elementor sites also register as Block Editor. And a custom theme cannot be detected at all, so field data cannot compare custom themes with builders. That is why we built the lab.
Custom theme vs Elementor in the lab: the same page built five ways
On one test page, our custom theme transferred 95 KB in 9 requests and Elementor 235 to 242 KB in 28 to 32, and every build's median Lighthouse score was 98 to 100. Beaver Builder Lite, on an unstyled page, transferred 89 KB in 12. The builder cost was real but small on a page this simple. The rule from our Shopify speed guide holds on WordPress too: "diagnose with lab data, judge success with field data."
Method. Two of the ten top-ranking pages we read on 2026-11-09 quote size ranges for builders without a method, test pages or tool versions, so we built our own. One local stack in Docker: the wordpress:latest image (WordPress 7.1.4, PHP 8.3.36, Apache 2.4.69) and mariadb:11 (MariaDB 11.8.9), on an Apple M1 Max. Every build used the same copy from one JSON file: a header with a text logo and four links, a hero with an H1, a paragraph, a button and a 1600x900 JPEG, three cards, a testimonial with a 96x96 avatar, a call-to-action band and a three-column footer. The page is a fictional architecture studio, labelled as a test page. Only the build's own theme and plugin were active while it was measured, with no cache or optimisation plugin and nothing changed from each tool's defaults. We loaded each page once before measuring, because Elementor writes its per-page CSS on first view, and checked a screenshot of each build.
- A. Block theme: Twenty Twenty-Five 1.5, the theme the fresh install activated, with page content in core blocks and the header and footer as edited template parts.
- B. Elementor on its own theme: Elementor 4.3.6 on Hello Elementor 3.5.2, free widgets (Heading, Text Editor, Button, Image, Testimonial) in containers, on the Elementor Canvas template, header and footer as sections on the page because Elementor's Theme Builder is Pro only. We saved the layout through Elementor's own document save, not by writing the database directly.
- C. Elementor on our test theme: the same layout, to separate Elementor's cost from Hello Elementor's.
- D. Beaver Builder Lite 2.11.1.2 on our test theme's blank template, built with Beaver Builder's own layout API. Lite has no testimonial module, so the testimonial is a photo and two text modules.
- E. Our custom classic theme with ACF 6.8.11 free fields: one hand-written stylesheet, one self-hosted Manrope WOFF2 copied from Twenty Twenty-Five, no build step. Our client builds use Tailwind, as our service page says; this test theme does not.
Elementor's defaults matter here. On activation its feature flags showed Atomic elements and optimised markup on, and optimised CSS files off. We built with the classic widgets, not the new Atomic elements, so Atomic output is not measured. By default it also loaded Roboto and Roboto Slab from Google Fonts.
What we excluded: Divi, Bricks, Oxygen and Elementor Pro need paid licences. Breakdance has a $0 plan, but it is not on WordPress.org and its download page sends you to an account portal, so we could not install it with WP-CLI. Paid builders appear only in the field data.
Timings depend on the host, so read bytes, requests and DOM first. Pro widgets and add-on packs may add more. We wrote build E ourselves and sell custom WordPress themes, so its code is below for you to check.
These are lab numbers from one small page on one machine, not a measure of how fast real sites built with each tool are. Each figure is the median of 3 Lighthouse 13.6.0 mobile runs on WordPress 7.1.4, 2026-11-09:
| Build (one local test page, free tiers) | Transfer | Requests | DOM elements | JavaScript | CSS | Fonts | Lab LCP | Lab TBT | Lab CLS | Median Lighthouse mobile score |
|---|---|---|---|---|---|---|---|---|---|---|
| A. Twenty Twenty-Five, core blocks | 102 KB | 9 | 95 | 6 KB | 3 KB | 54 KB | 1.43 s | 0 ms | 0.000 | 100 |
| B. Elementor 4.3.6 on Hello Elementor, classic free widgets | 242 KB | 32 | 128 | 110 KB | 23 KB | 72 KB | 2.00 s | 0 ms | 0.000 | 98 |
| C. Elementor 4.3.6 on our test theme, classic free widgets | 235 KB | 28 | 127 | 109 KB | 17 KB | 72 KB | 1.99 s | 0 ms | 0.000 | 98 |
| D. Beaver Builder Lite, unstyled defaults, no web font | 89 KB | 12 | 135 | 49 KB | 5 KB | 0 KB | 1.45 s | 0 ms | 0.000 | 100 |
| E. Our custom theme with ACF, written by Keplaris | 95 KB | 9 | 78 | 6 KB | 1 KB | 54 KB | 1.28 s | 0 ms | 0.000 | 100 |
Transfer sizes are compressed bytes as Lighthouse recorded them (Apache gzipped the stylesheet we checked on each build), in decimal KB. The full output, with the throttling settings, is in the last section.
What the table shows, build by build:
- Elementor's extra weight is mostly JavaScript and fonts. Against build B, our custom theme transferred 147 KB less in 23 fewer requests. Build B loaded 11 scripts (110.2 KB), including jQuery (30.7 KB) and Elementor's background slideshow and background video scripts (8.3 and 8.6 KB), on a page with no slideshow or video. Another 72.4 KB of font files, plus 4.4 KB of font CSS, came from Google Fonts' servers. Hello Elementor itself added little: build C, the same layout on our test theme, transferred 7 KB less in 4 fewer requests.
- Beaver Builder Lite transferred the least, 89 KB, and its page was unstyled. Its modules at their defaults, on a template with no theme CSS, rendered in the browser's default serif font with no colours, so it loaded no web font at all. Treat 89 KB as a floor, not a matched design. It also had the most DOM elements, 135, and loaded jQuery (30.7 KB).
- The block theme and our custom theme were close. Both loaded 9 requests, and the only script on each was WordPress core's emoji loader (5.7 KB). Of build E's 95 KB, 54 KB was the Manrope font file.
- Every build passed the lab LCP threshold of 2.5 seconds, with no blocking time and no layout shift. Builds A, D and E had a median score of 100 in this local lab.
The hero H1, traced through every build
To see what a builder wraps around content, we followed the hero H1 through each build: how many elements sit between <body> and the H1, and how many bytes of CSS the HTML asks for before the H1 (stylesheets that apply on a 412 px wide screen, decoded, plus inline style blocks):
| Build | Elements between body and H1 | CSS requested before the H1, decoded |
|---|---|---|
| A. Twenty Twenty-Five | 4 | 67 KB (21 KB linked, 46 KB inline) |
| B. Elementor on Hello Elementor | 4 | 225 KB (209 KB linked, 16 KB inline) |
| C. Elementor on our test theme | 4 | 205 KB (190 KB linked, 15 KB inline) |
| D. Beaver Builder Lite, unstyled | 7 | 37 KB (22 KB linked, 15 KB inline) |
| E. Our custom theme | 2 | 17 KB (3 KB linked, 15 KB inline) |
The decoded figure for B and C includes Elementor's stylesheets and the Google Fonts CSS as served to a Chrome user agent; compressed, B's stylesheets transferred 23 KB. Here is B's hero H1 with its wrappers, as we saved it from the page:
<div class="elementor-element elementor-element-a000008 e-flex e-con-boxed e-con e-parent" data-id="a000008" data-element_type="container" data-e-type="container">
<div class="e-con-inner">
<div class="elementor-element elementor-element-a000004 elementor-widget elementor-widget-heading" data-id="a000004" data-element_type="widget" data-e-type="widget" data-widget_type="heading.default">
<h1 class="elementor-heading-title elementor-size-default">Quiet buildings designed for the way people actually live</h1>
And E's:
<main>
<section class="hero wrap">
<h1>Quiet buildings designed for the way people actually live</h1>
What this lab does not show
- No CDN, no page cache, no real network. A caching plugin changes timings. WP Rocket's comparison of 10 builders on one test page, a vendor testing its own product, reports one before and after, on WPBakery: "WP Rocket improved the siteโs overall performance score from 80/100 to 100/100". We have not reproduced it.
- One small page. Real builder sites carry more images, plugins and Pro widgets; HTTP Archive's median Elementor home page weighed 2,940 KB, more than ten times our build B.
- Free tiers and classic widgets only. We did not test Elementor's Atomic elements, Pro widgets or add-on packs.
- Not a matched visual design. Each build used its tool's default styling, so the pages share content and structure, not pixels.
- INP is not measured. It needs real interactions; the field data covers it.
What happens to your content when you leave a page builder
In our removal test, free Elementor and Beaver Builder Lite both left readable HTML behind, and our custom theme left none of the page's own copy on screen. Every option leaves something behind. The question is whether it is readable HTML or a format only one tool can render.
For each build we saved post_content and the post meta, removed the tool (deactivated the builder plugin, or switched the theme), loaded the page, and counted how much of the page's own copy was still visible: 18 copy blocks (headings, paragraphs, links, quote, name and role) and the 212 words in them. Then we restored each build and checked it rendered again.
| Build | What we removed | post_content | Meta rows | Copy visible after removal | Hero image | Button text as links |
|---|---|---|---|---|---|---|
| A. Block theme | Switched to our classic theme | 4,124 bytes, 28 block comments, 11 <div | 1 | 18 of 18 blocks | Yes | 2 of 2 |
| B. Elementor on Hello | Deactivated Elementor | 2,841 bytes of plain HTML | 8 | 18 of 18 blocks | Yes | 2 of 2 |
| C. Elementor on our test theme | Deactivated Elementor | 2,841 bytes of plain HTML | 8 | 18 of 18 blocks | Yes | 2 of 2 |
| D. Beaver Builder Lite | Deactivated Beaver Builder | 2,729 bytes of HTML, 1 block comment | 5 | 18 of 18 blocks | Yes | 2 of 2 |
| E. Custom theme with ACF | Switched to Twenty Twenty-Five | Empty | 41 | 0 of 18 blocks | No | 0 of 2 |
No build left shortcodes. Elementor wrote a plain HTML copy of the text into post_content when the page was saved, and Beaver Builder's save does the same (its code comment calls it "stripped down content"). So after removal the words, links and images were all there, but the layout was not: no columns, no colours, and the buttons were plain links. The builder data stayed in post meta, so reactivating either plugin restored the page. With A, B and C the fallback template also printed the page title as a second H1.
Our custom theme is the one that locked the content in. Its copy sat in ACF meta, a value row and a field reference row for each of 20 fields, which only its templates render, so after the switch the page showed nothing of its own. The 16 of 212 words that still matched came from text around the page, such as the header and footer that Twenty Twenty-Five already held from build A. ACF's field data is still in the database and can be moved, but someone has to write the templates or a migration to move it. A custom theme also makes its developer a dependency, which is a lock-in of its own.
Divi and WPBakery were not measured. Divi 5 ships a migrator "that will convert all of your Divi 4 shortcodes to Divi 5 blocks".
Before you pick, write down what leaving would cost, the same exit-cost check we use when buying software without getting locked in.
Maintenance and update risk: licences, major versions and plugin exposure
A builder is a dependency with its own major versions: in 2026 both Divi and Elementor changed how pages are built. Elegant Themes set February 26, 2026 as the day Divi 5 left beta, in a post dated January 14 that also promised Divi 4 support "for at least an additional six months after the official release of Divi 5". Elementor's 4.0 announcement, first published March 31, 2026, says "new Elementor installations will start with Atomic features enabled by default". Neither change is free: someone has to test the migration on every template.
Most licences renew every year. These are list prices read on 2026-11-09, in USD, before tax and promotions:
| Builder | Plan | List price | Sites |
|---|---|---|---|
| Elementor | Essential | $60 a year | 1 |
| Elementor | Advanced Solo | $84 a year | 1 |
| Elementor | Advanced | $108 a year | 3 |
| Elementor | One | $180 the first year, then $228 a year | 1 |
| Beaver Builder | Starter / Plus / Professional / Unlimited | $89 / $179 / $299 / $546 a year | 1 / 3 / 50 / unlimited |
| Divi | Divi Theme & Builder | $89 billed yearly | Unlimited |
| Divi | Divi Pro | $277 billed yearly | Unlimited |
| Breakdance | Free / Pro 1 website / Pro unlimited | $0 / $99.99 / $199.99 a year | Unlimited / 1 / unlimited |
| Bricks | Starter / Business / Agency | $79 / $149 / $249 a year | 1 / 3 / unlimited |
WPBakery and Oxygen are paid too; we did not read their price pages for this post. Bricks and Divi also sell lifetime licences ($599 and $249 once). Elementor, Beaver Builder Lite and Breakdance have free versions; the costs of a whole build are a separate question we don't price here; our WordPress developer cost guide does.
Every plugin is attack surface. Patchstack's State of WordPress Security in 2026 reports that "91% of new vulnerabilities were found in plugins, and 9% were found in themes". A builder with add-on packs adds plugins; a custom theme adds code that few people besides its author ever review. With a custom theme, ask for the code in version control, documentation, and a named person who will update it.
Can editors still change pages on a custom theme? The editor experience compared
Yes, within the structure the developer gives them. This section is our experience and opinion, not something we measured.
A builder lets an editor change anything, including the parts that keep the design consistent. That freedom is the point for a marketing team that ships a new landing page every week, and the risk for a site with a brand system: spacing, type sizes and colours drift page by page.
A block theme gives editors blocks and patterns, and the developer limits them with theme.json presets (a fixed palette, type scale and spacing) and locked patterns that can't be moved or deleted. Editors can build new pages from approved sections without touching the design rules.
A classic custom theme with ACF fields gives editors forms: a heading here, an image there, a list of cards. Editors can't break the layout, and they also can't make a new one; a new kind of page needs a developer. Our test theme is that model, which is why its removal result looked the way it did.
When a page builder is the right choice
We would recommend a page builder in these cases, as our judgment rather than a rule from data:
- A marketing team ships new layouts often and has no developer on hand. Waiting days for each landing page costs more than a heavier page.
- The site must launch this month on a small budget. A builder and a good template get a credible site live fastest.
- The site is small or short-lived: a campaign, an event, or a test of an idea that may not last a year.
- An existing builder site already passes Core Web Vitals in field data, and editors are productive. We would not rebuild it for speed.
In those cases, keep the builder lean: fewer add-on packs, one font family, and the builder's own performance settings reviewed rather than assumed.
Which to choose: custom theme, block theme or page builder
Choose on who edits, how often layouts change and how long the site must last, then check field data before rebuilding anything.
| If your situation is | Then |
|---|---|
| Non-developers redesign layouts often, or the site is small or short-lived | A page builder |
| Editors need layout freedom, within limits that protect the design | A block theme with locked patterns and theme.json presets |
| A long-lived site, a design system, structured content, or money pages failing field LCP after hosting and image fixes | A custom theme |
| The front end is a product of its own and WordPress is only the editor | Headless, which is a different build |
If that last row fits, our headless WordPress with Next.js guide covers that build, with caching, previews and a WordPress outage tested.
When to rebuild a page builder site as a custom theme
Rebuild triggers worth acting on:
- Field LCP failing on key templates in Search Console after hosting, image and caching fixes.
- A forced builder migration that costs about as much as a rebuild.
- Licence and add-on sprawl: several paid packs to do what the theme could.
- Editors repeatedly breaking layouts or brand rules.
Not triggers on their own:
- A low Lighthouse score. Google's Search Console Core Web Vitals report is "based on real world usage data (sometimes called field data)", and its help page notes that PageSpeed Insights results "might vary" from it.
- "Builders are bad for SEO." Google's page experience guide says "Core Web Vitals are used by our ranking systems", but also "There is no single signal", and that Search shows the most relevant content "even if the page experience is sub-par".
- A builder site that already passes Core Web Vitals in field data.
Are page builders bad for SEO? Not directly. Google uses Core Web Vitals in ranking but says there is no single signal, so a builder affects rankings mainly through what it does to real users' loading times, which in the field data above means LCP.
Rebuild on field data, not on a Lighthouse score. In our lab, a builder page and a custom theme page both had median scores of 98 or more; the difference that matters is what your real users see. Google's thresholds for good are an LCP within 2.5 seconds, an INP of 200 milliseconds or less and a CLS of 0.1 or less, at the 75th percentile of page loads, per web.dev.
Run the field pull and the lab yourself
Everything above comes from the files below, run on 2026-11-09. The field pull needs only Node 20 or later and a network connection. The lab needs Docker, Chrome and about an hour. To keep this page readable we don't print the scripts that load the copy into each tool, switch the stack between builds, trace the H1 and count words after removal.
# Field data: prints both field tables
node builder-bench.mjs field
# Lab: start the stack, install WordPress and the tools, build each page, then for each build
docker compose up -d
CHROME_PATH="/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" RUNS=3 node builder-bench.mjs lab http://localhost:8099/ref-a/
This is the script the field research used, with Lighthouse pinned to 13.6.0, per-run scores, font bytes, TTFB, Twenty Twenty-Five, a fixed row order and the top-1M table added, and every Lighthouse report saved.
The theme and plugin were switched between builds, so the lab output is the script's output for each build in order, concatenated and unedited. The versions file the stack printed before the builds:
Recorded 2026-11-09T09:56:05Z
wordpress:latest wordpress@sha256:9001ea7dafd2bc3f05d068e6413b0edd2a116eeed4dfe9e08b6bd718dee4960a
mariadb:11 mariadb@sha256:c4124d1afa875e47f2892edf26b482fa54f796e2f342d3717a04ca091a22a9bd
WordPress 7.1.4
PHP 8.3.36
Apache Server version: Apache/2.4.69 (Debian)
MariaDB 11.8.9-MariaDB-ubu2404
WP-CLI WP-CLI 2.12.0
name,version
advanced-custom-fields,6.8.11
akismet,5.7.2
beaver-builder-lite-version,2.11.1.2
elementor,4.3.6
hello,1.7.2
name,version
hello-elementor,3.5.2
twentytwentyfive,1.5
twentytwentyfour,1.6
twentytwentythree,1.7
Node v24.20.0
Chrome Google Chrome 156.0.8078.80
Docker 29.7.2
Apple M1 Max
27.0.1
The bench script:
// builder-bench.mjs: field data per WordPress builder (HTTP Archive + CrUX, no key)
// and lab data (Lighthouse 13.6.0, 3 runs, medians) for a list of page URLs.
// Node 20+ built-ins only; Lighthouse is fetched by npx. Needs Chrome installed (set CHROME_PATH).
// Run: node builder-bench.mjs field
// node builder-bench.mjs lab http://localhost:8099/ref-a/ http://localhost:8099/ref-b/ ...
// Each Lighthouse report is saved as runs/<page>-r<N>.json next to where you run it.
import { execFileSync } from "node:child_process";
import { readFileSync, mkdirSync } from "node:fs";
import { cpus, totalmem, type, release, arch } from "node:os";
import { join } from "node:path";
// Core WordPress groups first, then builders in alphabetical order. Printed in this order, not ranked.
const TECH = ["WordPress", "WordPress Block Editor", "WordPress Site Editor", "Twenty Twenty-Five",
"Beaver Builder", "Breakdance", "Bricks", "Divi", "Elementor", "Hello Elementor", "Oxygen", "wpBakery"];
const API = "https://cdn.httparchive.org/v1";
const RUNS = Number(process.env.RUNS || 3);
const med = (a) => { const s = [...a].sort((x, y) => x - y); const m = s.length >> 1; return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2; };
const kb = (b) => (b / 1000).toFixed(0); // decimal kilobytes, 1 KB = 1,000 bytes
const pct = (v, n) => (v?.tested ? (100 * v.good_number) / v.tested : NaN);
const order = (rows) => [...rows].sort((a, b) => TECH.indexOf(a.technology) - TECH.indexOf(b.technology));
async function get(endpoint, rank, range = "start=latest") {
const q = `technology=${TECH.map(encodeURIComponent).join(",")}&geo=ALL&rank=${encodeURIComponent(rank)}&${range}`;
const r = await fetch(`${API}/${endpoint}?${q}`);
if (!r.ok) throw new Error(`${endpoint} ${r.status}`);
return r.json();
}
const mobile = (r) => Object.fromEntries(r.vitals.map((m) => [m.name, m.mobile]));
async function field() {
const [cwv, pw, top] = await Promise.all([get("cwv", "ALL"), get("page-weight", "ALL"), get("cwv", "Top 1M")]);
const month = cwv[0].date, y = Number(month.slice(0, 4)) - 1;
const trend = await get("cwv", "ALL", `start=${y}${month.slice(4)}&end=${month}`);
const weight = Object.fromEntries(pw.map((r) => [r.technology, Object.fromEntries(r.pageWeight.map((m) => [m.name, m.mobile.median_bytes]))]));
console.log(`Field (CrUX via HTTP Archive Technology Report), mobile origins, all ranks, month ${month}, pulled ${new Date().toISOString().slice(0, 10)}`);
console.log("technology".padEnd(24), "origins".padStart(9), "all3%".padStart(6), "LCP%".padStart(6), "INP%".padStart(6), "INP n".padStart(8), "CLS%".padStart(6), "TTFB%".padStart(6), "totKB".padStart(6), "jsKB".padStart(5));
for (const r of order(cwv)) {
const v = mobile(r), w = weight[r.technology] || {};
console.log(r.technology.padEnd(24), String(v.overall.tested).padStart(9), pct(v.overall).toFixed(1).padStart(6), pct(v.LCP).toFixed(1).padStart(6),
pct(v.INP).toFixed(1).padStart(6), String(v.INP.tested).padStart(8), pct(v.CLS).toFixed(1).padStart(6), pct(v.TTFB).toFixed(1).padStart(6),
kb(w.total ?? NaN).padStart(6), kb(w.js ?? NaN).padStart(5));
}
const months = [...new Set(trend.map((r) => r.date))].sort();
console.log(`\nRank check: top 1M origins, month ${top[0].date}; 13-month range of all3% on all origins, ${months[0]} to ${months.at(-1)} (${months.length} months)`);
console.log("technology".padEnd(24), "top1M n".padStart(8), "top1M%".padStart(7), "all%".padStart(6), "13-mo min".padStart(10), "13-mo max".padStart(10));
const all = Object.fromEntries(cwv.map((r) => [r.technology, mobile(r).overall]));
for (const r of order(top)) {
const o = mobile(r).overall;
const series = trend.filter((x) => x.technology === r.technology).map((x) => pct(mobile(x).overall));
console.log(r.technology.padEnd(24), String(o.tested).padStart(8), pct(o).toFixed(1).padStart(7), pct(all[r.technology]).toFixed(1).padStart(6),
Math.min(...series).toFixed(1).padStart(10), Math.max(...series).toFixed(1).padStart(10));
}
console.log("\nTechnologies overlap (a site can match several). Correlation, not cause. TTFB is not a Core Web Vital.");
}
function lhOnce(url, dir, i) {
const out = join(dir, `${new URL(url).pathname.replace(/\W+/g, "") || "home"}-r${i + 1}.json`);
execFileSync("npx", ["-y", "lighthouse@13.6.0", url, "--quiet", "--only-categories=performance", "--form-factor=mobile",
"--throttling-method=simulate", "--output=json", `--output-path=${out}`, "--chrome-flags=--headless=new"], { stdio: "ignore" });
const d = JSON.parse(readFileSync(out, "utf8")), a = d.audits, host = new URL(url).host;
const reqs = a["network-requests"].details.items;
const by = (f) => reqs.filter(f).reduce((s, x) => s + (x.transferSize || 0), 0);
return { lh: d.lighthouseVersion, chrome: d.environment?.hostUserAgent?.match(/Chrome\/[\d.]+/)?.[0],
form: d.configSettings.formFactor, thr: d.configSettings.throttling, bench: d.environment.benchmarkIndex,
score: Math.round(100 * d.categories.performance.score),
lcp: a["largest-contentful-paint"].numericValue, tbt: a["total-blocking-time"].numericValue, cls: a["cumulative-layout-shift"].numericValue,
bytes: a["total-byte-weight"].numericValue, first: by((x) => new URL(x.url).host === host), requests: reqs.length,
dom: a["dom-size-insight"]?.numericValue, js: by((x) => x.resourceType === "Script"), css: by((x) => x.resourceType === "Stylesheet"),
font: by((x) => x.resourceType === "Font") };
}
function lab(urls) {
console.log(`Lab (Lighthouse, mobile, simulated throttling), ${RUNS} runs per URL, medians. ${new Date().toISOString().slice(0, 10)}`);
console.log(`Machine: ${cpus()[0].model}, ${cpus().length} cores, ${Math.round(totalmem() / 2 ** 30)} GB, ${type()} ${release()} ${arch()}, Node ${process.version}`);
const dir = "runs";
mkdirSync(dir, { recursive: true });
for (const url of urls) {
const r = Array.from({ length: RUNS }, (_, i) => lhOnce(url, dir, i));
const m = (k) => med(r.map((x) => x[k]));
const t = r[0].thr;
console.log(`\n${url} (Lighthouse ${r[0].lh}, ${r[0].chrome})`);
console.log(` ${r[0].form}, RTT ${t.rttMs} ms, throughput ${t.throughputKbps} Kbps, CPU slowdown ${t.cpuSlowdownMultiplier}x, benchmark index ${r.map((x) => Math.round(x.bench)).join(", ")}`);
console.log(` transfer ${kb(m("bytes"))} KB (same-host ${kb(m("first"))} KB) | requests ${m("requests")} | DOM ${m("dom")} | JS ${kb(m("js"))} KB | CSS ${kb(m("css"))} KB | fonts ${kb(m("font"))} KB`);
console.log(` LCP ${(m("lcp") / 1000).toFixed(2)} s | TBT ${Math.round(m("tbt"))} ms | CLS ${m("cls").toFixed(3)} | score ${m("score")} runs LCP: ${r.map((x) => (x.lcp / 1000).toFixed(2)).join(", ")} runs score: ${r.map((x) => x.score).join(", ")}`);
}
console.log("\nLab only: one simulated mid-range phone, no real users. INP needs real interactions, so it is not measured here.");
}
const [mode, ...rest] = process.argv.slice(2);
if (mode === "field") await field(); else if (mode === "lab") lab(rest); else console.log("usage: node builder-bench.mjs field | lab <url...>");
The field output, unedited:
Field (CrUX via HTTP Archive Technology Report), mobile origins, all ranks, month 2026-09-01, pulled 2026-11-09
technology origins all3% LCP% INP% INP n CLS% TTFB% totKB jsKB
WordPress 2658175 48.3 55.4 90.3 1947294 87.3 22.9 2720 677
WordPress Block Editor 543833 52.0 60.4 90.4 396475 86.6 25.0 2285 627
WordPress Site Editor 49586 62.8 68.2 90.3 34865 93.1 29.2 1971 396
Twenty Twenty-Five 3012 44.6 50.1 79.4 2094 92.2 18.7 1556 423
Beaver Builder 28327 53.4 58.3 95.3 20265 89.7 22.9 2740 701
Breakdance 5273 56.3 61.0 94.1 4113 93.3 22.1 3075 643
Bricks 10701 54.8 59.3 92.5 8414 93.9 23.8 2329 578
Divi 150144 41.4 48.5 94.5 110014 81.0 18.4 2790 675
Elementor 877513 36.3 41.0 88.3 642119 88.7 15.2 2940 710
Hello Elementor 244654 37.6 41.6 89.7 180814 91.3 15.7 3185 727
Oxygen 11306 51.3 60.6 92.2 8628 85.1 23.3 2845 626
wpBakery 217664 38.7 44.9 91.9 161103 83.6 17.1 3217 868
Rank check: top 1M origins, month 2026-09-01; 13-month range of all3% on all origins, 2025-09-01 to 2026-09-01 (13 months)
technology top1M n top1M% all% 13-mo min 13-mo max
WordPress 110537 50.1 48.3 45.0 49.5
WordPress Block Editor 25207 51.5 52.0 48.1 53.7
WordPress Site Editor 1789 59.4 62.8 59.6 64.0
Twenty Twenty-Five 74 52.7 44.6 38.6 46.4
Beaver Builder 688 56.5 53.4 50.9 54.8
Breakdance 165 49.7 56.3 52.2 57.7
Bricks 410 46.3 54.8 51.7 55.7
Divi 2315 40.4 41.4 38.7 43.1
Elementor 25844 36.7 36.3 33.4 37.7
Hello Elementor 5905 37.5 37.6 35.1 39.2
Oxygen 415 46.0 51.3 49.4 53.2
wpBakery 7061 38.4 38.7 34.8 39.4
Technologies overlap (a site can match several). Correlation, not cause. TTFB is not a Core Web Vital.
The lab output, unedited:
Lab (Lighthouse, mobile, simulated throttling), 3 runs per URL, medians. 2026-11-09
Machine: Apple M1 Max, 10 cores, 64 GB, Darwin 27.0.0 arm64, Node v24.20.0
http://localhost:8099/ref-a/ (Lighthouse 13.6.0, Chrome/156.0.0.0)
mobile, RTT 150 ms, throughput 1638.4 Kbps, CPU slowdown 4x, benchmark index 3141, 3145, 3103
transfer 102 KB (same-host 102 KB) | requests 9 | DOM 95 | JS 6 KB | CSS 3 KB | fonts 54 KB
LCP 1.43 s | TBT 0 ms | CLS 0.000 | score 100 runs LCP: 1.43, 1.43, 1.43 runs score: 100, 100, 100
Lab only: one simulated mid-range phone, no real users. INP needs real interactions, so it is not measured here.
Lab (Lighthouse, mobile, simulated throttling), 3 runs per URL, medians. 2026-11-09
Machine: Apple M1 Max, 10 cores, 64 GB, Darwin 27.0.0 arm64, Node v24.20.0
http://localhost:8099/ref-b/ (Lighthouse 13.6.0, Chrome/156.0.0.0)
mobile, RTT 150 ms, throughput 1638.4 Kbps, CPU slowdown 4x, benchmark index 3007, 3063, 3057
transfer 242 KB (same-host 165 KB) | requests 32 | DOM 128 | JS 110 KB | CSS 23 KB | fonts 72 KB
LCP 2.00 s | TBT 0 ms | CLS 0.000 | score 98 runs LCP: 2.33, 2.00, 1.99 runs score: 97, 98, 98
Lab only: one simulated mid-range phone, no real users. INP needs real interactions, so it is not measured here.
Lab (Lighthouse, mobile, simulated throttling), 3 runs per URL, medians. 2026-11-09
Machine: Apple M1 Max, 10 cores, 64 GB, Darwin 27.0.0 arm64, Node v24.20.0
http://localhost:8099/ref-c/ (Lighthouse 13.6.0, Chrome/156.0.0.0)
mobile, RTT 150 ms, throughput 1638.4 Kbps, CPU slowdown 4x, benchmark index 3117, 3083, 3001
transfer 235 KB (same-host 158 KB) | requests 28 | DOM 127 | JS 109 KB | CSS 17 KB | fonts 72 KB
LCP 1.99 s | TBT 0 ms | CLS 0.000 | score 98 runs LCP: 1.98, 1.99, 2.31 runs score: 98, 98, 97
Lab only: one simulated mid-range phone, no real users. INP needs real interactions, so it is not measured here.
Lab (Lighthouse, mobile, simulated throttling), 3 runs per URL, medians. 2026-11-09
Machine: Apple M1 Max, 10 cores, 64 GB, Darwin 27.0.0 arm64, Node v24.20.0
http://localhost:8099/ref-d/ (Lighthouse 13.6.0, Chrome/156.0.0.0)
mobile, RTT 150 ms, throughput 1638.4 Kbps, CPU slowdown 4x, benchmark index 3039, 3073, 3051
transfer 89 KB (same-host 89 KB) | requests 12 | DOM 135 | JS 49 KB | CSS 5 KB | fonts 0 KB
LCP 1.45 s | TBT 0 ms | CLS 0.000 | score 100 runs LCP: 1.45, 1.44, 1.45 runs score: 100, 100, 100
Lab only: one simulated mid-range phone, no real users. INP needs real interactions, so it is not measured here.
Lab (Lighthouse, mobile, simulated throttling), 3 runs per URL, medians. 2026-11-09
Machine: Apple M1 Max, 10 cores, 64 GB, Darwin 27.0.0 arm64, Node v24.20.0
http://localhost:8099/ref-e/ (Lighthouse 13.6.0, Chrome/156.0.0.0)
mobile, RTT 150 ms, throughput 1638.4 Kbps, CPU slowdown 4x, benchmark index 3067, 3078, 3034
transfer 95 KB (same-host 95 KB) | requests 9 | DOM 78 | JS 6 KB | CSS 1 KB | fonts 54 KB
LCP 1.28 s | TBT 0 ms | CLS 0.000 | score 100 runs LCP: 1.43, 1.28, 1.28 runs score: 100, 100, 100
Lab only: one simulated mid-range phone, no real users. INP needs real interactions, so it is not measured here.
The removal test output, unedited:
a: post_content 4124 bytes, shortcodes 0, <div 11, style=" 1, block comments 28, meta rows 1 | after removal: 18 of 18 copy blocks verbatim, 212 of 212 words, hero image yes, button links 2 of 2, H1 tags 2
b: post_content 2841 bytes, shortcodes 0, <div 0, style=" 0, block comments 0, meta rows 8 | after removal: 18 of 18 copy blocks verbatim, 212 of 212 words, hero image yes, button links 2 of 2, H1 tags 2
c: post_content 2841 bytes, shortcodes 0, <div 0, style=" 0, block comments 0, meta rows 8 | after removal: 18 of 18 copy blocks verbatim, 212 of 212 words, hero image yes, button links 2 of 2, H1 tags 2
d: post_content 2729 bytes, shortcodes 0, <div 0, style=" 0, block comments 1, meta rows 5 | after removal: 18 of 18 copy blocks verbatim, 212 of 212 words, hero image yes, button links 2 of 2, H1 tags 1
e: post_content 0 bytes, shortcodes 0, <div 0, style=" 0, block comments 0, meta rows 41 | after removal: 0 of 18 copy blocks verbatim, 16 of 212 words, hero image no, button links 0 of 2, H1 tags 1
The Docker Compose file. The passwords are throwaway values for a local lab:
# Throwaway lab stack for the theme vs page builder test. Local only; passwords are disposable.
name: kep-tvb
services:
db:
image: mariadb:11
container_name: kep-tvb-db
environment:
MARIADB_DATABASE: wp
MARIADB_USER: wp
MARIADB_PASSWORD: lab-wp-pass
MARIADB_ROOT_PASSWORD: lab-root-pass
wordpress:
image: wordpress:latest
container_name: kep-tvb-wp
depends_on: [db]
ports:
- "8099:80"
environment:
WORDPRESS_DB_HOST: db
WORDPRESS_DB_USER: wp
WORDPRESS_DB_PASSWORD: lab-wp-pass
WORDPRESS_DB_NAME: wp
volumes:
- wp:/var/www/html
- ./kp-ref-classic:/var/www/html/wp-content/themes/kp-ref-classic
volumes:
wp:
The test theme, file by file. The font file is Manrope-VariableFont_wght.woff2 from Twenty Twenty-Five's assets/fonts/manrope folder.
style.css
/*
Theme Name: KP Ref Classic
Description: Hand-written classic test theme for a lab comparison. One stylesheet, one self-hosted font, no build step.
Version: 1.0.0
Requires at least: 7.1
Requires PHP: 8.3
License: GPL-2.0-or-later
*/
@font-face {
font-family: "Manrope";
src: url("assets/fonts/Manrope-VariableFont_wght.woff2") format("woff2");
font-weight: 200 800;
font-display: swap;
}
*, *::before, *::after { box-sizing: border-box; }
body { margin: 0; font-family: "Manrope", system-ui, sans-serif; font-size: 1.0625rem; line-height: 1.6; color: #1d1d1b; background: #fbf8f2; }
img { max-width: 100%; height: auto; display: block; }
a { color: inherit; }
.wrap { max-width: 72rem; margin: 0 auto; padding: 0 1.25rem; }
.site-header .wrap { display: flex; flex-wrap: wrap; align-items: center; justify-content: space-between; gap: .75rem 1.5rem; padding-block: 1.25rem; }
.logo { font-weight: 800; font-size: 1.25rem; text-decoration: none; }
.nav { display: flex; flex-wrap: wrap; gap: .5rem 1.25rem; margin: 0; padding: 0; list-style: none; }
.nav a { text-decoration: none; }
.hero { padding-block: 2.5rem 3rem; }
.hero h1 { font-size: clamp(2rem, 6vw, 3.5rem); line-height: 1.1; margin: 0 0 1rem; max-width: 18ch; }
.hero p { max-width: 40rem; margin: 0 0 1.5rem; }
.hero img { margin-top: 2rem; border-radius: .5rem; width: 100%; }
.button { display: inline-block; padding: .8rem 1.4rem; border-radius: 999px; background: #1d1d1b; color: #fbf8f2; text-decoration: none; font-weight: 600; }
.cards { display: grid; gap: 1.5rem; padding-block: 2rem; }
@media (min-width: 48rem) { .cards { grid-template-columns: repeat(3, 1fr); } }
.card h3 { margin: 0 0 .5rem; font-size: 1.25rem; }
.card p { margin: 0 0 .75rem; }
.testimonial { padding-block: 2.5rem; }
.testimonial blockquote { margin: 0 0 1rem; font-size: 1.25rem; max-width: 46rem; }
.testimonial figcaption { display: flex; align-items: center; gap: .75rem; }
.testimonial img { width: 48px; height: 48px; border-radius: 50%; }
.cta { background: #1d1d1b; color: #fbf8f2; padding-block: 3rem; }
.cta h2 { margin: 0 0 .5rem; font-size: 1.75rem; }
.cta p { margin: 0 0 1.5rem; }
.cta .button { background: #b9f3d6; color: #1d1d1b; }
.site-footer { padding-block: 2.5rem; font-size: .9375rem; }
.footer-cols { display: grid; gap: 1.5rem; grid-template-columns: repeat(3, 1fr); }
.footer-cols h4 { margin: 0 0 .5rem; font-size: 1rem; }
.footer-cols ul { margin: 0; padding: 0; list-style: none; }
.copyright { margin-top: 2rem; }
.entry { padding-block: 2rem; }
functions.php
<?php
// KP Ref Classic: enqueue one stylesheet (the font loads from it), register the ACF fields, nothing else.
add_action( 'after_setup_theme', function () {
add_theme_support( 'title-tag' );
} );
add_action( 'wp_enqueue_scripts', function () {
// The blank template (build D) and Elementor Canvas (build C) get no theme CSS,
// so those builds are measured on the builder's own output.
if ( is_page_template( 'page-blank.php' ) || is_page_template( 'elementor_canvas' ) ) {
return;
}
wp_enqueue_style( 'kp-ref', get_stylesheet_uri(), array(), '1.0.0' );
} );
// ACF (free) fields for the reference page template: fixed fields, no repeater.
add_action( 'acf/init', function () {
$fields = array();
$add = function ( $name, $type = 'text' ) use ( &$fields ) {
$fields[] = array( 'key' => 'field_kp_' . $name, 'name' => $name, 'label' => $name, 'type' => $type, 'return_format' => 'id' );
};
foreach ( array( 'hero_h1', 'hero_text', 'hero_button' ) as $n ) { $add( $n ); }
$add( 'hero_image', 'image' );
for ( $i = 1; $i <= 3; $i++ ) {
foreach ( array( 'h3', 'text', 'link' ) as $n ) { $add( "card{$i}_{$n}" ); }
}
foreach ( array( 'quote', 'name', 'role' ) as $n ) { $add( "testimonial_{$n}" ); }
$add( 'testimonial_avatar', 'image' );
foreach ( array( 'h2', 'text', 'button' ) as $n ) { $add( "cta_{$n}" ); }
acf_add_local_field_group( array(
'key' => 'group_kp_ref',
'title' => 'Reference page',
'fields' => $fields,
'location' => array( array( array( 'param' => 'page_template', 'operator' => '==', 'value' => 'page-ref.php' ) ) ),
) );
} );
header.php
<!doctype html>
<html <?php language_attributes(); ?>>
<head>
<meta charset="<?php bloginfo( 'charset' ); ?>">
<meta name="viewport" content="width=device-width, initial-scale=1">
<?php wp_head(); ?>
</head>
<body <?php body_class(); ?>>
<?php wp_body_open(); ?>
<header class="site-header">
<div class="wrap">
<a class="logo" href="/">Lumen Ridge</a>
<ul class="nav">
<li><a href="/">Home</a></li>
<li><a href="#services">Services</a></li>
<li><a href="#work">Work</a></li>
<li><a href="#contact">Contact</a></li>
</ul>
</div>
</header>
footer.php
<footer class="site-footer">
<div class="wrap">
<div class="footer-cols">
<div><h4>Studio</h4><ul><li><a href="#">About</a></li><li><a href="#">Team</a></li><li><a href="#">Careers</a></li></ul></div>
<div><h4>Projects</h4><ul><li><a href="#">Homes</a></li><li><a href="#">Workplaces</a></li><li><a href="#">Community</a></li></ul></div>
<div><h4>Contact</h4><ul><li><a href="#">Email</a></li><li><a href="#">Phone</a></li><li><a href="#">Visit</a></li></ul></div>
</div>
<p class="copyright">Copyright 2026 Lumen Ridge. A test page for a lab comparison.</p>
</div>
</footer>
<?php wp_footer(); ?>
</body>
</html>
page-ref.php
<?php
/* Template Name: Reference page (ACF) */
get_header();
$f = function ( $name ) { return esc_html( (string) get_field( $name ) ); };
?>
<main>
<section class="hero wrap">
<h1><?php echo $f( 'hero_h1' ); ?></h1>
<p><?php echo $f( 'hero_text' ); ?></p>
<a class="button" href="#contact"><?php echo $f( 'hero_button' ); ?></a>
<?php echo wp_get_attachment_image( (int) get_field( 'hero_image' ), 'full' ); ?>
</section>
<section class="cards wrap" id="services">
<?php for ( $i = 1; $i <= 3; $i++ ) : ?>
<div class="card">
<h3><?php echo $f( "card{$i}_h3" ); ?></h3>
<p><?php echo $f( "card{$i}_text" ); ?></p>
<a href="#work"><?php echo $f( "card{$i}_link" ); ?></a>
</div>
<?php endfor; ?>
</section>
<figure class="testimonial wrap">
<blockquote><?php echo $f( 'testimonial_quote' ); ?></blockquote>
<figcaption>
<?php echo wp_get_attachment_image( (int) get_field( 'testimonial_avatar' ), 'full' ); ?>
<span><strong><?php echo $f( 'testimonial_name' ); ?></strong>, <?php echo $f( 'testimonial_role' ); ?></span>
</figcaption>
</figure>
<section class="cta" id="contact">
<div class="wrap">
<h2><?php echo $f( 'cta_h2' ); ?></h2>
<p><?php echo $f( 'cta_text' ); ?></p>
<a class="button" href="#contact"><?php echo $f( 'cta_button' ); ?></a>
</div>
</section>
</main>
<?php
get_footer();
page.php (index.php is the same file)
<?php
// Default page template: the page title and the_content() (used when another tool is removed).
get_header();
while ( have_posts() ) :
the_post();
?>
<main class="entry wrap">
<h1><?php the_title(); ?></h1>
<?php the_content(); ?>
</main>
<?php
endwhile;
get_footer();
page-blank.php
<?php
/* Template Name: Blank (builder canvas) */
// No theme header, footer or CSS: the builder renders the whole page through the_content().
?>
<!doctype html>
<html <?php language_attributes(); ?>>
<head>
<meta charset="<?php bloginfo( 'charset' ); ?>">
<meta name="viewport" content="width=device-width, initial-scale=1">
<?php wp_head(); ?>
</head>
<body <?php body_class(); ?>>
<?php wp_body_open(); ?>
<?php while ( have_posts() ) : the_post(); the_content(); endwhile; ?>
<?php wp_footer(); ?>
</body>
</html>
How Keplaris builds WordPress sites
We build lean custom themes written from scratch, with structured content in custom field groups and the code in version control. We still published a test where our own approach beat Elementor on bytes and requests and lost on exit cost. If your builder site already passes Core Web Vitals in field data and your team ships pages happily, we would keep it. If you are weighing a rebuild, our WordPress and custom web development team builds custom themes.
Frequently asked questions
Is a custom WordPress theme faster than a page builder?
On a simple page, barely by score: in Keplaris's one-page local lab, all five builds had median Lighthouse 13.6.0 mobile scores of 98 to 100. The custom theme Keplaris wrote was lighter, at 95 KB in 9 requests, against 242 KB in 32 on Elementor 4.3.6 with Hello Elementor and free classic widgets. Beaver Builder Lite transferred 89 KB in 12, but its page was unstyled and loaded no web font. HTTP Archive cannot detect custom themes, so its real-user data cannot compare them with builders.
Are page builders bad for SEO?
Not directly. Google says Core Web Vitals are used by its ranking systems, that there is no single signal, and that it shows the most relevant content even when page experience is sub-par. Using a builder is not a penalty. The cost you can measure is loading: in HTTP Archive's September 2026 mobile data, LCP was good on 41.0% of Elementor origins against 55.4% of WordPress origins overall. Judge your own site by the field data in Search Console, not by a Lighthouse score.
Is the block editor (Gutenberg) a page builder?
Not in the plugin sense: it is WordPress's core editor, but with a block theme and the Site Editor it lays out whole pages, so it covers much of what builders do. It stores a page as HTML with block comments in post_content, and in our test that text survived a theme switch. In September 2026 field data, 62.8% of Site Editor origins passed all three Core Web Vitals on mobile, but origins using Twenty Twenty-Five passed at 44.6%, so a block theme is not a guarantee.
What happens if I deactivate Elementor?
In Keplaris's test with Elementor 4.3.6 and its free widgets, the page text, links and images stayed visible, because Elementor had written a plain HTML copy into post_content when the page was saved. The layout did not survive: no columns, no colours, and the buttons became plain links. The Elementor JSON stayed in post meta, and reactivating the plugin restored the page. We did not test Pro widgets or pages saved by older versions.
Which WordPress page builder is fastest?
We don't rank them, because field data reflects who uses each tool as much as the tool itself. In September 2026, Bricks, Breakdance and Oxygen origins passed Core Web Vitals on mobile more often than WordPress overall, then fell below WordPress within the top million origins, on samples of 165 to 415 sites. Elementor, Divi and WPBakery were below WordPress in both cuts. Test your own pages instead of trusting a ranking.
Should I rebuild my page builder site as a custom theme?
Rebuild on field data and cost, not on a Lighthouse score. Good reasons are Core Web Vitals failing on key templates in Search Console after hosting and image fixes, a forced builder migration that costs about as much as a rebuild, licence and add-on sprawl, or editors who keep breaking layouts. Weak reasons are a low lab score on its own, or a belief that builders are bad for SEO. If your builder site passes in field data and editors are productive, keep it.
Get in touch.
Whether you have questions or just want to explore what's possible, we're here to help.
