Shopify Core Web Vitals: Fix LCP and INP on Your Store

A practitioner's audit for Shopify Core Web Vitals that traces poor LCP and INP back to theme bloat, app scripts, image handling and slow Liquid, then fixes each one in order.

Shopify Core Web Vitals: Fix LCP and INP on Your Store

A Shopify theme can pass the Theme Store’s performance bar and still fail Core Web Vitals on your store. To get in, Shopify requires a minimum average Lighthouse score of 60 across the home, product and collection pages. That test runs on a benchmark store. It does not include your catalog, your fourteen apps or the hero video your brand team asked for.

Fixing Core Web Vitals on a Shopify store means auditing the store you actually run, not the theme you bought.

Get a template-by-template Shopify performance audit that traces poor LCP and INP to specific code.

Audit my Shopify store

Start with field data, not a Lighthouse score

Lighthouse runs a single simulated page load. Google ranks on field data from real Chrome users, and the two often disagree. That gap matters most for Interaction to Next Paint (INP), because a lab page load usually involves no clicks.

Google’s thresholds are measured at the 75th percentile of page loads, where an INP at or below 200 milliseconds is good and anything above 500 milliseconds is poor. INP only counts clicks, taps and key presses. Hovering and scrolling do not count. Lab tools that never interact with the page report Total Blocking Time as a stand-in, and that is a rough proxy, not the real number.

So begin with Search Console’s Core Web Vitals report, CrUX data or the web performance report in the Shopify admin. Then split the data by template. A store-wide average hides the fact that the product page fails and the home page passes, and those two templates have different causes. If you need a refresher on what each metric captures, see our breakdown of LCP, INP and CLS.

One diagnostic rule saves a lot of time. Shopify’s own guidance says that if the server response is slow, look at Liquid. If it is fast, look at the browser-side work that follows. Every fix below falls on one side of that line.

The audit sequence

Run this in order. Each step narrows the search for the next one.

1

Segment field data by template:

Pull LCP and INP for the home, collection, product and cart templates separately, on mobile first. Ignore desktop until mobile passes.

2

Identify the LCP element per template:

Use the Performance panel in Chrome DevTools to confirm what the browser treats as the largest element. It is often not what the design team expects.

3

Split LCP into server time and browser time:

Compare time to first byte and document download time against the LCP timestamp. A large server share points to Liquid. A large browser share points to images, CSS or scripts.

4

Profile Liquid rendering:

Run the Shopify Theme Inspector for Chrome on your slowest template and rank the Liquid files and lines by render cost.

5

Inventory every script by origin:

List each script, which app or tag manager loads it, and whether it blocks parsing. Flag anything left behind by apps you have already uninstalled.

6

Profile the money interactions:

Record a performance trace while selecting a variant, adding to cart, opening the cart drawer and applying a collection filter. These are the interactions that set your INP.

7

Fix, deploy, then wait for field data:

Field data updates on a rolling window, so judge each change on real-user data, not on the next Lighthouse run.

Where theme bloat actually comes from

Premium themes compete on features. Every mega menu, quick-view modal, predictive search panel and announcement carousel ships in the theme whether a merchant turns it on or not, and much of it renders into the DOM on every page load.

Shopify’s documentation names the worst patterns directly. A large DOM makes every style recalculation slower. That cost shows up in INP when a shopper taps something and the browser has to restyle the whole page before it can paint the response.

Stylesheets are the quieter problem. Each extra stylesheet link triggers its own style recalculation, so a theme that loads one CSS file per section pays that cost many times over. The fix is to merge them, and to make sure each file’s classes are only used inside the sections that render it, so Shopify’s automatic stylesheet subsetting can do its job.

App script overhead: the cost nobody budgeted for

Apps are where most Shopify performance budgets fall apart. Each one gets installed by a different team, for a sensible reason, and nobody owns the total.

App code reaches the storefront in a few ways: app embed blocks, app blocks inside sections, scripts injected through content_for_header, and, on older installs, snippets pasted straight into theme.liquid. That last route is the dangerous one. Uninstalling the app does not always remove the snippet. Many established stores are still loading JavaScript for review widgets and popup tools they stopped paying for years ago.

An app’s cost is not its file size. It is the main-thread time its code takes on the interactions that make you money, and that only shows up when you profile add-to-cart with every app enabled.

Two patterns cause most of the damage. The first is render-blocking app scripts in the head, which delay LCP before any content paints. The second is apps that attach their own handlers to your add-to-cart button: upsell modals, cart analytics, free-shipping bars. When a shopper taps the button, every one of those handlers runs before the browser can paint the response. That is a textbook INP failure, and no single app looks guilty on its own.

Look out for A/B testing anti-flicker snippets as well. They hide the page until the test script decides which variant to show, which directly delays LCP. Shopify’s guidance is to disable them whenever no test is running. For a governance model that stops this from coming back, our piece on third-party script budgets covers the process side.

