All articles
E-commerceNovember 17, 2026 6 min read

Why Your Shopify LCP Is Stuck at 3.2s (And the Six Fixes That Actually Moved It)

A field report on dragging Shopify product page LCP from the mid-3s into the low-2s. The usual advice doesn't cut it — here's what actually worked across three merchants in 2025.

Every few months a merchant pings us with the same complaint: "PageSpeed says we're a 72 on mobile, LCP is 3.2 seconds, and nothing we do seems to move it." They've installed a speed app, compressed the images, maybe swapped themes. The needle barely twitches. Here's what we've learned pulling three Shopify stores from the mid-3s into the low-2s range this year.

The LCP element on Shopify PDPs is almost never what you think

Before touching anything, open Chrome DevTools → Performance Insights → run a mobile trace. Look at the LCP candidate. On a Shopify product page, the winner is usually one of three things:

  • The hero product image
  • A large H1 or price block rendered after a web font swap
  • A video poster frame on themes that autoplay product video

What surprises people is how often it's the second image in a carousel, not the first — because the theme preloads both and the second finishes painting last inside the LCP viewport. Or it's a text node whose font file is 180KB and blocks paint until it arrives.

If you skip this step and start "optimizing," you'll spend a week compressing images while the real culprit is a font-display: block directive buried in a vendor stylesheet.

Quick diagnostic script

Drop this in the console on a production PDP to see what the browser actually picked:

new PerformanceObserver((list) => {
  const entries = list.getEntries();
  const lcp = entries[entries.length - 1];
  console.log('LCP element:', lcp.element);
  console.log('LCP time:', lcp.startTime);
  console.log('LCP URL:', lcp.url || '(text node)');
}).observe({ type: 'largest-contentful-paint', buffered: true });

Run it, hard refresh, and you've got ground truth in ten seconds.

Fix 1: Preload the right image, not all of them

Most Dawn-based themes either preload nothing or preload the first image in every featured collection. Neither is correct. You want exactly one preload on a PDP: the primary product image, at the responsive size the browser will actually use.

{%- if product.featured_media.preview_image -%}
  <link
    rel="preload"
    as="image"
    href="{{ product.featured_media.preview_image | image_url: width: 800 }}"
    imagesrcset="{{ product.featured_media.preview_image | image_url: width: 400 }} 400w,
                 {{ product.featured_media.preview_image | image_url: width: 800 }} 800w,
                 {{ product.featured_media.preview_image | image_url: width: 1200 }} 1200w"
    imagesizes="(max-width: 749px) 100vw, 50vw"
    fetchpriority="high"
  >
{%- endif -%}

The imagesrcset + imagesizes combo is critical. Without them, the browser preloads a size that doesn't match the actual rendered element and ignores the hint entirely. We've seen this miss on every Shopify theme audit we've done in the last twelve months.

Fix 2: Stop treating Shopify's CDN as infinitely fast

Shopify's image CDN is good, but it's not magic. On mobile networks in Brazil, India, or Nigeria, a 180KB hero image still takes 700ms over 4G. Two things we do on every project:

  • Force WebP via image_url: width: 800, format: 'webp' — the auto-negotiation works, but being explicit shaves a redirect on some edge nodes.
  • Cap the hero at 800px wide on mobile. Nobody needs a 1600px image on a 390px viewport. Themes that render src="...width=1500" by default are leaving two seconds on the table.

One merchant we worked with had a 340KB hero because the theme pulled master resolution for "retina quality." Dropping to width 800 at quality 80 cut it to 62KB. LCP moved from 3.1s to 2.4s on a mid-range Android.

Fix 3: The app audit nobody wants to do

We've written about app bloat before, but specifically for LCP there's a pattern: review apps, upsell apps, and personalization apps inject synchronous scripts into the <head> that block the parser before your LCP image can even be requested.

Run this in the console:

performance.getEntriesByType('resource')
  .filter(r => r.initiatorType === 'script' && r.startTime < 2000)
  .sort((a, b) => b.duration - a.duration)
  .slice(0, 10)
  .forEach(r => console.log(r.duration.toFixed(0) + 'ms', r.name));

