Industries

Do review widgets slow down your website? We measured three

12 October 2026 · JustReview

Yes, a review widget can slow down your website, but usually not by delaying the page itself. It adds work after the main content has painted: layout shift when its reviews push content down, and main-thread blocking while its script runs. On a clean test page we measured three widgets, our own, Elfsight’s and Trustindex’s, and none of them moved the largest paint beyond normal run-to-run noise, while one of them added 424 ms of blocking time and all three shifted the layout when placed in the first screen. Both problems have a fix that takes a few lines of CSS or JavaScript.

All measurements in this post were taken on 12 October 2026.

How we measured it

We built one plain product page for a fictional ceramics shop: a header, a headline, a short paragraph, a button, a 1200 by 800 hero photo of 72 KB with its width and height set, six sections of text and a footer. No framework, no analytics, no other third-party script. Then we made copies of that page that differ in exactly one thing: which review widget is on it and where.

Each widget went in exactly the way its vendor tells you to install it. Ours is the snippet our dashboard generates (stylesheet, a deferred script, init on DOMContentLoaded, a container where the widget appears). Elfsight’s is their async platform script plus a div with the lazy attribute their code generator adds. Trustindex’s is their loader script with defer async, placed where the widget should appear. For the competitors we used demo widgets that Elfsight and Trustindex run on their own websites, so we did not need a customer’s widget and did not touch anyone’s account. All three are the same kind of widget: a carousel of review cards with a header.

We tested each copy in two ways:

1. Lighthouse 12.8.2 with its default mobile settings, the engine behind PageSpeed Insights: an emulated mid-range phone, four times slower CPU and a simulated slow 4G connection. Five runs per variant, interleaved so that a slow minute on our network could not land on one widget only, and we report the median. Lighthouse does not scroll, which matters later.
2. A real Chromium browser with the same slowdowns applied, scrolled down to the widget and left for 15 seconds, three loads per variant. This is how we counted what each widget downloads when a visitor actually sees it, including widgets that wait for the scroll.

The results with the widget in the first screen

On a phone the widget section started 599 px from the top, so its upper part was visible on load, which is where most sites put reviews when they want them seen. The table is sorted by the Performance score Lighthouse shows you, because that is the number people check.

Medians of five Lighthouse mobile runs. Page weight includes the 81 KB the page weighs on its own.

Largest Contentful Paint, the metric most people mean when they ask whether a page got slower, gave no result we could pin on any widget. The hero photo was the largest element in all 50 Lighthouse runs, so no widget ever became the LCP. The value itself moved between about 1.05 and 1.6 seconds on every page, including the one with no widget at all (1.05 to 1.35 seconds). Our own widget shows why that spread is noise: the default snippet had a median of 1.56 seconds, and the same scripts with the height reserved had 1.05 seconds. A CSS rule below the hero photo cannot make the photo paint faster.

So the honest answer to the question in the title is: the load itself barely moves, the experience after it does. A visitor does not feel a slower first paint, they feel the text jump while they are reading it, or a page that ignores their first tap for half a second.

Layout shift: the cost everyone pays, and the easiest to remove

Every one of the three widgets shifted the layout when it sat in the first screen, and for the same reason. The page renders an empty container, the script fetches the reviews, and a block several hundred pixels tall appears and pushes everything below it down. Google’s threshold for a good Cumulative Layout Shift is 0.1. Trustindex landed at 0.103 in all five runs, just over the line. Elfsight varied between 0.045 and 0.105 depending on when its carousel finished loading. Ours was 0.063 in every run. Layout shift depends on timing: in a second series, with the slowdown applied inside the browser instead of simulated, Trustindex shifted far less (0.004), while Elfsight and ours stayed where they were.

The fix does not depend on the vendor: tell the browser how tall the widget will be before it arrives. Our carousel measured 908 px tall on a 412 px wide phone and 873 px on a desktop-width page, so we reserved that much:

#justreview-testimonials { min-height: 873px; }
@media (max-width: 600px) {
  #justreview-testimonials { min-height: 908px; }
}

With that one rule our CLS dropped from 0.063 to 0.001 and the Performance score went back to 100. Measure the height on your own page, because it depends on your settings: hiding the header or the button, or showing fewer slides, makes the widget shorter. If the reserved space is a little too large, the cost is some empty space under the carousel. If it is too small, you get part of the shift back.

Blocking time: where one widget costs 424 ms

Total Blocking Time is the sum of the parts of long JavaScript tasks above 50 ms, the moments when the page cannot respond to a tap. It is the lab stand-in for Interaction to Next Paint, the responsiveness metric in Core Web Vitals.

Two of the three widgets barely registered: ours added a median of 6 ms and Trustindex 2 ms, both within the range the empty page produced on its own (0 to 28 ms). Elfsight added 424 ms, between 314 and 523 ms across the five runs, and Lighthouse attributed 1,521 ms of main-thread work to its scripts, against 165 ms for ours and 185 ms for Trustindex’s. Most of it comes from one file: the Elfsight reviews app is a single script of 460 KB over the wire, which the phone has to download, parse and run before the carousel exists. That is also why the Elfsight widget took a median of 5.4 seconds to appear in our second test, against 1.8 seconds for ours and 1.5 for Trustindex.

None of this makes Elfsight a bad product. It is a platform that runs dozens of apps, and its reviews widget is built on it. But if your mobile score matters to you, this is the number to know before you install it.