Image handling: your LCP is probably a product photo

On most Shopify templates the LCP element is an image: the hero banner on the home page, the first product photo on a product page. The mistakes that slow it down are predictable.

  • Lazy-loading the LCP image. Themes often apply loading=”lazy” to every image through a shared snippet. On the first image in the viewport, this delays the request until after layout.
  • No fetch priority. Adding fetchpriority=”high” to the LCP image tells the browser to request it ahead of competing resources.
  • CSS background images for heroes. The browser’s preload scanner cannot discover them, so the request starts late. Use a real img element.
  • Fade-in animations. A reveal transition delays the LCP event even after the image has fully downloaded.
  • Two hero images toggled by CSS. Separate mobile and desktop images hidden with media queries can mean both get downloaded. A picture element downloads only the one that matches.
  • Popups that become the LCP. A newsletter dialog larger than the hero can take over as the LCP element.

The practical fix in Liquid is to use the section.index object. Pass loading eager and fetchpriority high to the image_tag filter when the section is first on the page, and lazy otherwise. The image_tag and image_url filters already generate srcset, width and height, and CDN URLs, so hand-built image URLs should be treated as a defect. For heavier galleries, our LCP subpart audit shows how to work out which phase of the image load is the slow one.

Liquid rendering patterns that inflate server time

Liquid runs on Shopify’s servers on every uncached request, and no browser-side optimization can win that time back. On streamed responses this is easy to miss. Shopify sends the top of the head first, so your TTFB looks healthy while the real Liquid cost hides in the document download time.

The patterns that hurt most grow with catalog size, which is why a theme that flew in the demo crawls in production:

  • Nested loops across products, variants and options, which grow quadratically.
  • Metafield access inside loops, especially variant-level checks on collection grids.
  • Iterating every variant when the initial render needs only the selected one.
  • Deeply nested render calls inside loops, each adding overhead.
  • Unguarded drawer and dialog content that renders in full on every page even though most shoppers never open it.

The Theme Inspector will show you which of these you have. One structural fix is worth doing regardless: put base stylesheets, font preloads and the import map above content_for_header. The browser then fetches them while Shopify is still rendering your sections.

Fixing INP on the interactions that matter

INP is reported from a page’s worst interactions, and on a store those are almost always variant selection, add-to-cart, filtering and opening the cart. Fix those four and you have fixed most of the metric.

The mechanism is always the same: too much work on the main thread between the tap and the next paint. The remedies follow from that. Load component JavaScript with a dynamic import inside the event listener, so the code arrives when someone uses the component and not at page load. Break long handlers up and yield to the main thread, so the visual response (a spinner, an updated price) paints before the analytics and upsell logic runs. Use the Section Rendering API to swap one section on a variant change, not to re-render the page. Debounce price-range sliders and search inputs.

A shopper does not need the cart total recalculated before the button shows it was pressed. Paint the acknowledgement first, then do the work.

Headless storefronts built on Hydrogen run into the same problems in a different form, and our guide to INP in single-page applications covers that architecture.

Your next step: pull mobile field data for your product template, record one trace of an add-to-cart tap with every app enabled, and list every function that runs before the next paint. That list is your fix order.

Frequently asked questions

Why does my Shopify store fail Core Web Vitals when my theme scores well in Lighthouse?

Lighthouse tests one simulated page load, usually without your apps, catalog size or real user interactions. Google assesses Core Web Vitals on field data from real Chrome users at the 75th percentile, so app scripts, large collections and slow interactions show up there and not in the lab score.

What usually causes poor LCP on Shopify product pages?

The most common causes are a lazy-loaded first product image, missing fetchpriority on that image, render-blocking app scripts in the head, fade-in animations on the gallery, and slow Liquid rendering from loops over variants or metafields.

How do I find which Shopify apps are slowing down my store?

List every script on the page by origin in Chrome DevTools, then record a performance trace of key interactions such as add-to-cart. Check theme.liquid and the snippets folder for code left behind by uninstalled apps, because removing an app does not always remove its code.

Can I fix INP on Shopify without rebuilding my theme?

Often, yes. Removing unused app scripts, deferring non-critical JavaScript, loading component code on interaction, yielding inside event handlers and building drawer and filter markup only when opened can all be done within an existing theme.

How long does it take to see Core Web Vitals improvements after a fix?

Lab tools show changes immediately, but the field data Google uses is collected over a rolling window of real visits. Expect several weeks before Search Console fully reflects a fix, so validate each change against real-user data before moving on.

Find out what is slowing your Shopify store

You now know where Shopify LCP and INP problems come from: theme bloat, app scripts, image loading and slow Liquid. Moburst Digital Experience can trace each failing template to the specific code behind it and hand you a prioritized fix list your team can ship.

Talk to a performance engineer