Shopify performance optimization means improving the three Core Web Vitals your store is measured on — LCP, INP and CLS at the 75th percentile — by removing what you control: heavy apps, unoptimised theme code, oversized media and third-party scripts. Shopify already handles hosting, CDN delivery, image optimisation, compression and caching, so most generic "speed up your site" advice does not apply. Shopify itself names the theme, installed apps and third-party code as the biggest factors it can influence (Shopify Help Center, retrieved 25 September 2026).
This is a technical checklist, in the order a developer should work through it.
Key Takeaways
• The targets are LCP within 2.5 seconds, INP within 200 milliseconds, and CLS within 0.1, measured at the 75th percentile of page loads (web.dev, last updated 31 October 2024, retrieved 25 September 2026).
• Shopify already runs a Cloudflare CDN, serves assets over HTTP/2, sets one-year browser caching, gzips CSS/JS/documents, minifies files, and optimises images — often serving WebP. Do not pay a developer to re-do this.
• The controllable causes are your theme, your apps, and any third-party or tag-manager code you added.
• Poor INP is often associated with excessive JavaScript or expensive main-thread work. Shopify recommends finding the actual offenders and removing or deferring them.
• Use Shopify's Web Performance reports for field truth, PageSpeed Insights for lab diagnosis, and remember that lab tools cannot measure INP at all — Total Blocking Time is the lab proxy.
• Performance is a maintenance discipline, not a one-off fix. Every new app is a performance decision.
The three metrics you are actually judged on
Metric — What it measures — "Good" threshold — Usual Shopify cause
• **LCP — Largest Contentful Paint** — How fast the main content appears — Within 2.5 s — Unsized hero image, video or carousel above the fold, render-blocking third-party code
• **INP — Interaction to Next Paint** — How quickly the page responds to taps and clicks — 200 ms or less — Excess main-thread JavaScript from apps, theme code, chat widgets, tag managers
• **CLS — Cumulative Layout Shift** — How much content jumps around while loading — 0.1 or less — App banners and widgets injected late, images without reserved space, font swaps, cookie notices
Google recommends measuring at the 75th percentile so that the assessment reflects the experience of at least 75% of visits, with mobile and desktop evaluated separately. A page passes when each device segment meets the good threshold for all three metrics at the 75th percentile (web.dev).
Two practical implications:
• Prioritise the device mix in your own data. For Indian stores, review mobile and desktop separately; mobile deserves particular attention when it represents most sessions. Do not accept a desktop-only result.
• Lab and field data are different instruments. PageSpeed Insights and Lighthouse run in a simulated environment; CrUX and Shopify's reports reflect real users on real connections. Use lab tools to diagnose a cause, and field data to decide whether the fix worked. Lighthouse cannot measure INP at all because there is no real user input — it reports Total Blocking Time as a proxy instead.
What Shopify already handles — do not pay for this
Shopify's own documentation states that these optimisations are built in and require no action:
• Global hosting and CDN. Your store runs on Shopify's infrastructure behind a Cloudflare CDN, with no bandwidth cap, serving assets over HTTP/2.
• Browser caching. Cacheable resources are set to cache for one year, the maximum possible duration, so repeat visitors load faster.
• Compression. CSS, JavaScript, documents and pages are gzipped, with keep-alive enabled.
• Image optimisation. The image CDN serves resized, compressed images in the best available format; JPGs are often delivered as WebP.
• File minification. CSS and JavaScript are minified when served to the storefront.
So the standard third-party audit recommendations to "add a CDN", "enable compression", "set up server-level caching headers" or "configure a fast host" do not apply to a Shopify store. If an agency quotes for those, that is a red flag about the rest of their audit.
The four things that actually slow a Shopify store
Shopify lists the theme, installed apps and third-party code as the biggest factors. Everything below is a variation of those three, plus media.
1. Apps and app scripts
Apps that inject storefront code can add JavaScript and network work. Some scripts may delay loading or interaction, while others have little measurable effect. Reviews widgets, loyalty pop-ups, subscription upsells, bundles, chat launchers, currency converters and back-in-stock tools are common candidates to audit.
App weight is a conversion question as well as a speed question — the same scripts that delay interaction are the ones shoppers feel when they try to add to cart. Our guide to Shopify conversion rate optimization covers where that friction shows up in the funnel.
The test is not "how many apps" but "does this app earn its weight". Shopify's own framing is to evaluate installed apps and third-party code to confirm they create enough value to offset their performance cost. Concretely:
• Uninstall what is not used, not just what is disliked. Shopify warns that uninstalling an app does not automatically remove its code from the theme, so removal may require the app developer.
• Defer anything that is not needed on first paint — chat bubbles, review scripts, upsell logic.
• Prefer an app that loads conditionally on the pages where it matters, rather than sitewide.
2. Theme and custom Liquid code
Custom code is the part of a Shopify store you fully own, and therefore the part that drifts. Over a year of small requests — a slider, a sticky bar, a custom font, a bundle widget — a theme accumulates scripts nobody remembers adding.
Shopify's specific recommendations:
• Use an up-to-date, optimised theme. The Horizon family and Online Store 2.0 themes from Shopify are free and built for performance, and many third-party themes are also well optimised. Shopify publishes theme performance data so you can compare before switching.
• Compare performance before and after enabling page transitions or other animations. Animations cost main-thread time.
• Keep the number of sections on a page template under control. High section counts lower performance.
• Turn on pagination for collections with large product counts, so the page does not load the entire catalogue at once.
• Audit custom Liquid, app blocks and section snippets for synchronous scripts, un-deferred jQuery patterns, and duplicated library loads.
If the theme is the root cause and a rebuild is on the table, weigh it against staying put: our comparison of Shopify versus a custom ecommerce website covers when a rebuild is actually justified.
3. Images, video and carousels
Shopify's image CDN generates resized, compressed variants for the sizes requested by the theme, so an oversized original does not automatically force a 4000-pixel asset into every browser. It can still be inefficient when rendered at a large size, and incorrect theme image settings can request more pixels than the display needs. A heavy animated hero must also justify the loading work it causes, as discussed in how a website can turn visitors into store customers.
• Upload images at a size close to their largest display size, and let Shopify generate the responsive variants.
• Do not place an autoplaying background video above the fold unless it demonstrably earns its place. It directly competes with LCP.
• Carousels and sliders ship JavaScript and often cause layout shift. Shopify lists carousels among the features that can slow a store.
• Lazy-load below-the-fold media, but never lazy-load the LCP image.
• Audit social media feeds, review widgets and third-party embeds — each is a network request and a script you do not control.
4. Tag managers, pixels and third-party code
Tag managers, analytics and advertising pixels, heatmaps, session recording and chat tools can create network and main-thread contention that contributes to poor INP. Shopify recommends auditing the tag manager and removing unused or low-value tags; the Chrome team's tag and tag manager best practices explains the performance trade-offs.
• Inventory every tag, then delete what nobody looks at.
• Load non-essential tags only after consent and after the page is interactive.
• Check whether the same library is being loaded twice through two different paths — a common and easily fixed duplication.
• Confirm that your analytics fires once per event, not twice, after a migration. Duplicate event scripts are a classic post-migration regression.
The technical checklist
Work top to bottom. Each item is verifiable.
A. Measure first
Shopify's Web Performance reports and measurement overview document the requirements and browser coverage described below.
• [ ] Turn off the store password page. Shopify's web performance reports need real user traffic; a password-protected store will not generate Core Web Vitals data.
• [ ] Open Shopify's Web Performance reports and record LCP, INP and CLS for the last 7 days, separated by mobile and desktop.
• [ ] Note which pages the score covers: Shopify's summary combines your home page, your most visited product page and your most visited collection page.
• [ ] Read the comparison against stores of similar sales volume, which Shopify provides as a benchmark.
• [ ] Run PageSpeed Insights on the same three page types for lab diagnosis.
• [ ] If you have no traffic yet, use PageSpeed Insights with synthetic data and re-measure once traffic exists.
Performance work is part of a build budget, not an afterthought. The wider planning bands for storefront work in India are in ecommerce website development cost in India.
B. Reduce JavaScript (fixes INP)
• [ ] List every app, and record what each one contributes to the storefront.
• [ ] Uninstall unused apps and confirm their code is actually removed.
• [ ] Defer or conditionally load chat, reviews, upsell and loyalty scripts.
• [ ] Review custom Liquid for synchronous or duplicated scripts.
• [ ] Clean the tag manager: remove unused tags, and gate non-essential ones behind consent and load events.
• [ ] Re-measure INP after each significant change, not at the end of the project.
C. Fix loading (fixes LCP)
• [ ] Identify the LCP element on home, top product and top collection pages.
• [ ] If it is an image, ensure it is appropriately sized and not lazy-loaded.
• [ ] If it is text, remove render-blocking third-party code from above the fold.
• [ ] If it is a video or carousel, test removing it and compare scores.
• [ ] Serve the hero asset at the size it is displayed, not at camera resolution.
D. Stabilise the layout (fixes CLS)
• [ ] Reserve space for app banners, cookie notices and announcement bars so they do not push content down after load.
• [ ] Ensure images and embeds have defined dimensions.
• [ ] Self-host or preload fonts, or use a font strategy that does not reflow the page mid-load.
• [ ] Check that late-loading widgets — chat bubbles, back-in-stock forms, coupon bars — do not shift the page.
E. Keep it fixed
• [ ] Add a performance check to your app-installation process: every new app is approved against a Core Web Vitals baseline.
• [ ] Check the reports after major theme changes, large catalogue imports, new collections, and sale campaigns. Shopify notes that scores can move after exactly these events.
• [ ] Re-check quarterly rather than daily. Shopify advises that with low traffic, weekly or monthly filters give a more stable read than daily fluctuations.
India-specific considerations
These are practical planning considerations for Indian merchants, not published benchmarks. Validate them against your own reports.
• Review the mobile report first when mobile dominates your own traffic. Segment results by device, assess the 75th percentile, and also test representative mid-range handsets on mobile data to understand slower-user behaviour.
• Budget for campaign spikes. Sale events and festivals produce short, sharp traffic surges. Load-test your checkout and key templates before the window, and pre-clear the app list so nothing is added mid-campaign.
• Count app weight against margin. Give every operational or marketing app an explicit performance budget and remove it when its commercial or operational benefit cannot be demonstrated.
• Treat chat and WhatsApp widgets as scripts, not features. Test their network use, JavaScript and layout cost before allowing a sitewide launch.
• Watch image weight in lifestyle catalogues. Apparel and jewellery catalogues with high-resolution images and zoom galleries are where oversized originals surface first.
• Test on a real mid-range handset, on mobile data, not office Wi-Fi. Performance problems are invisible on a fast connection and a fast laptop.
Frequently asked questions
Why do I have no Core Web Vitals scores on my Shopify store?
Shopify's documentation gives two common reasons: the online store is still in private/password mode, so there is no real user traffic, or the store has not had enough page views to generate real-user metrics. In the second case, use PageSpeed Insights with synthetic data until field data exists.
Why do Shopify's web performance reports differ from PageSpeed Insights?
Shopify's reports use real-user data gathered across Chromium browsers and Firefox, while tools such as PageSpeed Insights rely on the CrUX report, which covers opted-in Chrome users only. Timezone handling and data-sampling differences also contribute. Neither is wrong; they answer different questions.
Do I need a faster hosting plan for Shopify?
Usually not. Hosting, CDN and caching are part of the platform, so a higher plan will not normally resolve storefront code, oversized media or inefficient apps. Diagnose the bottleneck before changing plans.
Does uninstalling an app immediately fix the slowdown?
Not always. Shopify notes that uninstalling an app does not automatically remove its code from the theme, and you may need the app developer to complete the removal. Verify in the browser that the script is actually gone.
How much will performance work improve conversion?
Performance is a conversion input, not a guaranteed outcome. Shopify links better web performance to improved shopping experience, conversion and discoverability, and Google includes Core Web Vitals in its page-experience guidance, but meeting a threshold does not promise a ranking, conversion or revenue increase. Measure the change against your own baseline.
Fix the code you own, then keep watching it
Shopify performance optimization is mostly triage: measure field data on mobile, find the heaviest app and the worst custom script, remove or defer them, then re-measure. Everything else the platform already does for you.
Ready to have your store profiled? Talk to GrowMyStore about Shopify builds and performance work, or share your store URL and the pages that feel slowest for a project-specific scope.