Slow Shopify apps: how to measure what each one costs your store
From the work/ 9 min read
Measure the weight of each Shopify app with PageSpeed and DevTools, read the results, and clean the code an uninstalled app can leave in your theme.
- Shopify
- Performance
- Shopify apps
In this article (8)
To find which Shopify apps make your store slow, measure them one at a time: run PageSpeed Insights on a page, filter the DevTools Network panel by domain, and compare page weight with the app on and off. After uninstalling an app, check your theme too, because it can leave code that keeps loading.
This is the method step by step, a console snippet that adds up weight per domain (we ran it locally), and how to clean the theme after removing an app. The weights in the figures are illustrative examples: you have to measure your own store's.
How Shopify apps add weight to your store
An app does not weigh a fixed number of KB. What it adds depends on how it connects to your store. According to Shopify's documentation, an app with a theme app extension can be an app block, which puts content inside the page, or an app embed block, meant for apps that load JavaScript on storefront pages, with no UI or with a floating element. Older apps edit the theme code directly. Either way, the cost arrives from several directions:
| What it adds | How you notice | Where to measure |
|---|---|---|
| The app's JavaScript, served from its own domain | More bytes and more main-thread work | Network and Performance in DevTools |
| The app's CSS, fonts and images | More requests and bytes | Network, Size column |
| Scripts that load other scripts | Request chains that take longer | Network, sorted by Domain |
| Code pasted into the theme | Keeps loading after the app is gone | Search theme.liquid and snippets/ |
| Tracking pixels | Small but numerous requests | Network, filtered by domain |
There are two separate costs. One is the bytes that get downloaded. The other is the time the browser spends running that JavaScript, during which the page answers a tap worse. An app that is light in KB can block more than a heavy one, so measure both. An app may also load only on the product page: measure the main page types (home, collection and product), not just the front page.
Scroll the figure sideways to see all of it
Find the slow apps with PageSpeed: third-party code
PageSpeed Insights tells you whether there is a problem and which domains cause it. Paste the URL of a page on your store and read the mobile report. In the diagnostics, look for the third-party audit. The Lighthouse documentation calls it "Reduce the impact of third-party code" and explains the rule: Lighthouse calculates how long each third-party script blocks the main thread, and if the total blocking time is greater than 250 ms, the audit fails. A third-party script is any script hosted on a domain different from the URL you audit.
Two caveats before you trust that number:
- The audit moved. The same page notes that, as of Lighthouse 13, the audit became part of the insights. There is a third-parties insight that groups resources by third party using the Third Party Web dataset; it always passes and shows for information only, so do not wait for a red mark: read the list.
- A domain is not an app. One app can use several domains, and one domain (a tag manager, say) can serve several apps. The report tells you where to look; the per-app test comes next.
Lab results vary from run to run. Shopify recommends running Lighthouse several times and keeping the median, and its guide to auditing and removing third-party scripts also mentions the Lighthouse Treemap, which shows all the page's JavaScript grouped by origin with byte sizes. If your LCP is also slow, those scripts compete with the main image: in why your LCP is slow because of the hero image we covered how to tell them apart.
Measure each app with DevTools
To pin weight on one specific app, Chrome's Network panel is the direct tool. Do this in a private window with no extensions:
- Open DevTools on the Network panel, turn on Disable cache and pick a preset from the Throttling menu (fast 4G, slow 4G or 3G).
- Right-click the table header and turn on the Domain column.
- Reload the page and sort by Domain: the domains that are not yours are the third parties.
- Type
domain:plus one app's domain in Filter. The status bar shows the total requests and KB transferred. The Size column is the response headers plus the body, as the server delivered them. - To measure the real cost, open the Network request blocking tab, block that domain, reload and compare. Shopify recommends this method in its audit guide, along with the Performance panel: in the Bottom-Up tab, grouped by URL, you see which scripts use the most main-thread time.
Scroll the figure sideways to see all of it
If you want the summary by domain in one table, paste this in the console of the loaded page:
const byHost = {};
for (const e of performance.getEntriesByType("resource")) {
const host = new URL(e.name).host;
const row = (byHost[host] ??= { requests: 0, kb: 0 });
row.requests += 1;
row.kb += e.transferSize / 1024;
}
for (const row of Object.values(byHost)) row.kb = Math.round(row.kb * 10) / 10;
console.table(byHost);
performance.getEntriesByType("resource")returns one entry for every file the page requested.new URL(e.name).hostextracts the domain, with the port if there is one.byHost[host] ??= {...}creates that domain's row the first time it appears.row.requestscounts files androw.kbadds uptransferSize, in KB.- The
Math.roundline keeps one decimal andconsole.tableprints one row per domain.
We ran it once in Playwright's Chromium, on a made-up local page with three origins: the theme (5 KB), an "app origin" with two 40 KB scripts and another with one 120 KB script. It is not a real store. When the app servers did not send Timing-Allow-Origin, the snippet showed 0 KB for both origins; with Timing-Allow-Origin: * it showed 80.6 KB and 120.3 KB. That matches MDN: for a cross-origin resource, transferSize is 0 if it does not pass that check. If you see zeros, do not conclude the app weighs nothing: use the Size column in the Network panel. The snippet does not measure main-thread time either; that is what the Performance panel is for.
Uninstall an app and clean the code it leaves in your theme
Shopify's documentation is clear: uninstalling an app from the admin does not always remove its code from the theme. Apps with a theme app extension do not edit theme code, and the guidance on leftover code is written for apps that do: if they leave code behind, the developer must give you instructions to remove it. So, after uninstalling, check it yourself:
- Duplicate the theme and work on the copy. That is our precaution, not a Shopify requirement.
- Search the theme files for the app's name and its script domain. Check
layout/theme.liquidfor pasted<script>tags. - Look in the
snippets/folder: files an app left often carry its name. - Find the
{% render %}or{% include %}tags that load those snippets. According to Shopify, it is safe to remove the file and the tag together; if you remove only the file, the tag points at something that no longer exists. - Open the page, view the source and search for the app's domain: it should not appear. Also check the App embeds section of the theme editor.
One warning from the same documentation: when you remove the code by hand, leaving even an extra line break or space takes the theme off its upgrade path. Another reason to do it on a copy and check the result before publishing it.
What to check before Black Friday
With Black Friday on November 27, 2026, the order matters: measure first, then decide, then remove, and finally measure again. What you do not want is installing or removing apps during the code freeze; we cover that plan in the Black Friday code freeze.
- List every installed app and, next to each, what it does, who uses it and whether it is still needed.
- Measure the three key pages with and without each suspect app; write down requests, KB and the blocking result.
- Decide for each one: keep, replace or remove. A light app that sells stays.
- Clean the theme of the removed apps and measure the same pages again.
- Test the cart and checkout after each change, and finish before the freeze.
Scroll the figure sideways to see all of it
Common mistakes
- Measuring only the front page. Apps may load only on product, cart or checkout.
- Keeping a single run. Results vary; use the median of several.
- Measuring with the cache on. You will see fewer bytes than a new visitor gets.
- Reading a 0 as "weighs nothing". It may be a missing
Timing-Allow-Origin. - Calling the theme clean after uninstalling. Check
snippets/andtheme.liquid. - Removing an app without testing the cart. Some connect to the cart or checkout.
Frequently asked questions
How many KB is too much for an app?
The documentation we checked gives no universal number. Compare each app with the rest of the page and look at main-thread blocking: Lighthouse's third-party audit fails when total blocking passes 250 ms.
Does uninstalling an app delete its code from the theme?
Not always. Shopify says so in its guide to third-party scripts, and recommends checking the theme and the snippets folder after uninstalling.
Do apps with a theme app extension leave code too?
The documentation says theme app extensions do not edit theme code, and that the leftover-code guidance applies to apps that do. It does not describe what happens to their blocks on uninstall, so confirm it in the theme editor.
Why does PageSpeed give me different numbers each time?
Lab results vary. Shopify recommends running several Lighthouse audits and using the median, and always comparing under the same conditions.
Checklist
- List of installed apps, with what each one does.
- PageSpeed on home, collection and product, on mobile, with the median of several runs.
- Weight per domain in Network, with Disable cache and the Domain column.
- A blocked-domain test for every suspect app.
- A decision per app: keep, replace or remove.
- Theme duplicated;
snippets/,theme.liquidandrendertags checked after each uninstall. - Cart and checkout tested, and changes finished before the freeze.
If your main problem is the hero image, start with the slow LCP; if the campaign is close, leave the cleanup done before the Black Friday code freeze.
Saw this on Instagram? Comment PESO on the Reel and I'll send you the guide.
Written by

Published November 12, 2026 · updated November 18, 2026