Plugins Plugin hub Backup SEO Caching Security Forms WooCommerce Images Best backup plugins
Hosting Hosting directory Shared Managed Cloud India
Themes & builders Compare Rank Math vs Yoast
Tools All tools Hosting finder Plugin stack builder Cost calculator Salt generator Theme detector Who is hosting this? Speed test Headline analyzer robots.txt generator Redirect generator Uptime calculator Blog name generator
Best lists Best backup plugins Deals
Guides All guides Speed up WordPress Choose hosting Back up WordPress
How we test

Speed & performance · Guide

How to Improve LCP in WordPress

Short answer

To improve LCP in WordPress, find the largest visible element on each key page, then preload it, stop lazy loading it, and cut the server response time behind it. A good LCP is 2.5 seconds or less at the 75th percentile of real visits, as of November 2026. Work through the hero image, caching, and render-blocking files in that order, then recheck the field data in PageSpeed Insights.

Key takeaways

  • A good LCP is 2.5 seconds or less at the 75th percentile of real visits, and over 4.0 seconds is poor.
  • On 73% of mobile pages the LCP element is an image, so the hero image is usually the first fix.
  • WordPress 6.3 adds fetchpriority=“high” to the first large image that is not lazy loaded.
  • A good Time to First Byte is 800 milliseconds or less, and over 1,800 milliseconds is poor.
  • Field data in PageSpeed Insights covers the previous 28 days, so fixes take weeks to show fully there.

What is LCP in WordPress?

Largest Contentful Paint, or LCP, is the time from when a visitor starts loading a page until the largest image, text block, or video in the viewport has rendered.

web.dev defines LCP as the render time of the largest image, text block, or video visible in the viewport, measured from the start of navigation. On a WordPress site, that element is often the hero image on the home page, the featured image on a post, or a large headline.

LCP is one of the three Core Web Vitals, and it measures loading speed. The other two are Interaction to Next Paint, which measures response to input, and Cumulative Layout Shift, which measures visual stability. This guide covers LCP only, so it does not go into detail on the other two metrics.

What is a good LCP score?

A good LCP is 2.5 seconds or less, measured at the 75th percentile of real page visits.

web.dev states that sites should strive for an LCP of 2.5 seconds or less for at least 75% of page visits. That 75th percentile rule means 3 out of 4 visits must meet the target, not just the average visit.

LCP resultTimeWhat it means
Good2.5 seconds or lessMost visitors see the main content fast enough
Needs improvementOver 2.5 to 4.0 secondsThe main content is slow for many visitors
PoorOver 4.0 secondsThe main content is slow enough to need urgent work

The same thresholds appear in the PageSpeed Insights guide from Chrome for Developers, which lists LCP as good at 0 to 2,500 milliseconds, needs improvement at 2,500 to 4,000 milliseconds, and poor above 4,000 milliseconds. Check your score against those bands, as of November 2026.

How do you find your LCP element and score?

Open PageSpeed Insights, enter the page URL, and read the field data at the top before you change anything.

PageSpeed Insights is at pagespeed.web.dev. Enter a public URL and click Analyze. The top section, labeled Discover what your real users are experiencing, shows field data from the Chrome User Experience Report, known as CrUX.

Field data covers the previous 28 days and is updated daily, according to the PageSpeed Insights guide. The lower section, labeled Diagnose performance issues, shows lab data from one simulated Lighthouse load. Use field data to judge whether a page passes, and lab data to find the cause.

  1. Run your home page and 2 or 3 high-traffic pages through PageSpeed Insights.
  2. Note the LCP value, the rating, and whether the data is for this URL or the whole origin.
  3. Scroll to the Lighthouse section and find the Largest Contentful Paint element diagnostic.
  4. Write down the exact element it names, such as a hero image file or a heading.
  5. Repeat the run on mobile and desktop, because the LCP element can differ between them.

If PageSpeed Insights shows No Data, the page has too little CrUX traffic for URL-level field data. Use the origin data it shows instead, and use the lab result to guide the fix. For a general speed plan, see how to speed up WordPress.

How do you cut the time before the LCP image starts loading?

Make the LCP image discoverable in the first HTML response and give it high priority, so the browser starts downloading it at once.

web.dev breaks LCP into 4 subparts: Time to First Byte, resource load delay, resource load duration, and element render delay. The delay parts should be close to zero, while most of the time should go to loading the HTML document and the LCP source itself.

LCP subpartShare of LCP on a well-tuned pageWhat it covers
Time to First ByteAbout 40%Waiting for the first byte of the HTML document
Resource load delayUnder 10%Waiting to start loading the LCP resource
Resource load durationAbout 40%Downloading the LCP resource itself
Element render delayUnder 10%Waiting to render the element after its resource loads

The same web.dev guide notes that the two delay parts are the clearest sign of waste. If the browser spends a long time before it even starts the LCP download, shrinking the image file will not fix the total.

web.dev reports that, among pages with poor LCP, loading the LCP image is delayed by 1,290 milliseconds at the 75th percentile.

