How to Keep a Shopify Store Fast as It Grows

Most Shopify stores start fast. The problems come later, once the apps, tracking pixels, campaign landing pages, oversized images and theme edits start stacking up.

To keep a Shopify store fast as it grows, treat performance as an ongoing process, not a one-off speed fix. Audit new apps before installing them, monitor Core Web Vitals monthly, keep product media optimised, avoid page builder bloat on core templates, remove unused scripts after campaigns and rebuild repeated functionality as native Shopify sections where possible.

The platform itself is rarely the issue. Shopify is built to handle growth. What causes performance to decay is everything that gets layered on top over time, often without anyone keeping track.

If you are already dealing with a slow store, our Shopify performance optimisation service covers audits, fixes and ongoing support. This guide focuses on how to avoid getting there in the first place.

Why Shopify stores get slower as they grow

Ask most store owners why their Shopify site is slow and they will point at the platform. In most cases, Shopify is not the problem. The problem is everything that has been added on top of it.

Here is what typically builds up over time:

• More apps loading JavaScript on every page visit
• More tracking scripts and pixels from Meta, Google, TikTok, Klaviyo and others
• More products with larger image libraries and more variant combinations
• More campaigns leaving behind landing page sections, pop-ups and promo bars
• More theme edits from different developers, often without documentation
• More page builder sections that carry extra dependencies
• More duplicated functionality where two apps do the same thing
• More people making changes without a shared standard for what is acceptable
• More leftover code from apps that were uninstalled but not fully cleaned up

The pattern is always the same: performance was fine at launch, then gradually got worse. Not because anything broke, but because nothing was removed.

A store with 5 apps installed carefully is very different from a store with 20 apps installed over three years without any review. The weight accumulates, and at some point it starts to show in your Core Web Vitals, your page load times and your conversion rate.

Treat speed like a performance budget

A performance budget is a simple idea. You set limits for the things that affect speed, and you treat those limits the same way you would treat a financial budget. When something goes over, you have to make a decision.

For a growing Shopify store, a performance budget might cover:

Useful thresholds to monitor

These are not guaranteed benchmarks, but they are helpful reference points for knowing when to investigate:

• LCP (Largest Contentful Paint): aim for under 2.5 seconds
• INP (Interaction to Next Paint): aim for under 200 milliseconds
• CLS (Cumulative Layout Shift): aim for under 0.1
• JavaScript payload: watch for pages pushing above 400KB to 800KB of JavaScript

The point is not to hit a specific number. The point is to notice when something has changed, and to understand why.

Without a budget of some kind, every new app install, every new campaign script and every new theme edit happens in isolation. No one is weighing up the cumulative cost. A performance budget creates a shared standard so that decisions are made with awareness of their impact.

Audit apps before installing them

Every app you install is a performance decision, whether you think of it that way or not. Most Shopify apps work by injecting JavaScript into your storefront. Some load on every page. Some load only where they are needed. Some leave code behind after you uninstall them.

Before installing any new app, ask:

• Does this feature actually need an app, or could Shopify handle it natively?
• Does the app load scripts on the storefront, or does it only run in the admin?
• Does it load sitewide, or only on the pages where it is used?
• Will it affect product pages, which are usually your highest-traffic templates?
• Is there a lighter alternative that does the same job?
• Who is responsible for removing it if the campaign or project ends?

The question most teams skip: who removes it afterwards?

Apps installed for a seasonal campaign, a one-off promotion or a short-term test often stay installed long after they are needed. Over time, these accumulate into a layer of unnecessary JavaScript that runs on every page load, for no reason.

We cover this in more detail in our guide to Shopify app bloat, including how to identify which apps are actually affecting your storefront and how to clean them up safely.

Keep Core Web Vitals healthy

Core Web Vitals are not a one-time test. They change every time you install an app, update your theme, add a new tracking script or launch a campaign. If you only check them when something feels slow, you will always be reacting rather than managing.

Check them regularly, not just reactively

A good routine for growing stores:

• Check Google Search Console monthly to track LCP, INP and CLS across your key templates
• Test the homepage, product pages and collection pages separately as they have different components and different scores
• Re-test after every app install, especially apps that load scripts on the storefront
• Re-test after theme changes, even small ones
• Re-test after major campaigns, when new scripts, pixels and pop-ups have been added

What to watch for

LCP tends to suffer when hero images are too large or when render-blocking scripts delay the page. INP is often affected by heavy JavaScript from apps. CLS is usually caused by images without set dimensions, late-loading fonts or dynamic content that shifts the layout.

