The Uncomfortable Truth About Shopify Performance
Let me start with a number that hurts: Pages that load in 1 second achieve conversion rates that are 3x higher than pages that take 5 seconds. Specifically: a 1-second page converts at 9.6%, a 5-second page at just 3.3% -- a difference of 191%.
Or put another way: if your store takes 3 seconds instead of 1 second to load, you are potentially losing 20% of your conversions. On 10,000 EUR in monthly revenue, that is 2,000 EUR -- every month. Not because of bad products, bad marketing, or bad design. Just because of load time.
Shopify claims that 93% of stores on their platform are "fast" -- faster than on any other commerce platform. That is true in comparison. Shopify's servers are on average 2.8x faster than the competition. But server speed is only part of the equation. What makes your store slow usually happens in the frontend -- and that is where you have control.
How Fast Is "Fast Enough"?
Google Core Web Vitals (2025)
Google measures your page's performance using three metrics:
Largest Contentful Paint (LCP) -- How quickly does the main content become visible?
- Good: under 2.5 seconds
- Needs improvement: 2.5-4 seconds
- Poor: over 4 seconds
Interaction to Next Paint (INP) -- How quickly does the page respond to clicks?
- Good: under 200 milliseconds
- Needs improvement: 200-500ms
- Poor: over 500ms
(INP replaced FID as a metric in March 2024 -- many guides are still outdated on this.)
Cumulative Layout Shift (CLS) -- How stable does the layout remain?
- Good: under 0.1
- Needs improvement: 0.1-0.25
- Poor: over 0.25
What the Average Shopify Store Achieves
The reality: the average Shopify store has a PageSpeed score of 50-70 (out of 100). LCP typically sits at 2.5-4 seconds, INP at 200-500ms, CLS at 0.1-0.25. That is "needs improvement" -- not bad, but not good either.
Google recommends a load time of under 2 seconds for e-commerce pages. Users lose patience at exactly 2.75 seconds -- beyond that point, bounce rates increase dramatically.
The SEO Effect
Core Web Vitals are an official Google ranking factor. They account for roughly 10-15% of ranking signals. For competing search results, good Core Web Vitals can deliver 8-15% higher visibility.
That sounds like a small number? For a store that gets 40% of its traffic through organic search, that is the difference between page 1 and page 2.
The Biggest Performance Killer: Apps
Here is the number most Shopify merchants do not know: 62% of all third-party integrations hurt store performance. Not some. The majority.
How Apps Slow Down Your Store
Every app you install adds code to your theme:
- JavaScript files: Each app loads its own scripts. With 10 apps, that can be 10-20 additional HTTP requests.
- CSS files: Styling code that is loaded even on pages where the app is not active.
- External API calls: Many apps fetch data from external servers -- additional latency.
- DOM manipulation: Apps that insert or modify elements in the store can cause layout shifts.
The Hidden Danger: Zombie Code
The worst part: when you uninstall an app, its code often remains in the theme. So-called "zombie code" -- it no longer does anything, but it gets loaded with every page view.
In our experience, a typical Shopify store that has grown over 2 years has 3-5 uninstalled apps whose code is still embedded in the theme. That can easily cause 500ms to 1 second of additional load time.
The App Audit Method
Here is how to find out which apps are slowing down your store:
- Measure baseline: Note the PageSpeed Insights score of your homepage
- Disable apps individually: Deactivate each app one at a time and re-measure
- Calculate delta: Which app causes which performance loss?
- Evaluate cost-benefit: Does the app deliver enough value to justify the performance hit?
- Search for zombie code: Look in the theme code for references to uninstalled apps
Each additional app can add 200-500 milliseconds to load time. For a single app, that is barely noticeable. With 10 apps, it adds up to 2-5 seconds -- and that is the difference between a fast and a slow store.
Images: The Second Biggest Lever
Images typically account for 60-80% of the data volume on an e-commerce page. This is where the biggest optimization opportunities lie.
WebP and AVIF: The Modern Formats
WebP is supported by 96.5% of all browsers and delivers files that are on average 30% smaller than JPEG. 68% of the top 10,000 websites already use WebP.
AVIF is even more efficient: 50% smaller than JPEG, 20% smaller than WebP. Browser support is at 85-94% -- good enough for most stores, as long as you provide JPEG as a fallback.
The Optimal Image Strategy
For product images: AVIF as the primary format (best quality at smallest file size), WebP as fallback, JPEG as last resort.
For hero images: Use preloading (more on that below). The hero image is almost always the LCP element -- it determines when Google considers your page "loaded."
For decorative images: CSS gradients or SVGs instead of raster images. An animated CSS gradient is 0 KB. A decorative background image is 200 KB.
Lazy Loading Done Right
Images below the visible area (below the fold) should only be loaded when the user scrolls to them. Shopify supports this natively through the loading="lazy" attribute. However, there is a critical rule: never lazy-load images that are above the fold. Your hero image, product images in the first viewport, and your logo should all load immediately. Lazy loading these elements will actually hurt your LCP score because the browser defers loading the content users see first.
For images that do appear below the fold -- product galleries, related product sections, blog thumbnails -- lazy loading can significantly reduce initial page weight. A typical product page with 15-20 images can save 2-4 MB of initial data transfer by lazy loading everything below the first scroll.
Preloading Critical Resources
For your most important above-the-fold image (usually the hero or main product image), go one step further than just not lazy-loading it -- actively preload it:
<link rel="preload" as="image" href="hero-image.webp" type="image/webp">
This tells the browser to start downloading the image as early as possible, even before it encounters the <img> tag in the HTML. For LCP, this can shave off 200-500ms because the browser does not have to wait until it parses the full page to begin the download.
Image Sizing and Responsive Images
Another common mistake: serving the same 2000px-wide image to both desktop and mobile users. A smartphone on a 4G connection does not need a 2 MB hero image. Use Shopify's built-in image transformation API to serve appropriately sized images:
- Mobile: 750px wide is sufficient for most layouts
- Tablet: 1200px covers retina displays
- Desktop: 1600-2000px for full-width hero images
The difference is substantial. A 2000px JPEG at 300 KB becomes a 750px WebP at 45 KB -- that is an 85% reduction in file size for mobile users, who make up 78% of your traffic.
What to Do Next
Optimizing your Shopify store's performance is not a one-time task. It is an ongoing process that should be part of your regular store maintenance. Here is a practical sequence to follow:
- Run a PageSpeed audit on your homepage, your highest-traffic product page, and your collection pages. Note the scores and Core Web Vitals values.
- Perform an app audit using the method described above. Remove or replace apps that cause disproportionate performance loss.
- Clean up zombie code from previously uninstalled apps. Search your theme files for script tags and references that point to services you no longer use.
- Optimize your images -- convert to WebP/AVIF, implement proper lazy loading, and add preloading for above-the-fold images.
- Measure again and compare against your baseline. Track your Core Web Vitals monthly to catch regressions early.
Every 100 milliseconds you shave off your load time translates directly into better conversion rates, lower bounce rates, and higher search rankings. In e-commerce, speed is not a technical nicety -- it is revenue.