How to use Shopify Speed Optimization
A hands-on guide to making Shopify stores faster: where the weight actually comes from, which fixes move LCP the most, and how to keep speed from regressing after every app install.
Shopify Speed Optimization
The practice of reducing render-blocking weight on Shopify stores so pages hit a sub-3-second LCP and convert better.
Shopify speed optimization is the work of squeezing render-blocking weight out of a Shopify storefront — bloated themes, app-injected scripts, oversized hero images, and a long tail of third-party marketing tags — so pages load fast enough to convert. Shopify's hosted CDN, Brotli compression, and image transformation handle the infrastructure layer for you; what you control is everything that sits on top: which theme you picked, which apps you left installed, which pixels marketing keeps adding. Most stores in the €1M-€15M revenue band sit between 3.5 and 5.5 seconds on mobile Largest Contentful Paint. Pulling that under 3 seconds is usually a theme and app problem, not a hosting problem.
If your Shopify store loads in 5 seconds on a mid-range Android over 4G, you are quietly bleeding conversions before anyone sees a product. Every additional second of mobile load time costs roughly 4-7% of conversion rate in the apparel and beauty verticals — and the cost compounds at the funnel stages where intent is highest (PDP, cart, checkout).
The good news: Shopify gives you a fast baseline. The CDN, edge caching, and HTTP/2 are already handled. The bad news: that baseline is the easiest 20% of the work. The remaining 80% — theme weight, app scripts, image sizing, third-party tags — is yours, and it regresses every time someone installs an app or pushes a marketing pixel.
Diagnose before you optimise
Start with field data, not lab scores. Lighthouse and PageSpeed Insights give you a synthetic snapshot; Chrome UX Report (CrUX) and your real-user monitoring tell you what actual shoppers experience on actual devices. The gap between the two can be 30-40 points.
Focus on three numbers: Largest Contentful Paint (LCP, target under 2.5s), Interaction to Next Paint (INP, target under 200ms), and Cumulative Layout Shift (CLS, target under 0.1). LCP is where Shopify stores fail most often, almost always because of an unoptimised hero image or a render-blocking app script in the theme head.
Run Shopify's built-in Online Store Speed report alongside WebPageTest filmstrips. The filmstrip tells you what the shopper sees frame by frame — and when you watch it, you'll usually spot one specific element (a chat bubble, a review widget, a hero carousel) that delays paint by 1-2 seconds on its own.
Don't chase the Lighthouse score
A 95 Lighthouse score on your dev machine over fibre doesn't help a shopper on a 3-year-old Android in a Madrid metro. Optimise for the 75th-percentile field LCP from CrUX — that's the number Google uses for ranking, and the number that correlates with revenue.
Theme and app weight: where the seconds actually live
Shopify 2.0 themes (Dawn, Sense, Refresh) ship lean — usually under 100KB of JavaScript on a fresh install. Older themes and heavily customised vintage themes from 2018-2020 can hit 600KB+ of JS before a single app loads. If you're on a legacy theme, a clean rebuild on Dawn typically wins back 1.5-2.5 seconds on LCP, and pays for itself within a quarter.
Apps are the bigger ongoing problem. Each installed app can inject a script tag, a stylesheet, or both, and most of them load synchronously on every page — including pages where the app does nothing. A typical mid-size Shopify store runs 18-25 apps; audit the list and you'll usually find 4-6 that haven't been used in months but are still loading scripts on every PDP.
Mobile LCP vs conversion rate on Shopify stores
The curve is steepest between 3 and 5 seconds — exactly where most Shopify stores sit. Moving from 4.5s to 3.0s on mobile LCP recovers roughly 20-25% relative conversion, which on a €5M store is around €1M in annual revenue from one workstream.
Images, fonts, and third-party tags
Hero images are the single most common LCP element on Shopify PDPs and homepages. Three rules: serve WebP or AVIF (Shopify does this automatically if you use the image_url filter with format: webp), size images for the actual rendered viewport (don't ship a 2400px hero to a 390px iPhone), and add fetchpriority="high" to the LCP image so the browser prioritises it over below-the-fold assets.
Fonts: subset to the characters you actually use, preload the two weights above the fold, and set font-display: swap so text isn't invisible while a custom font loads. Third-party tags — Meta Pixel, TikTok Pixel, Klaviyo, Gorgias, review widgets, A/B test tools — should load async or deferred, and you should know exactly which page each one fires on.
Typical weight contribution by source on a mid-size Shopify store (mobile, kilobytes transferred)
| Source | Lean store | Typical store | Bloated store |
|---|---|---|---|
| Shopify core + theme JS | 80 KB | 180 KB | 450 KB |
| App scripts (10-25 apps) | 120 KB | 380 KB | 900 KB |
| Hero & product images | 180 KB | 420 KB | 1,200 KB |
| Custom fonts | 40 KB | 90 KB | 240 KB |
| Marketing pixels & tags | 30 KB | 150 KB | 380 KB |
| Total transferred | 450 KB | 1,220 KB | 3,170 KB |
| Typical mobile LCP | 2.1s | 3.8s | 6.4s |
The pattern is consistent: bloated stores aren't slow because of one giant problem, they're slow because of fifteen small ones that nobody owns. The apps that crept in for a one-off campaign two years ago are still firing on every page view today.
Keep it fast: governance after launch
One optimisation sprint will get you under 3 seconds. Six months of unmanaged app installs will put you right back at 5. The fix is process, not heroics: every new app install gets a before/after Lighthouse run on PDP and checkout, every marketing pixel request goes through a tag governance review, and quarterly someone audits the app list and removes anything unused.
This is also where a lightweight analytics setup pays off. If your tracking, heatmap, and A/B testing tool ship as three separate scripts each adding 40-80KB, consolidating them into a single snippet often wins back 100-200ms on its own — and gives you cleaner data on top. It's one of the easier moves in the broader Shopify optimization playbook.
A realistic 90-day target
For a typical €5M Shopify store starting at 4.5s mobile LCP: rebuild on a 2.0 theme (-1.5s), remove 6 unused apps (-0.4s), defer non-critical tags (-0.3s), optimise the hero image (-0.4s). Landing at ~1.9s with one quarter of focused work is a normal outcome, not an exceptional one.
Frequently asked questions
No. The CDN handles delivery — TLS, edge caching, compression, image transformation — but it can't fix a theme that ships 600KB of JavaScript or 18 apps each injecting a synchronous script. Infrastructure is roughly 20% of perceived speed on Shopify; theme and app choices are the other 80%.
Under 2.5 seconds at the 75th percentile of real-user data is Google's 'good' threshold and what you should aim for. Under 3.0s is acceptable for most stores. Above 4.0s on mobile is where conversion damage becomes measurable in your weekly numbers.
Almost always, yes — if you're coming from a 2018-2020 vintage theme or a heavily customised legacy build, the gain is typically 1.5-2.5 seconds on mobile LCP. The bigger benefit is that 2.0 themes use sections everywhere, so future edits don't require dropping custom JavaScript into the head.
It's not the count, it's the script weight and load timing. A store with 30 apps that all load async and only fire on relevant pages can be faster than a store with 8 apps that all load synchronously on every page. Audit the script tags each app injects, not the app count in your admin.
No — lazy-loading the LCP element is one of the most common mistakes. Your hero image should have loading="eager" and fetchpriority="high". Lazy-load everything below the fold instead. The browser then prioritises the image that actually determines your LCP score.
Yes, often by 300-800ms on PDPs. Most review widgets inject a synchronous script that fetches reviews, ratings, and CSS before render. Look for widgets that support deferred loading or server-side rendering of the star ratings — those give you the SEO benefit without the LCP cost.
On Shopify Plus you have some control via Checkout Extensibility; on standard plans the checkout is largely Shopify-managed. Either way, the biggest checkout speed wins come from reducing third-party scripts that fire on the thank-you page and from not stuffing the order-status page with apps that delay rendering.
Yes. Core Web Vitals (LCP, INP, CLS) are a Google ranking signal, especially as a tiebreaker between sites of similar relevance. The bigger SEO effect is indirect: faster pages have lower bounce rates and higher engagement, both of which feed back into ranking over time.
Set up continuous monitoring (Shopify's Online Store Speed report plus a real-user monitoring tool), and run a full audit quarterly. The trigger-based reviews matter more: every new app install, every theme update, every marketing pixel request should include a before/after speed check on PDP and checkout.
If you're on a vintage 1.0 theme with heavy customisation, rebuilding on Dawn or a modern 2.0 theme usually pays back within a quarter via recovered conversion. If you're already on a 2.0 theme, incremental optimisation — app audit, image sizing, tag governance — is faster and lower-risk than a rebuild.
Get an AI expert review of your site
Paste your URL — Metricuno's AI runs the same heuristic checks a senior CRO consultant would, scoring your page and prioritising the fixes that'll move conversion fastest.