None of these are difficult to diagnose once you know what to look for. The problem is that most stores do not look until the scores have already dropped significantly.

Our guide to Shopify Core Web Vitals explains each metric in detail and covers the most common causes of poor scores on Shopify stores.

Avoid page builder dependency on core templates

Page builders are useful for testing ideas quickly. They let marketers create and edit pages without waiting for a developer, which has real value. The risk comes when they start powering the templates that matter most to your store's commercial performance.

Where page builders create the most risk

• Product pages visited by every customer who considers buying
• Collection pages that carry significant SEO value and organic traffic
• High-traffic landing pages used in paid campaigns
• Navigation-critical pages that sit in your main menu
• Repeated template layouts that are rebuilt from scratch for every campaign

Page builders typically add their own JavaScript, CSS and rendering logic on top of Shopify's. On a one-off landing page used for a short campaign, that overhead is manageable. On your product page template, which loads thousands of times a day, it compounds.

The deeper problem is maintainability. Page builder sections are harder to hand off between developers, harder to optimise and harder to keep consistent as the store grows. When a new developer joins the project, the first thing they often say is that they cannot safely edit the theme because too much of it is controlled by the page builder.

Native Shopify sections, built properly, give you the same flexibility without the dependency. You can edit them in the theme customiser, hand them off to any Shopify developer and extend them without adding another layer of third-party code.

We go deeper on this trade-off in our comparison of Shopify custom theme vs page builder.

Keep product and collection pages lean

Most store owners focus their performance concerns on the homepage. In practice, product pages and collection pages matter more. They carry most of your organic traffic, they are the pages your paid campaigns land on and they are where customers decide whether to buy.

Every feature you add to these templates has a performance cost. That does not mean you should not add them. It means you should be deliberate about what you include and why.

Product page components to weigh up

Collection page components to weigh up

None of these features are wrong to have. The issue is when they are all present at once, each adding its own weight, and no one has reviewed the combined effect on page performance.

Optimise media before it reaches Shopify

Shopify does a reasonable job of processing and serving images efficiently. It converts images to WebP automatically, serves them via its CDN and generates responsive sizes. But it can only work with what you give it. If you upload a 6MB PNG as your hero image, Shopify will serve a smaller version of a very large source file.

The fix happens before the upload, not after.

Media best practices for growing stores

• Resize images before uploading. A product image does not need to be 4000px wide. 2000px is usually sufficient for a high-quality zoom experience.
• Compress large images using a tool like Squoosh or ImageOptim before they reach Shopify.
• Use WebP or AVIF formats where your workflow allows it. These formats are significantly smaller than JPEG or PNG at equivalent quality.
• Avoid oversized hero images. A full-width banner image is one of the most common causes of a poor LCP score. Keep the file size as low as possible without visible quality loss.
• Avoid autoplay video on key templates unless it is genuinely necessary. Video is heavy, and autoplay on product pages or collection pages adds significant load.
• Use proper alt text on all product images. This helps accessibility and search indexing.
• Set image dimensions in your theme code to reduce layout shift. When the browser does not know how tall an image will be, it causes the page to jump as images load, which harms your CLS score.

The practical rule: if an image file is over 500KB before upload, it probably needs compressing. If it is over 1MB, it definitely does.

Clean up after campaigns

Campaigns create performance debt. Not immediately, and not always obviously, but over time the leftovers accumulate.

A typical campaign might involve a new pop-up, a promo bar, a custom landing page, a Meta pixel event, an A/B testing tool and a temporary app for a countdown timer or gift-with-purchase mechanic. When the campaign ends, the results get reviewed, the ads get turned off, and then nothing else happens. The rest stays.

What campaigns typically leave behind

• Pop-ups and promo bars that are disabled but not removed
• Landing page sections that are hidden but still in the theme
• Temporary apps that are no longer used but still installed
• Tracking scripts and pixels added for the campaign
• A/B testing tools that are still loading on every page
• Extra conversion events that are no longer firing correctly
• Seasonal content and promotional banners buried in the theme
• Unused Liquid snippets left in template files

The compounding effect is real. After three or four campaign cycles without a clean-up, a store can easily have double the JavaScript payload it had at launch, with half of it serving no purpose.

The fix is straightforward: build a post-campaign clean-up into your process. After every major campaign, run through what was added and remove what is no longer needed. It takes less time than the campaign setup, and it prevents the slow drift that catches most growing stores out.

Build reusable native Shopify sections