If you see a review widget or a "frequently bought together" script in the top five, that's your bottleneck. Most of these apps support async loading or can be deferred until after load. The vendor docs rarely mention this — you have to ask support directly or move the script tag yourself through theme edits.

What we deprioritize on PDPs

  • Chat widgets: load on first user interaction, not on page load
  • Review stars: show a static placeholder, hydrate after LCP
  • Recommendation carousels: lazy-load below the fold using IntersectionObserver
  • Analytics beyond GA4 and Shopify's own: defer or batch

Fix 4: Fonts are still the silent killer

Shopify themes in 2026 still ship with self-hosted font files that are 150–250KB combined, and most use font-display: swap which is better than block but still causes a layout shift that can push LCP later if your H1 is the candidate.

Three moves:

  1. Subset the font to Latin (or Latin + your market's extended range). A 220KB Inter file becomes 38KB.
  2. Preload only the weight used above the fold — usually one weight, maybe two.
  3. Use size-adjust in the @font-face fallback declaration to eliminate CLS during swap.
@font-face {
  font-family: 'Inter-fallback';
  src: local('Arial');
  size-adjust: 107%;
  ascent-override: 90%;
}

body { font-family: 'Inter', 'Inter-fallback', sans-serif; }

This gets you the fallback metrics matching the real font, so when it swaps in, nothing jumps.

Fix 5: Section Rendering API for the fold below the fold

If your PDP has a recommendations rail, a recently-viewed section, or UGC gallery below the fold, server-rendering all of it on initial load costs you TTFB, which cascades into LCP. We move these to deferred fetch via Shopify's Section Rendering API.

const loadRecs = () => {
  fetch(`/products/${handle}?section_id=product-recommendations`)
    .then(r => r.text())
    .then(html => {
      document.querySelector('#recs-slot').innerHTML = html;
    });
};

if ('requestIdleCallback' in window) {
  requestIdleCallback(loadRecs, { timeout: 2000 });
} else {
  setTimeout(loadRecs, 1500);
}

TTFB on one merchant dropped from 680ms to 410ms after we deferred three below-the-fold sections. That alone shaved roughly 300ms off LCP because everything downstream started earlier.

Fix 6: Measure on real devices, not Lighthouse

Lighthouse runs on a simulated mid-tier device. Real users on actual phones in the markets you serve are usually worse. We use Chrome User Experience Report (CrUX) data for the 75th percentile LCP on mobile — that's what Google uses for ranking, and it's what you should optimize against.

The gap between lab LCP and field LCP on Shopify sites we audit is routinely 800ms to 1.2s. If your lab shows 2.4s and you're celebrating, field p75 is probably 3.3s and you're still failing Core Web Vitals.

Set up a field-data dashboard — the web-vitals library sent to your analytics endpoint does it in an afternoon:

import { onLCP, onCLS, onINP } from 'web-vitals';

const send = (metric) => {
  navigator.sendBeacon('/api/vitals', JSON.stringify({
    name: metric.name,
    value: metric.value,
    id: metric.id,
    url: location.pathname,
  }));
};

onLCP(send);
onCLS(send);
onINP(send);

Now you're optimizing against reality.

The order matters

If we're parachuting into a slow Shopify store tomorrow, the order is: diagnose the actual LCP element first, fix the preload hint, audit apps in the head, then address images and fonts. Deferred sections and field measurement come after the quick wins because they take longer to implement and validate.

We've seen teams start with a headless rebuild when the real problem was a review app and a 340KB hero image. A two-week performance sprint on the existing theme almost always beats a six-month replatform — and if after that sprint you're still stuck above 2.5s, then it's time to seriously consider headless. That's a different conversation and a different budget.

Where we'd start: run the LCP diagnostic script on your top-traffic product page today. If the element surprises you, you've already learned more than a month of PageSpeed Insights reports would have told you. From there, the six fixes above cover 90% of what we see in the wild. The last 10% is usually a specific theme quirk or an app vendor that needs to be replaced — and those you can only find by measuring.

#Shopify#Performance#Core Web Vitals#CRO#E-commerce

Want a team like ours?

72Technologies builds production software for the kind of teams who actually read this blog.

Start a project