Shopify App Speed: Find the App Slowing Your Store
⏱ 13 min read
Shopify Apps Killing Site Speed: How to Find the Culprit and Clean Up Leftover Code
Your store has collected apps over the years: a review widget here, a chat popup there, two upsell tools, three tracking pixels. Each one ships its own JavaScript, and together they turn into a real problem. Your Shopify app speed drops, the page loads sluggishly, and both Google and your customers notice. The catch almost nobody knows: uninstalling an app does not remove its code. This guide shows you how to find the real culprit and remove the leftover code cleanly, without throwing out your whole app stack.
How Apps Turn Into a Site-Speed Problem
A Shopify store rarely gets slow because of one file. It gets slow because every app, script and feature quietly joins the page load. Each one chips away at your Shopify app speed. Four mechanisms are behind it:
- JavaScript on every page. Many apps load their code globally, even on pages where their feature isn’t used.
- Render-blocking resources. App CSS and scripts in the
<head>delay the first paint, even when they’re irrelevant to the visible area. - Extra requests and third-party domains. Every app brings its own connections, and each one costs a DNS lookup, a handshake and load time.
- Main thread and INP. Event listeners from chat, popup and tracking apps compete for main-thread time and worsen how the page responds to clicks.
This hits your Core Web Vitals directly. Why the lab score misleads and what Google actually measures is covered in our piece on Shopify Core Web Vitals. And how to fix the hero image and LCP specifically is in the Shopify LCP fix guide. This article deals with the apps themselves.
Why Uninstalling an App Doesn’t Remove Its Code
This is the most important and most underrated point. When you delete an app, you only revoke its access to your admin data. You do not remove the Liquid snippets, JavaScript and CSS files it injected into your theme. In practice: if you tested ten different upsell apps over a year, you may be loading ten dead scripts on every page view, quietly taxing your Shopify app speed. This is called “ghost code”, or theme bloat.
There are two kinds of app code you need to tell apart:
- App embeds. Modern apps use the app-embed system (Online Store > Themes > Customize > App embeds). These toggle on and off and are removed automatically when you uninstall.
- Manually pasted code. Older apps ask you to paste code into
theme.liquid, or drop snippet and asset files. That is exactly the code that stays behind and has to come out by hand.
When choosing new apps, prefer ones that use app embeds over ones that ask you to paste code into theme.liquid. It’s stated in the app’s install instructions. That way, uninstalling cleans up on its own later.
Step 1: Get a Baseline Before You Touch Anything
Without a starting point, you can’t later prove your clean-up did anything. Measure first, then act.
- Run your homepage, a representative product page and the cart page through PageSpeed Insights.
- Note your Core Web Vitals, your total JavaScript payload and the number of render-blocking resources.
- Save these numbers as your “before”, separately per template.
Measure first, and work on a theme copy. A baseline proves the effect, and a duplicate protects you from taking the live store apart.
How to Diagnose a Shopify App Speed Problem
Now you find the culprit behind your Shopify app speed with data, not a hunch. Four tools, from simplest to most precise.
PageSpeed Insights: the third-party diagnostics
Open your product page in PageSpeed Insights and read these items specifically: “Reduce the impact of third-party code” groups scripts by provider with their blocking time, and “Reduce unused JavaScript” shows code that loads but isn’t used. Cross-reference the listed domains with your installed apps. The largest byte and blocking values are your priorities.
Chrome DevTools: Network and Coverage
Open DevTools (F12), the “Network” tab, filter by JS and reload the page. Sort by size or time and you’ll see every script your theme and apps pull in. Scripts from external domains are the third parties. The “Coverage” tab (via Ctrl+Shift+P, then “Show Coverage”) also shows what percentage of each file goes unused.
WebPageTest: block a domain and compare
The cleanest proof. In WebPageTest, open the “Block” tab under “Advanced Configuration” and block the suspect app’s domain. Then compare the run with and without it. Shopify documents this method in its own performance documentation. It measures a single app’s real contribution to load time.
Shopify Theme Inspector: find slow Liquid
The Shopify Theme Inspector Chrome extension shows, as a flame chart, which section and which app block cost how much server render time. That surfaces app code slowing the page during rendering, before it even reaches the browser.
The App Categories That Cost the Most
Certain app types show up as the culprit in nearly every Shopify app speed audit, because of how they load and what they do.
| App category | Typical symptom | What to do |
|---|---|---|
| Chat & support widgets | Large JS, loads globally, high INP | Load only where needed, or replace |
| Review apps | Heavy widgets, render-blocking | Lazy-load, build the markup natively |
| Social-proof & popup apps | Many requests, layout shift | Limit to a few pages |
| Page builders (legacy) | Large section and snippet files | Remove files after uninstalling |
Chat and support widgets are the classic suspect: they load heavy JavaScript on every page, even though the chat may only be needed on a handful of them.
Step 2: Audit Your App Stack
Before you delete any code, decide which apps stay at all. Go through the list honestly and ask three questions per app:
- Do you still use it? Test apps from a year ago are the most common ballast.
- Does it overlap? Two apps for the same feature mean double the JavaScript.
- Is there a native alternative? Some app features can be built directly, and more lightly, into the theme.
Anything that doesn’t survive those three questions goes on the uninstall list. Every removal is a direct Shopify app speed win. If you want to keep a feature, build the native version before you remove the app.
Seeing red scores but unsure which app is causing them?
Shopify PageSpeed Audit
We measure each app’s speed contribution and name the real culprit.
Get a speed audit →Shopify Theme Development
We remove ghost code cleanly and rebuild needed features natively.
Clean up the code →Technical SEO for Shopify
We connect a faster store to the rankings it should earn.
Check the basics →Step 3: Uninstall Cleanly and Remove Ghost Code
Now comes the part the uninstall button doesn’t do for you.
First, duplicate your theme
Online Store > Themes > Actions > Duplicate. Work on the copy, check it in preview, and publish only when everything works. The most common clean-up mistake is deleting a snippet a section still renders, or a script another one depends on.
Where app code hides
Open the code editor (Actions > Edit code) and search these places for the name or domain of the uninstalled app:
theme.liquid,header.liquidandfooter.liquidfor stray<script>tags and{% render %}lines,- the
snippetsfolder for files with app names likeyotpo-head.liquidorloox-reviews.liquid, - the
assetsfolder for orphaned JS and CSS files, - the app-embeds view for toggles from apps that no longer exist.
This is what typical ghost code left after an uninstall looks like:
<!-- App uninstalled, these lines now load into nothing -->
{% render 'yotpo-widget' %}
<script src="https://cdn.example-app.com/loader.js" defer></script>How to confirm code belongs to a dead app
Three safe ways: search the theme code for the brand or domain name (apps usually leave it in the src URL, the filename or comments). Open the browser console and watch for 404 errors from scripts loading into nothing, a clear ghost-code signal. Or install the app fresh on a test theme and diff the difference, which is its footprint.
Never delete code directly in the live theme, and never without a duplicate. Don’t remove code from an app you still use, either. When in doubt, ask the app developer for removal instructions or take a backup before you save.
Common Mistakes When Cleaning Up App Code
Even a good clean-up stalls if you fall into one of these traps.
- Working without a theme duplicate. One wrong click and the live page is broken.
- Deleting code from an app you still use. Always confirm the app is actually gone first.
- Removing a snippet a section still renders. Test in preview before you publish.
- Chasing every script. Some app scripts belong to features you want to keep; those need taming, not killing.
- Not measuring again. Without a before-and-after, you don’t know whether it helped your Shopify app speed.
How to Confirm Your Shopify App Speed Improved
Measure in two steps, or you’ll draw the wrong conclusions:
- Immediately, in the lab. Run the same templates through PageSpeed Insights again and compare JavaScript payload, render-blocking resources and requests against your before number. That is your Shopify app speed gain, quantified.
- After two to four weeks, in the field. The official Core Web Vitals assessment is based on a rolling 28-day window of real users. Don’t expect Search Console to move instantly.
For context on why the work pays off: according to the 2025 Web Almanac, a typical mobile page now ships around 700 KB of JavaScript, much of it third-party. Every dead script you remove cuts straight into that load.
When an App Can Stay and When It Has to Go
Not every app is a problem. Some earn their weight: a review app that drives revenue is worth its few kilobytes if it loads cleanly. The honest rule: keep what makes a measurable contribution and behaves. Replace what overlaps with another app. Rebuild natively what the theme can do just as well. And remove entirely what is dead. Good Shopify app speed doesn’t come from deleting every app, but from every remaining app earning its place.
Done the clean-up and want to know what’s still holding it back?
Shopify PageSpeed Audit
We hand you an app-by-app speed report and the exact fix order.
Check my load time →Shopify Theme Development
We strip the ballast and build features natively instead of loading another app.
Clean the theme →Technical SEO for Shopify
We make sure a faster store turns into better rankings.
Get an SEO audit →Shopify App Speed: Frequently Asked Questions
Often, yes. Uninstalling only revokes an app’s admin access; the Liquid snippets, scripts and asset files it added to your theme usually stay. These keep loading on every page as ghost code. App-embed code is removed automatically, but manually pasted code has to be found and deleted by hand.
Run a product page through PageSpeed Insights and read “Reduce the impact of third-party code” and “Reduce unused JavaScript”, then cross-reference the domains with your apps. For proof, block a suspect domain in WebPageTest and compare, or check the Network tab in Chrome DevTools.
There is no fixed number. What matters is how each app loads, not the count. An app that loads its JavaScript globally on every page hurts more than three that load only where needed. Audit each app’s real impact in the field data rather than counting installs.
Usually, yes. Dead scripts from uninstalled apps keep downloading, parsing and executing on every page load, adding weight for a service that no longer exists. Removing them reduces requests, JavaScript payload and main-thread work, which helps LCP and INP, especially on mobile. Always measure before and after.
It is safe if you work on a duplicate theme, not the live one. Duplicate it, remove the code on the copy, preview and test, then publish. The common risk is deleting a snippet a section still renders. If you are unsure about Liquid, have a developer do it.
App embeds are app features you toggle on or off in the theme editor under Online Store > Themes > Customize > App embeds. They are better because uninstalling the app removes the embed automatically, leaving no ghost code. When choosing apps, prefer ones that use embeds over pasted code.
A cleanup app can scan and flag leftover code, which is handy. But the reliable method is manual: search your theme files for the app’s name or domain, confirm the app is gone, and delete on a duplicate theme. Adding an app to remove apps is a little ironic, so use it as a scanner, not a crutch.
Review your app stack every quarter, and always after removing or replacing an app. Apps accumulate quietly, and each install or theme change can regress your speed. A short quarterly audit, plus a PageSpeed check on your key templates, keeps ghost code and bloat from creeping back.
Vladyslav Kharkivskyi