Below the fold, the cheapest widget is the one that has not loaded yet

When we moved each widget to the bottom of the page, after six sections of text, all three pages scored 100 with zero layout shift. That looks like good news for all three. It is not the same news.

Elfsight’s and Trustindex’s default snippets wait until the widget is about to scroll into view. In Lighthouse, which never scrolls, the Elfsight page downloaded 15 KB of its loader and Trustindex 34 KB, and nothing else. Our default snippet does not wait: the full 204 KB of the JustReview widget loaded on every view, including for visitors who never reach the bottom of the page. It did not hurt the score, because the script is deferred and runs after the page has painted, but it is data the visitor paid for and may never see.

If your reviews sit far down a page, load ours on scroll instead. This wrapper replaces the stylesheet, script and init lines of the snippet; keep your own settings object from the dashboard:

<div id="justreview-testimonials"></div>
<script>
(function () {
  var box = document.getElementById('justreview-testimonials');
  var io = new IntersectionObserver(function (entries) {
    if (!entries[0].isIntersecting) return;
    io.disconnect();
    var css = document.createElement('link');
    css.rel = 'stylesheet';
    css.href = 'https://justreview.co/widget/justreview.css';
    document.head.appendChild(css);
    var js = document.createElement('script');
    js.src = 'https://justreview.co/widget/justreview.js';
    js.onload = function () {
      JustReview.initTestimonials('YOUR_USER_ID', { /* your settings */ });
    };
    document.head.appendChild(js);
  }, { rootMargin: '600px 0px' });
  io.observe(box);
})();
</script>

We tested it on the same page: zero requests to our servers before the visitor scrolled, six after, and the full carousel rendered with no errors. The rootMargin starts the download 600 px before the widget enters the screen, so on a normal connection it is ready by the time the visitor gets there. In Lighthouse that page transferred 82 KB in 3 requests in all five runs, practically the 81 KB of the page with no widget.

What each widget downloads when a visitor actually sees it

Lighthouse only counts what loads without scrolling. To compare the full cost, we scrolled to each widget in a real browser and counted every byte, request and host that the widget caused.

Three loads per widget, first-screen placement, slowed CPU and network. “Visible after” is the time from the start of navigation until the widget’s section was taller than 150 px.

Trustindex is the lightest of the three when it shows a normal set of reviews: 112 KB from its own CDN and 32 KB of reviewer photos. The range comes from one file. In seven of the eight first-screen loads in our two tests, the carousel included a reviewer without a profile picture, and the default avatar for that reviewer was a 1200 by 1200 pixel JPEG of 368 KB, fetched from Tripadvisor’s image CDN as a placeholder. That one file weighed more than twice as much as the rest of the widget.

Elfsight’s 866 KB is the app script of about 460 KB, 327 KB of images through its image proxy (the demo shows review photos), and the rest in data and loader files spread over six hosts.

Ours is the script (126 KB), the stylesheet (16 KB), three font files of about 19 KB each and one call to our API of about 5 KB. It shows no avatars and no review photos, which is part of why it is smaller and also a design choice you may or may not like.

How to add a review widget without slowing down your site

The checklist that came out of these measurements, in the order it matters:

• Reserve the widget’s height in CSS if it appears in the first screen. This alone took our CLS from 0.063 to 0.001, and it works for any vendor.
• Load it on scroll if it sits below the fold. Elfsight and Trustindex do this by default, ours needs the wrapper above.
• Put one widget on a page, not three. A second widget of the same vendor reuses the script, but each extra block is another layout shift and another round of data.
• Never load a widget script synchronously in the <head>. All three default snippets are async or deferred. Some page builders and tag managers move them; check the final HTML.
• Check the result on a phone profile, not on your laptop. Our numbers come from Lighthouse’s mobile settings with a four times slower CPU, the profile behind the mobile score in PageSpeed Insights, and that is where the 424 ms shows.

If you are still choosing where on the page reviews should go, our scan of 282 live homepages in where to put reviews on your website covers the placement side, and the comparison of free Google reviews widgets covers price and limits. This post was only about speed.

Why JustReview, if speed is on your list

Our widget does the least work on the visitor’s phone: in this test it added 6 ms of blocking time against 424 ms for Elfsight, made 6 requests to 2 hosts while the others made 18 or more, and never sent the visitor’s browser to Google’s, Tripadvisor’s or anyone else’s image servers. With its height reserved, the page scored the same 100 as the page without any widget. The same script carries reviews from Google, Facebook and marketplaces such as Amazon or Etsy in one carousel, so one widget replaces the three you would otherwise stack, and the install is the same four lines on any site, see how to embed reviews on your website. If you compared us with these two on other criteria, the side-by-side pages for Elfsight and Trustindex have the details.

The caveats, so you know them before you install rather than after. Our default snippet is not lazy, so below the fold you want the wrapper from this post. The carousel is tall on phones, about 900 px with the header and button on, so reserve that space or trim the settings. And the three font files are a quarter of our weight; if your site already uses a similar font, that part is the cost of a consistent look, not of the reviews.

The floating badge is on the free plan, with 100 stored reviews from Google and Facebook. The carousel we measured here starts on Plus at 9 € a month, and every plan has unlimited page views, so lazy loading saves your visitors data, not your quota. The full split is on the pricing page. To run the same test on your own page, create a free account and paste your widget in.