The average Shopify store has 6–12 active apps. Each one adds JavaScript to every page load. Most merchants have no idea how much performance they're giving up — or which specific app is responsible.
Apps are how most Shopify merchants extend their store's functionality. Reviews, chat, loyalty programmes, upsells, size guides, currency converters. The ecosystem is vast, and it's easy to accumulate apps over time — installing one for a campaign, another for a feature test, and forgetting to remove them.
The problem isn't apps per se. It's that every app with a storefront component injects JavaScript into your theme. And most of that JavaScript loads synchronously — blocking your page from rendering until it's done.
This article walks through how to identify which apps are contributing to your performance problems, how to quantify the impact, and what options you have for fixing it.
Why Apps Slow Down Shopify Stores
When a browser loads a Shopify page, it processes resources in a queue. HTML first, then CSS, then JavaScript. Synchronous JavaScript — the kind most Shopify apps inject by default — pauses everything else until it finishes downloading and executing.
One app doing this might add 80ms. Three apps doing this might add 400ms. Six apps, all injecting JavaScript with no load order management, can add 800ms or more to your LCP — on every page load, for every visitor.
There are three ways apps affect performance specifically.
1. Global Injection
Most apps inject their JavaScript into every page of your store, regardless of where they're actually needed. A size guide app runs on your homepage. A product bundle app fires on your blog posts. A loyalty popup loads on your checkout confirmation page.
This is the default because it's the easiest implementation. It's also the most expensive in performance terms.
2. Render-Blocking Load Order
Apps loaded in the document head, or without async/defer attributes, block the browser's rendering pipeline. The browser can't paint anything until that script has been downloaded, parsed, and executed — regardless of whether it's visible above the fold.
3. Third-Party Network Calls
Many apps don't just inject JavaScript — they also make network requests to their own servers on page load. A reviews app fetching star ratings. A personalisation app calling a recommendation API. A chat widget checking for unread messages.
Each of these creates a dependency on a third-party server's response time. If that server is slow, or experiences latency, your page load time inherits that problem.
How to Identify Which Apps Are Slowing Your Store
There are four practical steps to isolating your app impact.
Step 1: Run a Render Waterfall Analysis
The most accurate way to see your app impact is to analyse the network waterfall — the sequence in which every resource on your page loads. Tools you can use: WebPageTest (webpagetest.org) — free, shows full waterfall with timing per resource. Chrome DevTools → Network tab → record a page load, sort by initiator. GTmetrix — waterfall view with filmstrip showing when content becomes visible.
In the waterfall, look for JavaScript files loading from third-party domains (not cdn.shopify.com). Each one is an app. Note their load start time and duration — particularly any that load before your LCP element appears.
Step 2: Use the Shopify Theme Inspector
Shopify's Theme Inspector (available as a Chrome extension) shows you a flame graph of your theme's Liquid rendering performance. While it doesn't show JavaScript impact directly, it identifies which sections and snippets are taking the most server-side render time — useful for separating theme issues from app issues.
Step 3: Disable Apps Temporarily and Measure
The simplest diagnostic: create a duplicate theme, disable apps one by one in the theme code, and measure LCP with each one removed. This isolates the exact contribution of each app.
It's time-consuming, but it gives you precise data. A 400ms LCP improvement from disabling a single app is hard to argue with.
Step 4: Check Your App List Against the Impact Table
Some app categories are consistently high-impact. Use this as a starting triage:
- Reviews & UGC (e.g. Yotpo, Judge.me): High impact — defer JS; load only on product pages
- Live chat (e.g. Tidio, Gorgias): High impact — load on interaction only (lazy trigger)
- Upsell & cross-sell popups: High impact — load after page interactive (defer)
- Loyalty & rewards (e.g. Smile.io): Medium impact — defer; exclude on checkout
- Size guides / fit finders: Medium impact — load on product pages only; defer
- Email capture / popups: Medium–High impact — trigger on scroll or delay, not on load
- Wishlist apps: Low–Medium impact — audit frequency; often replaceable natively
- Currency converters: Medium impact — replace with Shopify Markets where possible
- Analytics pixels (Meta, TikTok, GA4): Medium impact — load via GTM; sequence after LCP paints
- Product personalisation / bundles: High impact — load on interaction; not globally
What to Do With the Results
Once you know which apps are contributing to your performance problems, you have four options.
Option 1: Remove Apps You Don't Actively Use
The most obvious fix, and the most overlooked. Many Shopify stores have apps installed from years ago that are no longer actively used, but are still injecting JavaScript on every page load.
Go to your Shopify admin → Apps, and audit every app against two questions: Is this generating measurable revenue or value? Was it installed in the last 12 months? Any app that fails both gets removed.
Option 2: Restrict Apps to the Pages Where They're Needed
Many apps allow you to control which pages they load on, either through their settings or through conditional loading in your theme's app block configuration. A size guide app only needs to run on product pages. A blog-related app doesn't need to load on your checkout.
This doesn't reduce the JavaScript payload on the pages where the app runs, but it eliminates unnecessary load on every other page.
Option 3: Defer App JavaScript Loading
For apps that can't be removed or restricted by page type, the next best option is to defer their loading until after your page's main content has rendered.
This requires editing your theme code to change how the app's script tag is loaded. Moving from synchronous loading to deferred or asynchronous loading, or triggering the script on a user interaction like scroll or click, can recover 200–600ms of LCP without removing the app at all.
This is technical work that requires care: some apps break if loaded asynchronously because they depend on DOM elements being present. A developer needs to test each change individually.
Option 4: Replace High-Impact Apps With Leaner Alternatives
Some app categories have inherently heavy implementations. If your reviews app is consistently adding 600ms to your LCP and you can't defer it effectively, it may be worth evaluating lighter alternatives — or moving to Shopify's native review functionality if your requirements allow.
The same applies to chat widgets, currency converters, and wishlist functionality — all of which have native or near-native Shopify options that carry significantly less JavaScript overhead.
The Compounding Problem of App Accumulation
Here's the pattern we see on stores that have been running for two or more years: App installed for a promotion or feature test. Promotion ends — app is no longer actively used. App remains installed because removal feels risky. Another app is installed for the next initiative. Repeat six times over three years.
The result is a store running 10–15 apps, of which 4–6 are actively contributing to performance problems and 2–3 are providing no measurable value at all.
A once-yearly app stack audit — reviewing every installed app against its value contribution and JavaScript footprint — is one of the highest-ROI maintenance activities available to a Shopify merchant. It costs a few hours and can recover hundreds of milliseconds of load time without touching a single line of theme code.
We've audited stores where removing three unused apps reduced LCP by over 900ms. That's a full second of load time — recovered by clicking 'Uninstall' three times.
How App Auditing Fits Into a Full Performance Strategy
App auditing is one component of a complete Shopify performance fix. It addresses the third-party JavaScript layer, but it doesn't resolve ghost code in your theme, suboptimal LCP element loading, font rendering issues, or CSS bloat — all of which can independently cause poor performance.
A full performance audit covers all of these layers together, prioritises fixes by revenue impact, and delivers measurable results in field data — not just an improved lab score.
Most stores have at least 2–3 apps that can be removed or deferred immediately, with no loss of functionality and a meaningful LCP improvement.
Conclusion
Want to know exactly which apps are costing you performance — and revenue? Start with a free Performance Scan to get a clear picture of your store's real-world load time and where it's coming from.
Or book the 1-Day Shopify Performance Fix — we handle the full audit, including your app stack, and deliver measurable improvements in a single engineering day.