How to Fix a Slow Largest Contentful Paint (LCP) on Mobile

Largest Contentful Paint (LCP) measures how long the biggest visible element, usually a hero image or headline block, takes to render on a mobile device. Our audit reads your mobile LCP from Google PageSpeed Insights: under 2.5s passes, 2.5 to 4.0s is a warning, and over 4.0s fails. By the end of this guide you will have found your LCP element, fixed the delays in front of it, and confirmed the new score.

By Updated ⏱ 2-4 hours (plus up to 28 days for field data to update)🎯 Advanced● High impactTechnical
Illustration: Largest Contentful Paint (LCP) fix guide
TECHNICAL · FIX GUIDE Largest Contentful Paint (LCP) IMPACTEFFORT TIME2-4 hours (plus up to 28 days for field data to update) LEVELAdvanced

Why it matters

LCP is one of Google's three Core Web Vitals, and Google uses page experience signals as a ranking factor. A page that sits on a blank or half-loaded screen for 4+ seconds on a phone loses visitors before they see your offer, and bounce rates rise sharply with every extra second. Slow pages are also costlier for crawlers, including AI crawlers, to fetch and render, so a fast, server-rendered main element helps both search and AI tools pick up your content reliably.

✕BeforePageSpeed Insights (mobile): LCP 4.8s.The LCP element is a 2.1 MB JPEG herowith loading="lazy", behind a 1.4s✓AfterPageSpeed Insights (mobile): LCP 1.9s.The hero is a 90 KB AVIF served from aCDN with fetchpriority="high", and

What you need

Your page URL and access to PageSpeed Insights (pagespeed.web.dev)
Chrome DevTools
Admin access to your CMS or theme code
Access to hosting, CDN or caching settings

Step-by-step fix

1

Identify the LCP element and where time is lost

Run your URL at pagespeed.web.dev and stay on the Mobile tab. Note whether the top section shows real-user (field/CrUX) data or only lab data, because our audit reports whichever source PSI returns. Under Diagnostics, expand Largest Contentful Paint element to see the exact element and its phase breakdown:

  • Time to First Byte: server delay
  • Resource load delay: the browser found the image late
  • Resource load duration: the file is too heavy
  • Element render delay: CSS or JS is blocking rendering

Fix the largest phase first.

Pro tip: In Chrome DevTools, open the Performance panel and record with 4x CPU slowdown and Slow 4G throttling. The LCP marker in the Timings track highlights the element on the page.
2

Cut server response time (TTFB)

Aim for a TTFB under 0.8s on mobile. Field data counts it from navigation start, so redirects add to it. To get there:

  • Enable full-page caching so HTML is served from cache, not rebuilt for every visitor.
  • Put the site behind a CDN that caches HTML at the edge.
  • Remove redirect chains, for example http to https to www.
  • Upgrade underpowered shared hosting or PHP versions.

Measure from the command line before and after each change.

text
curl -o /dev/null -s -w "DNS: %{time_namelookup}s  Connect: %{time_connect}s  TTFB: %{time_starttransfer}s  Total: %{time_total}s\n" https://example.com/
Pro tip: Run the curl command 3 times. If the first run is slow and the next runs are fast, your cache works but is expiring too quickly or varying on cookies.
3

Make the hero image discoverable and high priority

The LCP image must be in the initial HTML as a real <img> tag, not injected by JavaScript or hidden in a CSS background. On that image, set the following:

  • Remove loading="lazy".
  • Add fetchpriority="high".

If the image must stay a CSS background, or comes from a slider script, add a preload link in the <head>. Only prioritise the one LCP image, not every image above the fold.

html
<!-- In <head>, only needed if the image is a CSS background or loaded late -->
<link rel="preload" as="image" href="/img/hero-1200.avif" imagesrcset="/img/hero-600.avif 600w, /img/hero-1200.avif 1200w" imagesizes="100vw" fetchpriority="high">

<!-- The hero image itself -->
<img src="/img/hero-1200.avif" srcset="/img/hero-600.avif 600w, /img/hero-1200.avif 1200w" sizes="100vw" width="1200" height="675" alt="Example Co team at work" fetchpriority="high" decoding="async">
Pro tip: If the hero image is on a different domain, such as a CDN, add <link rel="preconnect" href="https://cdn.example.com"> so the connection is ready earlier.
4

Compress and resize the LCP image

Serve the hero image in AVIF or WebP at the size it actually displays on a phone, not a 4000px original. Use srcset and sizes so mobile devices download roughly a 600-800px version. Target under 100-150 KB for a mobile hero.

You can use an image CDN that converts formats automatically, or export with a tool like Squoosh or the command below.

text
npx @squoosh/cli --avif '{"cqLevel":30}' --resize '{"width":800}' -d ./out hero.jpg
# or with ImageMagick 7+
magick hero.jpg -resize 800x -quality 60 hero-800.avif
Pro tip: Always set width and height attributes on the image. They do not speed up LCP, but they prevent layout shift, which is a separate Core Web Vital.
5

Remove render-blocking CSS, JS and font delays

If Element render delay is large, the image has downloaded but the page is not allowed to paint it yet. Work through these fixes:

  • Add defer to non-critical scripts.
  • Load third-party tags (chat, heatmaps, A/B testing) after page load.
  • Inline the small amount of CSS needed for above-the-fold content.
  • Use font-display: swap so text-based LCP elements are not hidden while web fonts load.

