“Block themes are faster.” That’s what our client heard, and that’s why they’re considering a move from a classic page-builder theme (WPBakery) to a custom block theme. Before switching anything on the live shop, we built the block theme on staging and tested it. First result: the server took longer to build each page than it does with the old theme.
Nothing was broken. Nobody did anything wrong. The block theme was simply doing a lot of work nobody could see, and the only way to find it was to measure.
Here’s what two days of measuring found, what we changed, and what each change was worth. The numbers are real, from a production copy of a Polish WooCommerce shop with ~500 products and 42 plugins. The short version: the block theme’s server time went down by 25–35% (summary at the end).
“Time to build” is how long the server works on a page before it can send the first byte to the visitor. Every page that isn’t served from a page cache pays it: the cart, checkout, logged-in customers, filtered category pages, the first visit after a price change. That’s exactly the traffic that buys.
The finding that matters most for anyone choosing a theme: the better your product data, the more a block theme costs on the server. Great descriptions and rich galleries, the things you invested in, are exactly what makes it slow. Jump to the numbers.
(We took two of those apart separately: add to cart and checkout.)
Table of Contents
The First Measurement Lied (a Little)
The obvious first step: open the same pages on the live site (old theme) and on staging (block theme) and compare. We did that with Query Monitor, logged in as an administrator:
| Page | Theme | Time | Queries |
|---|---|---|---|
| Product | old page-builder theme (live, with Redis) | 468 ms | 163 |
| Product | new block theme (staging, no Redis) | 505 ms | 486 |
| Category | old page-builder theme (live, with Redis) | 516 ms | 155 |
| Category | new block theme (staging, no Redis) | 663 ms | 640 |
Looks bad for the block theme. But the comparison wasn’t fair:
- The live site had a Redis object cache, staging didn’t. That alone explains most of the triple query count.
- An administrator isn’t a customer. Logged in, WordPress loads the admin bar, Query Monitor itself and extra checks. The same product page that took 505 ms for the admin took about 385 ms for an anonymous visitor.
So we threw this table away and started again: staging only, as an anonymous visitor, real requests to the server, the median of several runs. Boring, but it’s the only kind of number you can make decisions with.
Lesson one for shop owners: if someone shows you “the site is slower” or “the site is faster”, ask who the page was loaded as and what was cached. Half of the performance arguments we see are two people measuring different things.
Where the Time Actually Went
Product page, anonymous visitor, ~385 ms in total:
| Stage | Time | What’s in it |
|---|---|---|
| Building the page from blocks | 172 ms | the “add to cart with options” block 55 ms, header 61 ms, gallery 25 ms |
| Loading WordPress and 42 plugins | 57 ms | the consent plugin 25 ms |
WordPress start-up (init) | 52 ms | WooCommerce, block registration, the consent plugin again |
| Loading scripts and styles | 26 ms | the consent plugin, 47 queries |
| Final pass over the finished HTML | 26 ms | the consent plugin scanning the whole page |
The block theme as such wasn’t slow. An ordinary block costs about 0.05–0.1 ms to render. The time sat in three specific places that you won’t spot by looking at the site.
Three Hidden Costs
1. Every product card carries the whole product
On category pages, the shop and the homepage, WooCommerce’s product grid block prepares full product data for every card: prices with tax, every image, variations, stock. It writes all of it into the page as data for the “add to cart” button.
The button needs exactly two things from that: the product ID and the product type.
Per card that was about 6 ms and 19 KB. A category page with 16 cards: ~100 ms of server time and 309 KB of hidden data inside the HTML, before the visitor’s browser even gets to the images.
What we did: a small theme module that gives cards only the data the button uses. The main product on a product page still gets full data.
For your developer
One filter: woocommerce_hydration_dispatch_request
It’s where WooCommerce fills blocks with Store API product data. Our theme module hooks into it, recognises product-grid cards and returns a slim record for them (ID, type, what the button needs) instead of the full product. Leave the main product on the product page alone. Add a filter as an off-switch so it can be disabled without a deploy.
Result on the shop, category and homepage: up to −132 ms per page, and the category page HTML down from 697 KB to 373 KB, most of it from this one change.
2. All variations calculated on every visit
The “add to cart with options” block on a product page calculates the full data of every variation, about 6.5 ms each, every single time. A product with 7 variations: 43–52 ms per visit, for data that changes only when you edit the product.
What we did: we store the result in the object cache (Redis). The cache key includes the version number WooCommerce itself bumps whenever a product or variation is saved, so a price change, a stock change after an order or a scheduled sale refreshes it automatically. We tested it the simple way: raised one variation’s price by 1 PLN, and the page showed the new price immediately.
3. The menu was built three times
The header had a menu split into left and right parts, a separate hamburger block and a custom mobile overlay. With that setup WordPress outputs the menu items and the whole overlay. The left menu (31 items, a mega menu) was rendered three times, about 14 ms each.
What we did: one main menu, one navigation block with a mobile overlay. The desktop mega menu and the mobile drill-down work exactly as before. The menu is now built twice instead of three times.
The Better Your Catalogue, the Slower the Page
This is the part every shop owner considering a block theme should know.
On our local test copy, the “full data on every card” problem cost about 2 KB per card. On the real shop, almost 18 KB per card. Same theme, same code. The difference was the products.
We took the hidden data from a real category page (16 cards, before the fix) apart:
| What’s in each card’s data | Total | Per card | Share |
|---|---|---|---|
| The entire product gallery (3–10 images, each in several sizes) | 153 KB | 9.6 KB | 54% |
| The full product description (up to 7,762 characters) | 71 KB | 4.4 KB | 25% |
| Short description | 20 KB | 1.2 KB | 7% |
| Categories, attributes, prices, variations, cart limits | 41 KB | 2.6 KB | 14% |
A card shows one image and no description. Yet the data behind it contained the whole gallery and the full description with nutrition facts and ingredients. On top of that, Polish characters were escaped in a way that takes 6 bytes instead of 2, around 3,300 times per page.
The better your catalogue, the more you pay.
A shop with careful descriptions and rich galleries pays the most. A demo shop with short descriptions and no photos barely shows the problem.
That’s why a block theme can look fast in the agency’s demo and slow on your real catalogue. Test it on a copy of your own shop, with your own products, before you decide.
What Each Change Was Worth
We measured every change on its own with an A/B test: the same page, requests alternating with the change on and off, the median of 10–12 runs, as an anonymous visitor.
| Change | Page | Before | After | Difference |
|---|---|---|---|---|
| Redis object cache (server setting) | product | 385 ms | ~360 ms | −25 ms |
| Redis object cache (server setting) | product: queries | 425 | 154 | −271 |
| Lean product-card data | category | 488 ms | 356 ms | −132 ms |
| Lean product-card data | shop | 392 ms | 326 ms | −66 ms |
| Lean product-card data | homepage | 328 ms | 290 ms | −38 ms |
| One menu instead of three renders | category | 375 ms | 349 ms | −26 ms |
| One menu instead of three renders | regular page | 273 ms | 254 ms | −19 ms |
| Cached variation data | product | 329 ms | 283 ms | −45 ms |
Medians of 10–12 uncached PHP requests on a production copy. WordPress 7.1, WooCommerce 11.2.1, PHP 8.2 with OPcache, 42 plugins.
Look at the Redis row. It removed almost two thirds of the database queries, and the page got only ~25 ms faster. The problem wasn’t the database, it was PHP doing unnecessary work. If we had stopped at “add Redis, query count down, done”, we’d have fixed a number, not the shop.
That’s not an argument against Redis. It’s a fixed part of how we set up WooCommerce on GridPane. It just isn’t a substitute for finding out what PHP is doing.
What the Browser Gets: the Block Theme Wins
None of this means the block theme is a bad idea. In the browser, the block theme wins clearly. Compressed JavaScript and CSS on the product page:
| Old page-builder theme | Block theme | |
|---|---|---|
| JavaScript | ~340 KB* | 226 KB |
| CSS | 320 KB | 90 KB |
| JS and CSS files | 126 | 81 |
| HTML elements (DOM) | 1,654 | 1,239 |
So the block theme gives you a lighter page in the browser. It doesn’t automatically give you a faster server. Those are two different things, and you need to measure both.
Does a Ready-Made Block Theme Avoid This?
We checked Purple, the new WooCommerce block theme from Automattic (WordPress 7.1, WooCommerce 11.1+). Same local copy of the shop, same data, both themes alternating on one install, median of 12 runs:
| Page | Our custom theme | Purple |
|---|---|---|
| Homepage | 172 ms | 225 ms |
| Shop (12 cards) | 185 ms | 225 ms |
| Category (12 cards) | 188 ms | 236 ms |
| Product (6 variations) | 217 ms | 311 ms |
Purple is a solid, modern theme, and it follows WooCommerce’s defaults. That’s the point: the defaults include full product data on every card and a header with three navigation blocks, the same two patterns we removed. Part of the difference is also that Purple shows more on each page (24 cards on the homepage instead of 5, 8 related products), and each of those items pays the full data cost.
Local test products are short (~2.7 KB of data per card), so on a real catalogue the gap would be bigger, not smaller.
The Block Theme Before and After Our Fixes
All of it in one table. Both columns are the same block theme on staging, the same pages, loaded as an anonymous visitor with no page cache:
- Before: the block theme as we got it, without a Redis object cache. Our starting point.
- After: the same block theme with Redis and the three fixes above.
| Block theme on staging | Before | After |
|---|---|---|
| Product page, time to build | 385 ms | 283 ms |
| Category page, time to build | ~520 ms | 349 ms |
| Category page, HTML size | 697 KB | 373 KB |
| Database queries, product page | 425 | 154 |
The old page-builder theme isn’t in this table. How the two themes compare is in the first measurement (server) and what the browser gets (browser).
What This Means for Your Shop
- A block theme isn’t automatically faster on the server. Its advantage is in the browser: less CSS, less JavaScript, a smaller page. On the server, WooCommerce’s interactive blocks prepare a lot of data up front.
- The cost grows with your data, not with the number of blocks. A demo shop won’t tell you anything; your own catalogue will. Product cards (~6 ms each) and variations (~6.5 ms each) are what get expensive, and they scale with your catalogue.
- Redis cuts queries, not PHP work. Useful, but not a fix on its own.
- One plugin can cost as much as the whole theme. In a separate A/B test, the consent plugin (ConsentMagic Pro) cost about 90 ms and ~160 queries on every page, some of them straight to the database where Redis can’t help. Optimising it is a separate stage.
- Measure as a customer, not as an admin. And check your tools: at one point our own timing instrumentation triggered extra work on the server and gave us a false conclusion. We only caught it by comparing against a run with no instrumentation at all.
The message isn’t “block themes are slow” or “block themes are fast”. It’s this: don’t optimise in the dark. Before changing anything, find out where the time goes. After changing something, measure what it was worth. Every change in this article has a number next to it, and two of the things everyone would try first (a new theme, Redis) turned out to be worth far less than the three things nobody could see. (Expectations losing to data is a recurring theme here: we once bought a domain before running the benchmark, and the data disagreed.)
For our client the decision is still open, and that’s the point: they’ll make it with numbers, not with “block themes are faster”. The testing continues on staging.
If you’re considering a block theme migration, or you’ve done one and the shop doesn’t feel faster, get in touch. We’ll measure it first.
How We Measured
- Staging as a copy of production: WordPress 7.1, WooCommerce 11.2.1, PHP 8.2 with OPcache (checked that it actually works, otherwise every number is skewed), 42 active plugins, GridPane hosting.
curlrequests from the server to PHP as an anonymous visitor, no page cache. Medians of 5–12 requests, A/B tests alternating on/off.- Timing through a temporary must-use plugin active only with a secret header: stages, time per block and hook, queries with their call sites. No database writes, removed after the work.
- Checked in the browser after every change (the kind of flow worth covering with Playwright): add to cart from a card and from the product page, cart counter, variation selection, category filters, mega menu, mobile drill-down.
- Theme changes: 3 commits, each with an emergency off-switch through a filter.