How to Fix Mobile LCP on Shopify Product Pages
Written by Saif Ur Rehman, Lead CRO Auditor and founder of Cartvane. Updated .
On a phone, the main product photo is usually the biggest thing on the first screen of a Shopify product page. That makes it your Largest Contentful Paint (LCP) element. When it arrives late, the shopper sees a title, a grey box and a price, and waits.
This guide shows you how to find the LCP element on your product page, which of its four timing parts is slow, which theme or app setting usually causes it, and why Shopify admin, PageSpeed Insights and Lighthouse often show three different numbers. You don't need to be a developer for the diagnosis. Some fixes are a theme setting; others are a short Liquid change for whoever maintains your theme.
For a first read before you open DevTools, the free Cartvane scan measures mobile LCP on your product page at phone width and marks the result on a screenshot of your own page. No card needed.
The short version
- Find the LCP element first. On most product pages it's the first gallery image. Sometimes it's a popup, a cookie banner or a block of text.
- Never lazy-load it.
loading="lazy"or a JavaScript lazy loader on the first gallery image delays it every time. - Give it
fetchpriority="high", and give that to one image only. - Don't fade it in. Reveal and page-transition animations hold back LCP even after the image has downloaded.
- Remove or defer render-blocking app scripts, including A/B test anti-flicker snippets left on when no test is running.
- Judge the result by field data (your Shopify web performance report or Chrome's CrUX data), not by one Lighthouse run.
Industry research vs what Cartvane checks
Two kinds of information appear in this guide. Keep them apart.
| Industry guidance | Cartvane product | |
|---|---|---|
| -- | -- | -- |
| Source | Google's web.dev and Chrome documentation, Shopify Help Center, Shopify's theme performance docs on shopify.dev | An automated walk of your public pages |
| What it tells you | Definitions, thresholds, known causes and fixes | What one lab run found on your URL |
| Type of data | Explains both field (real users) and lab (test) data | Lab data: one browser, one network, phone width 390 × 844 |
| Scope | Any website | 91 checks across your store; 7 of them are in the Speed group |
Cartvane isn't affiliated with Google or Shopify. A Cartvane speed result is a lab reading, so treat it as a lead to investigate, then confirm with your field data.
What LCP measures on a product page
LCP is the render time of the largest image, text block or video visible in the viewport, measured from when the shopper started navigating to the page (web.dev, LCP). Google's target is 2.5 seconds or less, measured at the 75th percentile of page loads and split by mobile and desktop. In practice, three out of four visits should hit it.
Shopify's admin uses the same bands for its performance summary (Shopify Help Center, web performance reports):
| Metric | Good | Moderate | Poor |
|---|---|---|---|
| -- | -- | -- | -- |
| LCP | ≤ 2,500 ms | > 2,500 ms and < 4,000 ms | > 4,000 ms |
| INP (responsiveness) | ≤ 200 ms | > 200 ms and < 500 ms | > 500 ms |
| CLS (layout shift) | ≤ 0.1 | > 0.1 and < 0.25 | ≥ 0.25 |
A few details from web.dev's definition explain behaviour that confuses store owners:
- LCP stops updating once the shopper taps, scrolls or presses a key. A popup that appears after the first scroll can't become the LCP element. One that appears on a timer before any interaction can.
- Elements with opacity 0 don't count. An image that is downloaded but still invisible behind a fade-in isn't "painted" yet.
- LCP includes everything before the page arrives, including redirects and server time. That's one reason field numbers are often worse than lab numbers.
Google "highly" recommends good Core Web Vitals "for success with Search" (Google Search Central), and Shopify's theme docs say performance "directly influences conversion rates" (shopify.dev). Neither gives a number for your store, so this guide doesn't either. A late product photo is reason enough: it's a visible problem on the page that sells.
Which number to trust
You'll likely meet three different LCP figures for the same page. They measure different people in different ways.
Shopify admin: your store's own field data
In your Shopify admin, go to Online Store. The performance summary on the Themes page shows LCP P75, INP P75 and CLS from real visits over the past 30 days, ranked Good, Moderate or Poor. For product pages specifically, go to Analytics > Reports and search the word contentful. Two reports matter here:
- Largest Contentful Paint: Page Type compares product pages with home and collection pages.
- Largest Contentful Paint: Page URL lists individual paths, so you can find the slow product templates.
The "Over Time" report adds numbered event annotations for things like app installs and theme updates, which helps you match a jump in LCP to a change. Three limits: data can be delayed by up to 36 hours, only the last 90 days are kept, and you need the Reports staff permission with private mode turned off (Shopify Help Center).
PageSpeed Insights: two tools on one page
The top of a PageSpeed Insights result, labelled Discover what your real users are experiencing, is Chrome UX Report (CrUX) field data. The bottom, Diagnose performance issues, is a single Lighthouse lab run. If a product URL doesn't have enough traffic for its own data, PageSpeed Insights shows data for your whole origin instead, and that can be very different from one product page. When Lighthouse and CrUX disagree, Google's own guidance is that CrUX "likely provides a more accurate picture", as long as you're looking at page-level CrUX data (web.dev, Optimize LCP).
Why the numbers disagree
| Source | Type | Who it measures | Window | Blind spots |
|---|---|---|---|---|
| -- | -- | -- | -- | -- |
| Shopify web performance reports | Field | Real visits to your store. Shopify's developer docs say the data "comes from Chrome users who opted into sharing performance metrics" | Up to 30 days in the summary; 90 days kept; up to 36 h delay | Browsers outside that group |
| CrUX (top of PageSpeed Insights, Search Console) | Field | Opted-in Chrome users on desktop and Android | 28-day rolling average | Chrome on iOS, Android WebViews and other Chromium browsers (such as Edge) are excluded; low-traffic pages have no data |
| Lighthouse / lab tools | Lab | One emulated device on one throttled network | One run | Real devices, real networks, warm caches, real interactions |
Sources: shopify.dev, Lab vs field data; CrUX methodology; CrUX API.
If many of your shoppers use an iPhone, note that both field sources are built from Chrome data, and CrUX leaves out Chrome on iOS. Neither number describes a Safari shopper directly. Use field data as your trend line, and also open your slowest product page on a real iPhone over mobile data. Shopify's docs add a survivorship warning: field data only counts visitors who stayed long enough to be measured.
Find your product page's LCP element in five minutes
- Pick one product page with real traffic on your main product template.
- Run it through PageSpeed Insights on the Mobile tab. Note the field LCP at the top and whether it's for "This URL" or the whole origin.
- In the lab section, filter the audits by LCP and open the Largest Contentful Paint element diagnostic. It names the element and breaks its time into parts.
- Open the page in Chrome, then DevTools > Performance. The live metrics view shows your local LCP next to CrUX field data for the page or origin when it's available. Set CPU and network throttling to resemble a mid-range phone on mobile data, enable Screenshots, and record a reload.
- Click the LCP marker in the timings track. The summary names the element, and the trace's insights show the LCP breakdown.
- Check what the element is. Main product image: carry on below. Popup, cookie banner or email capture: jump to cause 6. A heading or description: see cause 9. A transparent image or empty box that no shopper would call content: read the section on fake speed apps.
On a slow product page I start with that last step, because the fix depends on which element won. For a lab reading at phone width first, run the free scan.
The four parts of LCP, and which one is yours
Google's web.dev splits every LCP into four parts that add up to the total with no gap (web.dev, Optimize LCP):
| Part | What it is | Rough guideline share | Usual Shopify cause |
|---|---|---|---|
| -- | -- | -- | -- |
| Time to first byte (TTFB) | Until the first byte of HTML arrives | ~40% | Slow Liquid rendering, redirects, proxies |
| Resource load delay | From first byte until the image starts downloading | < 10% | Lazy-loaded first image, CSS background image, image found only by JavaScript |
| Resource load duration | Downloading the image | ~40% | Oversized image, too many files competing at once |
| Element render delay | From download finished until it's painted | < 10% | Fade-in animation, render-blocking app scripts, anti-flicker snippets, long JavaScript tasks |
The shares are guidelines, and web.dev warns against converting them into fixed milliseconds. The two parts with "delay" in their name should be close to zero.
Two lessons save wasted effort. First, compressing the image is rarely the first fix: web.dev says load duration "tends not to be a significant bottleneck for most sites". Second, fixing one part can just move the time. In web.dev's example, a smaller image that a script still hides only adds to render delay, and LCP stays the same.
Shopify's docs give a field-data shortcut (shopify.dev, Debugging with metric gaps). For one page type on one device, read TTFB, FCP (first contentful paint) and LCP at the same percentile and compare the gaps:
- Slow TTFB, then quick FCP and LCP: the server or your Liquid is the problem (cause 8).
- Fast TTFB, slow FCP: something blocks the first paint, usually render-blocking scripts or styles, or an anti-flicker snippet (cause 5).
- Fast TTFB and FCP, slow LCP: the image is found late or revealed late (causes 1 to 4 and 6).
Shopify causes and fixes, in the order I'd check them
Unless noted, each fix below comes from Shopify's Performance best practices for Shopify themes, where the first three are rated High impact on LCP.
1. The main product image is lazy-loaded
loading="lazy" on the first gallery image tells the browser to wait until layout confirms the image is on screen. JavaScript lazy loaders (Shopify names lazysizes, lozad and vanilla-lazyload) are worse: they swap src for data-src, so the browser can't see the image URL at all until the script runs (shopify.dev, Never lazy-load the LCP image).
Shopify's image_tag filter already loads images eagerly in sections 1 to 3 and lazily from section 4 on. Problems usually come from a custom or app-built gallery, or a section that sets loading: 'lazy' on everything.
What to ask your developer: make the first gallery image eager, keep loading="lazy" for images further down, and remove any JavaScript lazy loader. If the theme decides with section.index, write the lazy branch as section.index > 3. Shopify warns that section.index is nil in the theme editor, static sections and Section Rendering API responses, so a test like section.index <= 3 sends the image down the lazy branch in exactly those cases.
2. The image has no priority hint
By default the browser fetches images at low priority and only raises the priority once layout shows the image is in view. fetchpriority="high" on the LCP image removes that wait (shopify.dev). Shopify says to use it on one image per page, together with eager loading, and never with loading="lazy". web.dev adds that high priority on more than one or two images stops helping, and that carousel slides hidden at startup can be marked fetchpriority="low" so they don't compete (web.dev).
So you can keep a swipeable gallery: first slide eager and high priority, the rest normal or low.
3. A fade-in or page transition hides it
Chrome ignores elements at opacity 0, so an image that fades in after JavaScript adds a class isn't counted until it becomes visible. Shopify's docs describe an image that downloads in two seconds but reports LCP at six because the reveal fired late (shopify.dev, Don't hide the LCP image behind animations).
Check this first: in your admin, open Online Store > Themes > Customize > Theme settings and look for an Animations group with options like Animate between pages, Page transitions or reveal-on-scroll. Not every theme has them. If yours does, turn page transitions off and test again. Shopify calls page transitions the single most impactful animation-related LCP issue and the easiest to fix.
If an effect must stay, Shopify suggests excluding the first section, or using a short CSS @keyframes animation (under about 0.3 seconds) that starts on first render without waiting for a script.
4. The image is a CSS background, or a mobile/desktop pair
The browser's preload scanner finds <img> tags in the HTML early. It can't find an image referenced only in CSS until the stylesheet is parsed, so Shopify recommends <img> instead of background-image for hero and LCP content. Separate mobile and desktop images toggled with CSS should become one <picture> element, so the phone downloads only the phone image.
5. An app or test snippet blocks rendering
Many apps add <script> tags without async or defer, or add stylesheets that block the first paint. Shopify lists chat, reviews, email capture, analytics, A/B testing and recommendation apps as common types (shopify.dev, Remove render-blocking apps). For each, ask whether it's used, whether it must load on every page, and whether it can wait until after the first paint.
A/B testing tools deserve a separate look. Their anti-flicker snippet deliberately hides the page until the testing script loads. Shopify says the cost is "often over 2 seconds" on first contentful paint and tells you to disable the snippet when no test is running and close finished tests (shopify.dev).
How to find the worst scripts (shopify.dev, Finding your worst JavaScript offenders): the Lighthouse Treemap ranks files by size; the DevTools Performance panel's Bottom-Up view ranks them by scripting time; WebPageTest's Processing Breakdown ranks them by blocking time. The DevTools Coverage tab shows code that loaded but never ran.
6. A popup or cookie banner becomes the LCP element
Most popups are injected by JavaScript after the page loads. If one is larger than your product photo when it appears, it becomes the LCP element and resets the clock to its own arrival (shopify.dev, Prevent dialogs from hijacking LCP). There's no attribute that opts an element out of LCP. Shopify's fixes:
- Make the dialog smaller than the main content (a slim bar instead of a full-screen overlay).
- Show it only after the first scroll, tap or keypress. A timer alone isn't enough, because LCP is still being measured on an untouched page.
- Render it only on the templates where it makes sense. Shopify's own example skips product and cart pages.
Check on a phone: a banner smaller than the photo on desktop can be larger on a 390-pixel screen.
7. The image is far bigger than its slot
This is the resource load duration part. Shopify's image_url and image_tag filters generate srcset, add width and height, and serve from Shopify's CDN. Shopify's CDN picks a format the browser supports, such as WebP or AVIF (shopify.dev, image_url). Give image_tag realistic widths and an explicit sizes attribute for the first image, so a phone doesn't download a desktop-width file. image_url requires a width or height, accepts widths up to 5760px, and never enlarges an image beyond its original size, so a small upload stays small.
image_tag also offers preload: true, which sends a Link preload header. Shopify says to use preload sparingly, for one or two resources the browser discovers late (shopify.dev, image_tag).
8. Slow TTFB from Liquid
On a Shopify storefront, most server time is Liquid rendering. Shopify calls deeply nested loops across products, variants or options "the most common cause of high TTFB", and lists variant over-fetching and metafield lookups inside loops alongside it. A theme that's fast with 10 products can be slow with 100.
One trap: Shopify usually streams the response, so a tool's TTFB may cover only the <head>, with the rest of the Liquid time hidden in the document download. Shopify recommends the Shopify Theme Inspector for Chrome to find the slowest Liquid lines, a job for your theme developer.
9. The LCP element is text
If PageSpeed Insights names a heading or description as the LCP element, web fonts may be the delay. web.dev notes that any font-display value other than auto or block keeps text visible while the font loads. Shopify recommends self-hosting fonts on its CDN or using system fonts.
Once you know your cause, rank it against everything else on the page. The free Cartvane scan checks mobile LCP on the product page alongside the rest of the 91 checks.
Be careful with "speed apps" and speed services
Shopify has a whole guide on fake performance apps. It says Shopify removed most of them from the App Store, and that the same techniques are now sold as "speed optimization" services on freelance platforms. The tricks it describes:
- LCP hijacking: injecting a large element that paints instantly, such as a transparent full-size image, so the metric describes that element instead of your product photo. The photo loads exactly as slowly as before, and because everyone gets the injected element, field data "improves" too.
- Testing tool detection: serving a stripped page to Lighthouse and similar tools by checking the user agent or platform.
- Holding back scripts until the first scroll or tap, so lab tools never see them and real shoppers pay the cost as slow taps.
Shopify's quick test: compare PageSpeed Insights with Lighthouse run in an incognito DevTools window. A gap of 20 or more points is a warning sign. Check that the screenshots look like your page and that the LCP element is real content. Then find the frame in the DevTools filmstrip where your photo actually appears. A real fix moves that frame; a cheat moves only the number.
Verify the fix
- Lab first, same conditions as before. Re-run DevTools with the same throttling and compare the LCP part you targeted. Shopify's lab-vs-field guide advises taking the median of several runs before believing a change.
- Watch the Shopify report. Allow for the up-to-36-hour delay, and switch to weekly grouping if your traffic is low (Shopify's own tip for noisy charts). Event annotations help you pin the change date.
- Give CrUX four weeks. It's a 28-day rolling average, so a fix shows up gradually in PageSpeed Insights and Search Console.
- Watch the page itself. The product photo should visibly appear sooner on a phone.
Where speed fits in a product page audit
A fast photo with the price below the first screen still leaves the shopper scrolling; layout is covered in the product page CRO guide. Express buttons pushing Add to cart down is a layout issue too (see the guest checkout and express wallets guide), and the full journey is in the Shopify CRO audit checklist.
A lazy-loaded first image or an idle anti-flicker snippet is a bug with a known answer: ship the fix and measure. Removing something a team wants, like a popup or a gallery effect, trades one goal against another, so discuss it first.
What Cartvane checks
Cartvane's 91 checks include a Speed group of 7. The homepage lists three of them by name: Mobile LCP on the product page, Mobile LCP on home and collection, and Interaction responsiveness (INP). The other Speed checks cover the layout jumping near the buy button (CLS), app scripts slowing the page, page weight (images, blocking scripts and total size), and how quickly the cart drawer and filters respond. You can see how speed findings are reported in the sample audit, where each one is labelled "via the audit browser (lab, not field data)".
The scan loads your public pages at phone width (390 × 844) and desktop width in a lab browser, one run on one network. It can't see your Shopify report or CrUX history, so confirm anything it flags there. Speed findings sit in the same ranked list as product page, cart, checkout and trust findings, so you can see whether a slow photo is your biggest leak or a smaller one.
The free preview shows your health score, your 3 biggest leaks marked on your pages and the full fix for one of them, a quick win you can ship today, with no card. The full report is $19.99 one time, with no subscription. Paid reports come with a 14-day money-back promise. See pricing.
FAQ
What is a good LCP for a Shopify product page?
2.5 seconds or less for at least 75% of visits, on mobile and desktop separately. Shopify's admin calls that Good, 2.5 to 4 seconds Moderate, and over 4 seconds Poor.
Why is PageSpeed Insights fast but my Shopify report slow (or the other way round)?
Lighthouse is one emulated phone on one network. Your Shopify report and the CrUX part of PageSpeed Insights are real visits over weeks, including slow phones and cold caches. If only one source says LCP is poor, work out which visitors it describes before changing code.
Why does PageSpeed Insights show no field data for my product page?
CrUX includes a page only if it's publicly indexable, returns a 200 status and is "sufficiently popular". Google doesn't publish the threshold. Without page-level data, PageSpeed Insights falls back to your whole origin. Your Shopify report may still have data for that URL.
Should I remove my product image carousel?
Not for LCP reasons alone. Make the first slide eager with fetchpriority="high", keep other slides at normal or low priority, and turn off any fade-in on the first slide.
Will a speed app fix my LCP?
Real fixes live in the theme and the apps you load. Shopify warns about apps and services that game Lighthouse instead of making pages faster. Check the result against the filmstrip and your field data, not the score.
Does my theme's Theme Store score mean my store is fast?
No. To enter the Theme Store, a theme needs an average Lighthouse score of at least 60 across home, product and collection pages on a benchmark store (shopify.dev). Your photos, apps and catalog differ, so measure your own product pages.
About the author
Saif Ur Rehman is the founder and Lead CRO Auditor of Cartvane, based in Lahore, Pakistan, with 5+ years focused on Shopify conversion rate optimization and 110+ Shopify CRO projects. On a slow product page, the first thing he checks is which element won LCP, because that decides the fix. More on the About page.
Related: Shopify CRO audit checklist (91 checks) · Shopify product page CRO · Guest checkout and express wallets · Sample report · Pricing · Free scan
Sources
Google (web.dev, Chrome, Search Central)
- Largest Contentful Paint (definition, 2.5 s at p75, element types, opacity 0 / full-viewport / low-entropy exclusions, stops on interaction, field and lab tools; updated Sep 4, 2025): https://web.dev/articles/lcp
- Optimize Largest Contentful Paint (PSI field vs lab, origin fallback, CrUX more accurate, DevTools live metrics, four subparts and guideline shares, never lazy-load, fetchpriority high/low, load duration rarely the bottleneck, font-display; updated Mar 31, 2025): https://web.dev/articles/optimize-lcp
- CrUX methodology (eligibility, sufficiently popular, Chrome on iOS / WebView / other Chromium excluded): https://developer.chrome.com/docs/crux/methodology
- CrUX API (28-day rolling average, LCP subpart metrics): https://developer.chrome.com/docs/crux/api
- Understanding Core Web Vitals and Google search results: https://developers.google.com/search/docs/appearance/core-web-vitals
Shopify Help Center
- Web performance reports (30-day summary, bands, Page Type / Page URL reports, event annotations, 36 h delay, 90 days, permissions, weekly grouping tip): https://help.shopify.com/en/manual/online-store/web-performance/web-performance-reports
Shopify developer docs (shopify.dev)
- Performance best practices for Shopify themes (impact tables, Liquid TTFB and streaming, Theme Inspector, Theme Store score ≥ 60): https://shopify.dev/docs/storefronts/themes/best-practices/performance
- Lab vs field data (Web Performance Dashboard data source, CrUX window, disagreement causes, median of runs): https://shopify.dev/docs/storefronts/themes/best-practices/performance/lab-vs-field
- Debugging with metric gaps: https://shopify.dev/docs/storefronts/themes/best-practices/performance/performance-gaps
- Never lazy-load the LCP image: https://shopify.dev/docs/storefronts/themes/best-practices/performance/never-lazy-load-lcp-image
- Mark the LCP image with fetchpriority="high": https://shopify.dev/docs/storefronts/themes/best-practices/performance/set-fetchpriority-high-on-lcp-image
- Don't hide the LCP image behind animations: https://shopify.dev/docs/storefronts/themes/best-practices/performance/dont-hide-lcp-image-behind-animations
- Prevent dialogs from hijacking LCP: https://shopify.dev/docs/storefronts/themes/best-practices/performance/prevent-popups-hijacking-lcp
- Remove render-blocking apps: https://shopify.dev/docs/storefronts/themes/best-practices/performance/remove-render-blocking-apps
- Remove A/B test anti-flicker snippets when no tests are running: https://shopify.dev/docs/storefronts/themes/best-practices/performance/disable-ab-testing-when-inactive
- Finding your worst JavaScript offenders: https://shopify.dev/docs/storefronts/themes/best-practices/performance/finding-worst-offenders
- Identify and remove fake performance apps: https://shopify.dev/docs/storefronts/themes/best-practices/performance/fake-performance-apps
- image_tag filter (automatic lazy loading further down the page, preload Link header, use sparingly): https://shopify.dev/docs/api/liquid/filters/image_tag
- image_url filter (width or height required, 5760px max, no enlarging, automatic WebP/AVIF selection): https://shopify.dev/docs/api/liquid/filters/image_url
Cartvane
- Homepage check list (Speed group: Mobile LCP on the product page, Mobile LCP on home and collection, INP): https://www.cartvane.com
- Sample report (Speed findings, "lab, not field data", 390 × 844): https://www.cartvane.com/sample
- Pricing: https://www.cartvane.com/pricing
Get your free Shopify CRO audit
Paste your store URL and see your biggest conversion leaks in minutes. 91 checks, no card required.