Remove A/B testing "anti-flicker" snippets that hide the whole page with opacity:0. They directly delay LCP.

html
<script src="/js/app.js" defer></script>
<link rel="preload" href="/fonts/inter-var.woff2" as="font" type="font/woff2" crossorigin>
<style>
  @font-face { font-family: "Inter"; src: url(/fonts/inter-var.woff2) format("woff2"); font-display: swap; }
</style>
Pro tip: Check the PSI Opportunities list for "Render-blocking requests". It names the exact files and how much time each one costs.
6

Replace sliders and client-rendered heroes

Hero carousels, fade-in animations and heroes built by a JavaScript framework after load all push LCP back. The browser cannot paint an element until the script has created and revealed it. Replace them with the following:

  • Use a single static first slide rendered in HTML.
  • Remove entrance animations on the hero.
  • On frameworks, use server-side rendering or static generation so the hero arrives in the first HTML response.
7

Re-test and confirm the result

Clear your site and CDN caches, then run PageSpeed Insights on mobile again. Lab LCP updates immediately. Field (CrUX) data is a rolling 28-day average of real users, so it improves gradually over about four weeks.

5s.

Pro tip: Track field LCP over time in Google Search Console under Experience > Core Web Vitals > Mobile. After deploying, click Validate Fix on the LCP issue.

Platform-specific notes

WordPress

Since WordPress 6.3, core adds fetchpriority="high" to the first large content image and skips lazy loading on it. Themes and page builders often override this, so check the HTML. Caching plugins such as WP Rocket, LiteSpeed Cache or W3 Total Cache provide page caching, and most have an option to exclude above-the-fold images from lazy loading. Avoid running two caching plugins at once.

Shopify

Images are already served from Shopify's CDN with automatic WebP/AVIF. Your job is the theme markup. In the hero section's Liquid file (Online Store > Themes > Edit code), render the image with: {{ section.settings.image | image_url: width: 1600 | image_tag: loading: 'eager', fetchpriority: 'high', widths: '400, 800, 1200, 1600', sizes: '100vw' }}. Remove unused apps, because many inject render-blocking scripts.

Next.js

Use next/image for the hero. Add the priority prop on Next.js 15 and earlier, or preload on Next.js 16+, where priority is deprecated. This removes lazy loading and adds a preload. Render the hero on the server (Server Components or static generation) rather than in a client component that fetches data first.

Cloudflare

Add a Cache Rule to cache HTML (Cache eligibility: Eligible for cache, Edge TTL set), or use APO for WordPress sites. Turn on Polish for image compression (Speed > Optimization > Image Optimization; paid plans). Turn on Early Hints so preload links are sent before the HTML finishes.

Wix / Squarespace

You cannot edit server response or preload tags directly. Keep the top section to one static image, avoid video backgrounds and slideshows above the fold, and upload images at about 2000px wide or smaller. The platform converts formats and serves them through its own CDN.

Check that it worked

✅ How to verify

  • PageSpeed Insights (pagespeed.web.dev), Mobile tab: LCP shows under 2.5s, and the LCP element diagnostic shows small load delay and render delay.
  • View the page source (Ctrl+U): the hero <img> appears in the raw HTML with fetchpriority="high" and no loading="lazy".
  • Run curl -w "%{time_starttransfer}" against the URL several times: TTFB is consistently under about 0.8s.
  • Check Google Search Console > Core Web Vitals > Mobile over the next 28 days: URLs move from Poor or Needs improvement to Good.

⚠️ Common mistakes

  • Lazy-loading every image, including the hero, which delays the one image that matters most for LCP.
  • Preloading or setting fetchpriority="high" on many images or fonts, which makes them compete for bandwidth and cancels the benefit.
  • Testing only on desktop or on a fast office connection, while the audit measures mobile under throttled conditions.
  • Expecting the field data score to change the day after deploying, when CrUX is a 28-day rolling average.

Is this still an issue on your site? Run a free audit — ZORO checks this and 294 other SEO, AI-visibility, accessibility and security signals, with fixes for your platform.

Check my site free

FAQ

What is a good LCP score?

Google rates LCP as good at 2.5 seconds or less, needs improvement between 2.5 and 4.0 seconds, and poor above 4.0 seconds. These ratings are judged at the 75th percentile of real mobile and desktop visits. Our audit uses the mobile value from PageSpeed Insights.

Why is my PageSpeed LCP different every time I test?

Lab tests run on one simulated device and network, so server load, ads and third-party scripts cause variation between runs. Field data from real Chrome users is more stable but updates slowly. Run 3 tests and look at the median, and treat field data as the final verdict when it is available.

Should I preload my hero image?

Preload it only if the browser discovers it late, for example when it is a CSS background image or inserted by JavaScript. If it is already a normal <img> in the HTML, adding fetchpriority="high" and removing loading="lazy" is usually enough.

Does a CDN fix LCP on its own?

Not always. A CDN shortens the distance files travel and can cache HTML, which lowers TTFB. However, an oversized image, a lazy-loaded hero or render-blocking scripts will still keep LCP high. Use the phase breakdown in PageSpeed Insights to see which part is slow.