How to Audit Your Shopify App Stack

The average Shopify store has 6-8 apps installed. High-growth stores often have 15-20. We have audited stores running more than 30. Every one of those apps was installed for a reason. The problem is that nobody goes back to check whether the reason still holds, whether the app still works properly, or whether it is silently degrading the store's performance.

An app stack audit is the process of systematically evaluating every app on your Shopify store against three criteria: performance impact, cost, and business value. The goal is a leaner, faster, cheaper app stack that does everything you need without the overhead you do not.

We run this audit for every new client we onboard. Without exception, we find apps that should be removed. In most cases, we find opportunities to save £200-£500 per month and improve page speed scores by 10-20 points. This guide walks through the exact process we use.

Why your app stack needs auditing

Shopify apps are remarkably easy to install. One click, authorise, done. That ease of installation is a feature until it becomes a liability. Over time, app stacks accumulate like barnacles on a ship's hull: each one seems harmless individually, but collectively they create drag that slows everything down.

The performance tax

Every app that adds functionality to your storefront does so by injecting code — JavaScript, CSS, and sometimes both — into your theme. This code loads on every page. Even if the app's feature only appears on product pages, its JavaScript bundle may load on the homepage, collection pages, and checkout. The cumulative weight of all these scripts is what we call the performance tax.

We recently audited a UK fashion brand's store and found that their 18 installed apps were collectively adding 1.2MB of JavaScript to every page load. To put that in context, the entire theme (all the HTML, CSS, and theme JavaScript combined) weighed 400KB. The apps were three times heavier than the theme itself. Their mobile PageSpeed score was 34. After removing and replacing unnecessary apps, it was 72.

The cost creep

App costs compound. An app at £29/month does not feel significant. But 12 apps at £29/month is £4,176 per year. Add a couple of premium apps at £79-£149/month and you are looking at £6,000-£8,000 annually in app subscriptions. Many merchants do not even know their total app spend because each subscription is billed separately.

The security surface

Every app you install has access to some portion of your store's data. Most apps request broad permissions during installation — access to orders, customers, products, and more. Each app represents a potential attack vector. If an app's servers are compromised, or if the app developer's practices are not up to standard, your customer data could be exposed. Fewer apps means a smaller attack surface.

Step 1: Take a complete inventory

Open your Shopify admin and navigate to Settings > Apps and sales channels. Create a spreadsheet with every installed app and the following columns:

• App name
• Monthly cost
• Primary function (what does it do?)
• Where it appears (storefront, admin, both, backend only)
• When installed (if you can find out)
• Who requested it (if anyone remembers)
• Last time it was actively used or configured

That last column is the most revealing. If nobody has touched an app's settings in 12 months, there is a good chance it is either working perfectly in the background (good) or doing nothing useful while still loading code and charging you money (bad).

Be thorough. Check for apps that might be hidden or that do not appear in the main apps list. Some older apps install via theme code modifications rather than proper app embed blocks, and they may not show up in your installed apps list at all.

Step 2: Measure performance impact

This is the most technical step, and it is the most valuable. For each storefront-facing app, you need to understand how much JavaScript and CSS it injects and what impact that has on page load time.

Using browser developer tools

Open your store's homepage in Chrome with developer tools open (Network tab). Filter by JS and CSS file types. Look for files that are clearly loaded by apps — they typically have domains or filenames that differ from your theme's files. Note the file size and load time for each.

// Quick audit: check total app JS weight
// Open Chrome DevTools > Console on your storefront

const scripts = document.querySelectorAll('script[src]');
let appScripts = [];

scripts.forEach(s => {
  const src = s.getAttribute('src');
  // Theme scripts come from cdn.shopify.com/s/files/
  if (!src.includes('cdn.shopify.com/s/files/')) {
    appScripts.push({
      src: src.substring(0, 80),
      // Size not available via DOM, check Network tab
    });
  }
});

console.table(appScripts);
console.log(`Total third-party scripts: ${appScripts.length}`);

The disable-and-measure method

For a more rigorous assessment, use a Shopify development store or the theme editor's app embeds panel. Disable each app's theme embed one at a time and run a PageSpeed Insights test after each change. Record the score with and without each app. This gives you a precise measurement of each app's performance impact.

This process is time-consuming but illuminating. We have found individual apps that dropped PageSpeed scores by 15-20 points. Those are the apps that need to go first. This method connects directly with the QA testing process we use for all our builds.

Step 3: Calculate true cost

The monthly subscription is only part of an app's cost. The true cost includes:

• Subscription fee: The obvious monthly or annual charge.
• Performance cost: Slower pages mean lower conversion rates. If an app adds 0.5 seconds to page load time and your store does £50,000/month, even a 0.5% conversion rate reduction costs £250/month in lost revenue.
• Support cost: Time your team spends configuring, troubleshooting, and maintaining the app.
• Conflict cost: Time spent resolving conflicts between apps or between an app and your theme.

When you calculate true cost, the picture often changes dramatically. An app that costs £29/month but adds 800ms to page load is not a £29 app — it is potentially a £300-£500 app once you factor in the revenue impact of slower pages.

Step 4: Identify redundancy and overlap

App redundancy is more common than most merchants realise. Here are the patterns we see repeatedly:

• Multiple review apps: Brands install one reviews app, it does not work perfectly, they install another without removing the first. Both load JavaScript on every page.
• Overlapping analytics: Google Analytics via a Shopify app, plus a pixel app, plus a marketing attribution app, all tracking similar data with separate JavaScript bundles.
• Duplicate functionality: A cart upsell app and a product recommendation app that both add "you may also like" sections. A well-built cart solution can handle both.
• Built-in vs. app: Functionality that Shopify now provides natively (like basic SEO features, email marketing, or simple discount codes) still being handled by a third-party app installed before Shopify added the feature.

Map each app's features against every other app's features. Look for overlap. When two apps do similar things, evaluate which does it better and remove the other. Also check for functionality that is now built into Shopify itself or into your theme — many themes now include features like product filtering that previously required a separate app.

Step 5: Find orphaned code

This step catches problems that the others miss. When you uninstall a Shopify app, it does not always clean up after itself. Code snippets, theme modifications, and script tags can remain in your theme files long after the app is gone.

To find orphaned code, open your theme's code editor and search for:

• Script tags with external URLs (domains that do not belong to Shopify or your theme)
• Liquid snippets with names that match previously installed apps
• Comments referencing app names or installation instructions
• HTTP requests in the Network tab that return 404 errors (the app's server is gone, but your theme is still trying to load its files)

// Check theme.liquid for orphaned app code
// Look for patterns like:
{% render 'some-old-app-snippet' %}

// Or external script tags:
<script src="https://app-domain-that-no-longer-exists.com/widget.js"></script>

// These add load time and potentially cause console errors
// even though the app is no longer installed

We typically find 2-5 orphaned code fragments on stores that have been running for more than two years. Each one is making an HTTP request to a server that either returns an error (adding latency) or loads a script that no longer does anything useful (adding weight).

The keep, remove, or replace framework

For each app in your inventory, apply this decision framework:

Keep if:

• It provides essential functionality that cannot be achieved another way
• Its performance impact is acceptable relative to the value it delivers
• It is actively maintained by a reputable developer
• It does not overlap significantly with other apps or built-in Shopify features

Remove if:

• Nobody on your team knows what it does or why it was installed
• Its functionality is now built into Shopify or your theme
• It has not been updated in 12+ months
• It duplicates functionality provided by another app you are keeping
• It was installed for a specific campaign or test that has ended

Replace if:

• The functionality is essential but the current app has unacceptable performance impact
• A lighter-weight alternative exists that provides the same core features
• The functionality can be achieved with custom theme code at a lower ongoing cost
• Multiple apps could be consolidated into a single custom-built solution

Common app-to-code replacements

Some app functionality is straightforward enough that it can be replaced with lightweight theme code. Here are the most common swaps we make during audits:

App function	Typical app cost	JS weight	Custom code alternative
Announcement bar	£0-£10/mo	30-80KB	Native theme section (0KB added)
Countdown timer	£5-£15/mo	40-120KB	Custom Liquid + 2KB JS
Trust badges	£0-£10/mo	20-60KB	SVG icons in theme (0KB JS)
Back-in-stock alerts	£10-£30/mo	50-150KB	Klaviyo back-in-stock flow
Age verification	£5-£15/mo	30-80KB	Custom modal + 3KB JS
Colour swatches	£5-£20/mo	40-100KB	Theme variant picker (built-in)

The savings from these swaps are not just financial. A store that replaces six lightweight-function apps with theme code removes 200-600KB of JavaScript from every page. That translates to measurably faster page loads, better Core Web Vitals, and higher conversion rates.

For more complex functionality, consider whether a consolidated custom app solution could replace multiple paid apps. We build lightweight, purpose-built apps that handle exactly what your store needs without the overhead of features you will never use.

After the audit

Once you have your keep, remove, and replace lists, implement changes methodically:

1. Remove orphaned code first. This is risk-free and immediately improves performance.
2. Uninstall clear removals. Apps that nobody uses and nobody needs. Test the store thoroughly after each removal.
3. Replace one app at a time. Build or install the replacement, test it thoroughly, then remove the original. Never leave gaps in functionality.
4. Document the final stack. Create a record of every remaining app, why it is there, and who is responsible for it. This makes future audits faster.
5. Set a reminder for the next audit. Six months from now, review again. New apps will have been installed, existing apps will have been updated, and Shopify will have added new built-in features.

Track the results. Run PageSpeed Insights before and after the audit. Calculate the monthly cost saving. Monitor conversion rate for the two weeks following the changes. These metrics justify the time spent and make the case for regular audits going forward. As part of a broader Shopify development relationship, we build app audits into our ongoing retainer work.

The leanest Shopify stores are not the ones that never installed apps. They are the ones that regularly audit what they have and make ruthless decisions about what stays. Performance and simplicity are ongoing disciplines, not one-time projects.

Andrew Simpson, Founder

---

Your Shopify app stack is either an asset or a liability. A curated, lean stack improves performance, reduces costs, and minimises security risk. A bloated, unaudited stack does the opposite. The audit process outlined above takes a day or two of focused work, but the returns — in faster pages, lower costs, and better conversion rates — last for months.

If you would like help auditing your app stack, get in touch. We will run through the full analysis and give you a prioritised list of recommendations.