That delay alone is more than half of the 2.5 second budget for a good score. The same page reports that 35% of LCP images were not discoverable in the initial HTML response.

Steps to cut resource load delay:

  1. Use a normal image element with a src or srcset attribute for the hero, not a CSS background image or an image loaded by JavaScript.
  2. Add fetchpriority="high" to that one image, and to a preload link for it if the image is a background image.
  3. Preload the LCP image with a preload link in the page head when the theme hides the image URL from the first HTML.
  4. Do not preload every image on the page, because that competes with the one image that matters.

How do you make the hero image load faster?

Serve the hero at the size the layout needs, in a modern format, with high priority and no lazy loading.

web.dev reports that 73% of mobile pages have an image as their LCP element, based on the 2024 Web Almanac by HTTP Archive. That is why the hero image is the first place to look on most WordPress sites.

WordPress 6.3 added fetchpriority="high" to the first large image on a page, according to the WordPress developer news for July 2023. The image must not be lazy loaded, must have no conflicting fetchpriority value, and must be larger than 50,000 square pixels. Check that your theme does not undo that default.

WordPress adds lazy loading to images by default, since version 5.5, and that helps below-the-fold images. It harms LCP when it is applied to the hero.

WordPress developer docs warn that an image should not be lazy loaded and marked as high priority at the same time, in wp_get_loading_optimization_attributes.

  • Set the hero image to loading="eager" and fetchpriority="high".
  • Keep loading="lazy" on images below the fold only.
  • Upload the hero at the display width, not at full camera size, and use WebP or AVIF where your image tool supports it.
  • Add width and height attributes so the browser reserves the space and the layout does not shift.

If you use LiteSpeed Cache, its docs describe Viewport Images, a service that excludes above-the-fold images from lazy loading.

The LiteSpeed Cache page optimization docs state that Viewport Images are detected by QUIC.cloud and loaded with the page, while other images stay lazy loaded. Turn that on, or add the hero file name to the lazy load excludes.

How do you fix a slow server response?

Cut Time to First Byte, or TTFB, to 800 milliseconds or less, because LCP cannot be faster than the time the server takes to answer.

TTFB is the time from when a visitor starts a navigation until the browser receives the first byte of the HTML document. web.dev warns that a high TTFB can make a 2.5 second LCP hard or impossible to reach.

The PageSpeed Insights guide lists TTFB as good at 0 to 800 milliseconds, needs improvement at 800 to 1,800 milliseconds, and poor above 1,800 milliseconds. TTFB is a diagnostic metric, not one of the three Core Web Vitals, but it feeds directly into LCP.

What to check, in order:

  1. Open Tools, then Site Health, then Info in WordPress admin, and note the PHP version and database version.
  2. Compare them with the WordPress requirements, which recommend PHP 8.3 or greater and MariaDB 10.11 or greater, or MySQL 8.0 or greater, as of November 2026.
  3. Turn on full-page caching so repeat visits are served without running PHP and database queries each time.
  4. Remove or replace plugins that run heavy work on every page load, and keep the number of active plugins low.
  5. Ask your host about the data center nearest to most of your visitors, and about persistent object caching if your plan offers it.

For help choosing a PHP version, see which PHP version to use for WordPress. A slow TTFB on a shared plan with an old PHP version is a hosting problem, not an image problem.

How do you stop render-blocking CSS and JavaScript delaying LCP?

Remove or defer the files that block the first paint, so the browser can render the LCP element as soon as its resource arrives.

web.dev explains that element render delay is the time between the LCP resource finishing its download and the element rendering. If JavaScript hides the content until it finishes loading, the time saved by a smaller image simply moves into this delay.

  • Defer non-essential JavaScript, and load scripts in the footer where the theme allows it.
  • Inline or load first the CSS needed for the top of the page, and defer the rest.
  • Remove unused CSS and JavaScript from plugins and page-builder widgets you do not use on that template.
  • Do not load sliders, carousels, or animation libraries on pages that do not need them.

WordPress 6.3 added script loading strategies through wp_register_script and wp_enqueue_script, with defer and async options.

A deferred script runs after the document has loaded, while an async script runs as soon as it loads, with no fixed order. Ask a developer to apply those strategies to non-essential scripts, and test each change on a staging copy first.

If a page builder is part of the delay, see how to speed up Elementor for its performance settings. Keep the focus here on LCP: the fix is to let the largest element render early, not to remove every script at once.

How do you use caching and a CDN for LCP?

Use full-page caching and a content delivery network so the HTML and the hero image reach visitors from a nearby server, with a cache hit instead of a fresh PHP build.

A cache stores a finished copy of a page and serves it again without running WordPress each time. A content delivery network, or CDN, stores copies of your files on servers near your visitors. Both cut TTFB and resource load duration, which are about 40% each of LCP on a well-tuned page, according to web.dev.

  1. Enable page caching in your caching plugin or at your host, and purge the cache after each content change.
  2. Enable a CDN for images, CSS, and JavaScript, and confirm the hero image is served from it.
  3. Check that logged-in users, carts, and checkout pages bypass the page cache, so visitors do not see each other's pages.
  4. Test the home page in a private browser window after each change, and confirm the layout still loads in the right order.