Growing stores repeat themselves. The same trust badges appear on the homepage, the product page and the campaign landing page. The same FAQ layout gets rebuilt three times in a page builder. The same promotional banner gets recreated for every sale.

Each time this happens in a page builder or via a new app, it adds another layer of code. Each time it is built as a native Shopify section, it adds almost nothing.

Layouts worth building as reusable native sections

• Trust badge and accreditation sections
• Review highlight and testimonial blocks
• Size guide and fit information panels
• Product benefit and feature grids
• Comparison tables
• Promotional banners with configurable content
• FAQ sections with schema markup
• Campaign-ready hero sections with swappable content

The investment in building these properly pays back quickly. Instead of installing a new app for each campaign or rebuilding the same layout in a page builder, your team can drop a native section into any template in the theme customiser, configure it and publish. No new dependencies, no extra JavaScript, no performance cost.

This is part of what we mean by custom Shopify theme development done with growth in mind. The goal is not just a fast store at launch. It is a store that stays fast as the team uses it.

When to move from patching to rebuilding

Most performance problems on Shopify stores can be fixed without a rebuild. App audits, script clean-ups, image optimisation and native section work will resolve the majority of issues. A rebuild is not the default answer, and any agency that recommends one without a proper audit first should be questioned.

That said, clean-up is not always enough.

Signs that a rebuild may be the right call

• The theme has years of edits from multiple developers, with no clear documentation
• Core Web Vitals keep failing despite repeated fixes
• Page builders power the product page, collection page or other key commercial templates
• Multiple apps are doing the same job because no one could agree on which one to remove
• Developers are reluctant to touch the theme because too much is fragile or undocumented
• Every new campaign requires a workaround because the theme cannot accommodate it cleanly
• Store owners or developers cannot safely remove old code without breaking something else

The right process is always audit first. A thorough audit will tell you whether the issues are fixable with targeted changes or whether the accumulated technical debt has reached the point where rebuilding is more efficient than patching.

Sometimes the answer is a targeted rebuild of specific templates, not the entire store. A product page rebuilt as a clean native template, replacing a page builder dependency, can make a significant difference without touching anything else.

How Futur Media helps Shopify stores stay fast

Futur Media helps UK Shopify brands keep performance under control as they grow. We audit apps, scripts, theme code, media and Core Web Vitals, then give you a clear fix list. Where needed, we rebuild bloated sections as cleaner native Shopify components so the store stays fast beyond the next campaign.

Our work covers:

• App bloat audits to identify which apps are affecting storefront performance and which can be removed or replaced
• Core Web Vitals fixes targeting LCP, INP and CLS across your key templates
• Custom Shopify development to replace page builder dependencies and app-driven functionality with native sections
• Performance-first builds for stores that need a cleaner foundation
• Ongoing support for teams that want a Shopify developer on hand as they grow

We do not recommend rebuilds as a default. We audit first, identify what is causing the performance issues and recommend the most efficient fix. Sometimes that is a targeted clean-up. Sometimes it is rebuilding a single template. Occasionally it is a full migration to a cleaner theme.

If your store is getting slower as it grows, our Shopify performance optimisation service is the right starting point.

Shopify performance maintenance checklist

Use this as a recurring reference for your team. The goal is to make performance maintenance a habit, not a crisis response.

• Review all installed apps monthly and remove any that are no longer in use
• Disable unused app embeds in the Shopify theme customiser
• Check Core Web Vitals in Google Search Console monthly
• Test the homepage, product pages and collection pages separately
• Compress large new images before uploading to Shopify
• Remove campaign scripts, pixels and pop-ups after each campaign ends
• Audit for duplicate tracking pixels across Meta, Google and other channels
• Avoid using page builders on core commercial templates
• Keep reusable layouts as native Shopify sections where possible
• Re-test Core Web Vitals after every app install
• Re-test Core Web Vitals after every theme change
• Record before-and-after performance scores when making significant changes
• Keep a named owner for performance within the team

The most important item on this list is the last one. Performance decays when no one owns it. Assign someone to keep an eye on it, even if that person is you.

Want to keep your Shopify store fast as it grows?

If your Shopify store is getting slower as you add apps, campaigns and new features, Futur Media can help you find the cause and build a cleaner way forward.

Our Shopify performance audits review your apps, scripts, theme code, media and Core Web Vitals, then give you a prioritised fix list with clear next steps. No jargon, no vague recommendations, no default push towards a full rebuild.

Get a free Shopify performance audit, or if you would prefer to talk through what you are seeing first, book a strategy call and we will take a look together.