Performance
Is your review app slowing down your Shopify store? How to measure it
Review widgets are some of the heaviest third-party scripts on Shopify stores. They fetch external data after page load, block the main thread, and cause layout shifts. This guide shows you exactly how to measure the performance cost with Lighthouse and Chrome DevTools - so you have concrete numbers, not suspicions.
Audience: merchants, developers, anyone running Lighthouse audits. Reading time: ~8 minutes.
1. Why review apps slow Shopify stores
Standard review apps (Loox, Judge.me, Stamped, Yotpo) follow the same pattern: they inject a JavaScript bundle into your theme that, on page load, fires a request to their external API server. The review data arrives after the page has already started rendering, and the JavaScript inserts it into the DOM.
This creates three distinct performance problems:
- Additional network requests to an external origin. Your page now depends on a server you don't control. Every millisecond of latency on that server directly delays your review content from appearing.
- JavaScript execution on the main thread. Parsing, compiling, and executing the review widget's JS bundle blocks other work. On lower-end mobile devices, this creates long tasks that delay user interaction.
- Layout shift on injection. When review cards are inserted into the DOM after initial paint, they push existing content downward. This is a direct source of Cumulative Layout Shift (CLS), one of Google's Core Web Vitals.
2. Running a Lighthouse audit
Option A: PageSpeed Insights (no setup required)
Go to pagespeed.web.dev and enter the URL of a product page. This runs a Lighthouse audit against your live site from Google's servers under simulated mobile conditions - the same conditions Google uses when assessing Core Web Vitals for ranking.
Run it on a product page that has reviews, not your homepage. That's where the widget loads.
Option B: Chrome DevTools Lighthouse (more control)
Open Chrome, go to your product page, open DevTools (F12), and select the Lighthouse tab. Choose "Mobile" device emulation, check "Performance", and click "Analyze page load".
For the most meaningful results, run the audit in a Chrome incognito window with no extensions active - extensions can interfere with timing measurements.
FiveOh Reviews on Metaobjects has zero JavaScript widget - your reviews are rendered server-side in Liquid with no external network request, no render-blocking scripts.
Get more information →3. Reading the results: what to look for
Opportunities: "Eliminate render-blocking resources"
If the review widget's script tag has no async or defer attribute, it blocks HTML parsing entirely. Lighthouse will flag it here with an estimated savings in milliseconds.
Opportunities: "Reduce the impact of third-party code"
This section lists every third-party origin and its main-thread blocking time. Look for your review app's domain (typically something like cdn.loox.app, stamped.io, yotpo.com). The "Main-thread blocking time" column shows how many milliseconds the script blocked user interaction.
Diagnostics: "Avoid large layout shifts"
This section lists the DOM elements responsible for CLS. If review cards appear here, the widget is injecting them after initial paint without reserving space.
Metrics to record
Note these numbers before and after any changes:
- LCP (Largest Contentful Paint) - target under 2.5 s
- CLS (Cumulative Layout Shift) - target under 0.1
- TBT (Total Blocking Time) - proxy for INP; target under 200 ms
- Performance score - weighted composite; useful for tracking trend
4. Isolating the widget with DevTools Network
Lighthouse gives you aggregate scores. DevTools Network shows you exactly what each request costs in time.
Open DevTools, go to the Network tab, check "Disable cache", reload the page, and wait for everything to settle. Then filter by the review app's domain (type it in the filter box). You will see:
- The JS bundle request - look at its size and transfer time
- The API data request - look at its TTFB (time to first byte) and transfer time
- Any image CDN requests for review photos
In the Waterfall column, note where these requests start relative to the initial HTML response (the first request in the waterfall). The gap between the HTML response and when review content becomes visible is the latency the widget is adding.
5. Real numbers: what a typical widget costs
Based on publicly documented audits and Lighthouse data for common Shopify review apps, typical costs are:
| Metric | Typical JS widget | Server-side (Metaobjects) |
|---|---|---|
| JS bundle size | 50–200 kB (gzipped) | 0 kB |
| External API requests | 1–3 (data, fonts, images) | 0 |
| Main-thread blocking time added | 100–600 ms | 0 ms |
| LCP delay added | 0.5–4 s (connection-dependent) | 0 s |
| CLS from injection | 0.05–0.3 shift score | 0 |
These ranges are wide because they depend on the specific app, your CDN setup, the user's connection speed, and how many reviews are loaded. The point is not the exact number - it is that the server-side number is always zero, because no external request ever happens.
FiveOh Reviews on Metaobjects is the server-side alternative - reviews load with the page HTML, no external API, and your Lighthouse score stays clean.
Get more information →6. The architectural fix
The only way to eliminate the performance cost of a review widget is to stop using one. This means storing review data inside Shopify itself - as Metaobjects - where it is accessible to Liquid during the server-side render. Reviews then become part of the initial HTML response, at zero extra cost in network requests or JS execution.
Shopify's standard product review Metaobject definition (shopify--product-review) is the official data structure for this. Review apps that write to this format store data in your Shopify store, not on their own servers - enabling Liquid-based rendering and eliminating the widget dependency entirely.
Written by Marius Korbmacher
Lead Developer at FiveOh Reviews on Metaobjects
FiveOh Reviews on Metaobjects
Reviews stored in Shopify. Rendered in Liquid. Yours to keep.
The review app that writes to Shopify's standard product review Metaobjects - server-side rendering, no JavaScript widget, no external dependency, no vendor lock-in.