For WP Rocket, see how to configure WP Rocket for Core Web Vitals.

For LiteSpeed Cache with QUIC.cloud, see how to set up LiteSpeed Cache with QUIC.cloud. Use one page cache at a time, because two caches can purge and serve different copies.

WordPress 6.8 added speculative loading, which can prefetch or prerender linked pages before a visitor clicks them.

Developer docs for speculative loading state that it is only enabled for sites with pretty permalinks when no user is logged in. It helps later page views, not the first LCP on a page.

How do you check that your LCP fix worked?

Rerun the Lighthouse lab check at once for a fast signal, then wait for the 28-day field data to confirm the change for real visitors.

Lab data changes as soon as you change the site, because Lighthouse runs a fresh simulated load each time. Field data in PageSpeed Insights covers the previous 28 days, so a fix takes up to about 28 days to show fully there, according to the PageSpeed Insights guide.

  1. Rerun PageSpeed Insights on the same URL and note the lab LCP and the LCP element it names.
  2. Confirm the LCP element is the one you intended, and that it is no longer lazy loaded.
  3. Check the same page on mobile and desktop, because the element and the score can differ.
  4. Note the date of each change, so you can match later field data to the right fix.
  5. Recheck the field data weekly, and judge the fix on the 75th percentile, not on a single fast run.

web.dev reports that 40% of sites in the Chrome User Experience Report do not meet the recommended LCP threshold.

That shows how common this problem is, and why a single fix rarely moves a site from poor to good on its own. For the related question of whether speed affects search, see does page speed affect SEO.

What mistakes should you avoid?

Do not lazy load the hero, preload every image, or chase a lab score while the field data still fails.

  • Lazy loading the hero image delays the download until after the browser has other work to do.
  • Preloading 5 or 6 images at once competes with the LCP image and slows it down.
  • Using a CSS background image for the hero hides the URL from the first HTML, so the browser finds it late.
  • Adding fetchpriority="high" to every above-the-fold image removes the signal that tells the browser which one matters most.
  • Changing 4 things at once makes it impossible to tell which change helped, so change one thing, rerun the lab check, and note the result.
  • Judging the fix on one Lighthouse run ignores real visitors, because field data is judged at the 75th percentile over 28 days.

If the LCP element is a large heading instead of an image, the fix is different. Check that the font loads fast, that no script hides the text, and that the server response is under 800 milliseconds. Do not add an image preload when the LCP element is text.

Frequently asked questions

How long does it take for an LCP fix to show in PageSpeed Insights?

Lab data changes at once, because Lighthouse runs a fresh simulated load each time you click Analyze. Field data covers the previous 28 days, so a fix can take up to about 28 days to show fully there. Recheck the field data weekly and judge the fix on the 75th percentile, not on a single fast lab run.

Should I lazy load my hero image in WordPress?

No. Lazy loading delays the hero download, and the hero is often the LCP element, so lazy loading it directly harms LCP. Set the hero to loading eager with fetchpriority high, and keep lazy loading for images below the fold only. WordPress 6.3 already adds high priority to the first large image that is not lazy loaded.

Is a good Lighthouse score the same as a good LCP?

No. The Lighthouse score comes from one simulated load in a lab, while LCP in the Core Web Vitals assessment comes from real Chrome users over 28 days at the 75th percentile. A green lab score can sit beside a failed field result. Use the lab score to find causes, and use field data to judge whether visitors pass.

What if my LCP element is text, not an image?

Then the fix is about fonts, scripts, and server response, not image size. Check that the font does not block rendering, that no script hides the text until it loads, and that Time to First Byte is 800 milliseconds or less. Do not preload an image when the LCP element is a heading or a paragraph.

Does a CDN alone fix a poor LCP?

No, a CDN helps with delivery, but it cannot fix a slow server, a hidden hero image, or render-blocking files. A CDN cuts the time to fetch the HTML and the image from a nearby server. Pair it with page caching, a fast PHP version, and a preloaded hero image to move LCP under 2.5 seconds.

Sources

  1. Largest Contentful Paint (LCP) web.dev
  2. Optimize Largest Contentful Paint web.dev
  3. The most effective ways to improve Core Web Vitals web.dev
  4. How to view Chrome UX Report data on PageSpeed Insights Chrome for Developers
  5. wp_get_loading_optimization_attributes() WordPress Developer Resources
  6. What's new for developers? (July 2023) WordPress Developer Resources
  7. Page Optimization | LSCache for WordPress LiteSpeed Documentation
  8. Requirements WordPress.org

Is your product missing, or something out of date?

Tell us what to add or correct. We read every note and reply when we need a source. A message does not buy a ranking.

About the editors

WPLegible editors

Researched from the primary sources listed above and checked against our editorial rules. About the site · How we test