What Is LCP Request Discovery? (+ How to Fix LCP Image Issues)

LCP Request Discovery is one of the performance insights you may encounter in Google’s website speed testing tools. It helps diagnose why the Largest Contentful Paint (LPT) image on your page might be loading more slowly than expected. The insight checks for a few critical factors that can cause delays in this part of the loading process. 

To help you take advantage of it, this guide explores what the LCP Request Discovery means, how to measure it, and the actionable steps you can take — both manually and via plugin — to pass it. 

What Is the LCP Request Discovery Insight?

To understand LCP Request Discovery, you first need to understand LCP, or Largest Contentful Paint. It’s one of Google’s main Core Web Vitals and measures how quickly the largest visible element on a page, usually a hero image or a headline, appears. 

This matters because a delayed LCP harms the perceived overall load speed of your web pages. Poor LCP also indirectly affects other metrics like Interaction to Next Paint (INP). All of that is bad news for your site’s user experience and SEO. 

Enter LCP Request Discovery 

Google introduced this insight to make it easier to diagnose loading problems with LCP, specifically images that serve as the LCP element. 

The metric checks exactly three things: 

• Does the image have fetchpriority=high applied to it? 

• Is it discoverable in the initial document? 

• Is it not being lazy loaded? 

All these conditions aim to help ensure LCP images load as quickly as possible. Basically, it checks whether the browser can discover the image immediately and receives directives to prioritize it in the loading process. If not, it delays the LCP element and with it the entire page it appears on. 

Google’s performance tools already had two audits targeting similar issues, namely “Preload Largest Contentful Paint image” and “Largest Contentful Paint image was not lazily loaded.” Both of these are folded into the new insight. 

How to Measure LCP Request Discovery 

Website owners can check for LCP Request Discovery issues using Google PageSpeed Insights/Lighthouse and Chrome Developer Tools. 

When you run a performance test in PageSpeed Insights, the insight may appear under the Insights section. It will include the individual checks your site does and does not pass as well as the image that serves as the LCP. 

Check Passed Audits if you can’t see it. In addition, make sure your results show “Insights” not “Audits.” While LCP Request Discovery will become a default measurement in Google’s performance tools from October 2025, before that you may have to use the available switch to see it. 

You can also measure whether this performance insight applies to your page when you record a performance profile for it in the Chrome Developer Tools’ Performance tab. 

LCP Request Discovery appears in the left sidebar (again, check Passed Audits if necessary). What’s different here is that it additionally shows the loading time discrepancy between the earliest possible and the actual loading time of your LCP image. This is also visible in the network timeline. 

How to Improve LCP Request Discovery Manually 

From here, we will discuss what steps you can take if LCP Request Discovery is an issue on your website. 

Use rel=“preload” and fetchpriority=”high” 

There are HTML two attributes you can add to the declaration of your LCP image that will make it load earlier: rel=”preload” and fetchpriority=”high”. 

Preload marks a resource as critical for the browser and tells it to load it right away, earlier than it would usually discover it naturally. 

However, by default, browsers consider images low priority. So even if loaded early, they could still be queued behind other critical resources. Adding fetchpriority=”high” tells the browser to prioritize it above others instead. 

Here’s how both look in the HTML document: 

<link rel="preload" as="image" href="/images/hero.jpg" fetchpriority="high"> 

Using them helps load the LCP element as quickly as possible and improve LCP Request Discovery. 

WordPress users should note that since version 6.3, the CMS automatically adds fetchpriority=”high” to visuals most likely to be the LCP image. 

If you automatically want to preload, say, your featured images, you have to add custom PHP code to your (child) theme’s functions.php. Jackson Lewis has an example and breakdown of a solution for that. 

Load the LCP Element in the Initial Document 

There are several methods for loading images on web pages: 

• As HTML requests, using an <img> tag. 

• Using CSS, for example, with the background-image property. 

• Dynamically, via JavaScript. 

Since the first resource any browser loads is the HTML document, any image link it contains will be discovered first. In all other methods, the browser first needs to discover, download, and process other files to discover the image call. If those are low priority, it takes much longer for the image to start loading. 

For that reason, one of the strongest optimizations you can do for LCP Request Discovery is reference your LCP image directly in the initial HTML. That’s also the reason why the insight checks specifically whether that’s the case. 

In WordPress, the way your LCP image is loaded is determined by your theme. Check your page source code via browser developer tools to make sure it uses HTML markup to do so. If it doesn’t, you have to figure out how else it loads your LCP image and find a workaround to move it to the HTML. 

Avoid Lazy Loading the LCP Element 

Lazy loading is itself a great technique help web pages load faster. It prevents page elements that aren’t visible at first from loading so that they don’t delay more important parts from appearing. It’s most often used for images further down the page, so that they only load if and when a visitor scrolls towards them. 

Here, it’s as easy as adding the loading=”lazy” attribute to the HTML element. 

<img src="/images/gallery-photo.jpg" alt="Gallery photo" loading="lazy" width="600" height="400"> 

But you can also apply this method to other page elements, for which it’s called “lazy rendering.” 

As you can imagine, this technique is counterproductive when applied to LCP images. It prevents them from loading early, slowing down the entire page experience. Therefore, make sure this doesn’t happen on your site — one of the checks LCP Request Discovery performs is specifically for that. 

Since version 5.5 WordPress automatically lazy loads images (at least, those added to the page with native functionality). WordPress 5.9 modified the functionality to exclude the first three images on the page. Therefore, if you are on WordPress, the CMS might be taking care of this automatically but be sure to double-check! 

Optimize Your LCP Image 

While you are in the process of optimizing how your LCP image loads, you might as well optimize the image itself as well. Images naturally add a lot more data to web pages than code or text and are often a loading bottleneck. 

To mitigate that, there are ways to make the image as small as possible without sacrificing quality: 

• Use modern formats like WebP or AVIF, they produce smaller file sizes than JPG or PNG. 
• Compress images to get rid of unnecessary data. 
• Don’t make image dimensions larger than they appear on page (e.g. don’t use a 800px wide image that only shows 300px wide on screen). 
• Use srcset so that browsers only download the optimal size for the user’s device (this is default behavior in WordPress). 
• Use an image CDN to optimize delivery and caching for global audiences. 

Reduce Time to First Byte (TTFB) 

TTFB, or Time to First Byte, measures how long it takes for the browser to receive the first piece of page data from the server. 

A high TTFB means all requests, including the one for the LCP image, start later than they should, making overall page loading speed worse. Faster TTFB, on the other hand, helps the image be discovered and rendered faster. 

What are your options to reduce Time to First Byte? 

• Use a fast web host: The machine your site is hosted on greatly influences how quickly it loads. Use a reputable hosting provider and a server environment optimized for your type of website. 

• Enable caching: Caching means frequently requested files and resources are kept in easily accessible storage for quick access. There are several types, such as browser, server-level, and object caching that can all help reduce TTFB. 

• Use compression: Compressing HTML, CSS, and JavaScript files (also called “text compression”) reduces their size, making them faster to download. That way, pages can process more quickly, and browsers discover the LCP element sooner. 

• Optimize your database: A crowded and unoptimized database slows down page loading. Take care of it so it runs smoothly and quickly. 

• Connect your site to a content delivery network (CDN): A CDN caches content on servers across multiple regions, delivering files from the server geographically closest to each visitor. This reduces latency, speeds up TTFB, and ensures that the LCP image and all other files load faster for global audiences. 

Eliminate Render-Blocking Resources 

Render-blocking resources are CSS and JavaScript files that need to be downloaded and processed before the browser can continue rendering the page. If they don’t contain critical code, they simply delay content from showing up, directly impacting LCP by postponing the display of the largest contentful element. 

You have the following options to eliminate render-blocking resources: 

• Get rid of unused code: Check the Coverage tab in browser developer tools for unused CSS and JavaScript code and see what you can get rid of. 

• Inline critical CSS: That way, essential styles are available immediately without waiting for external files. 

• Defer or asynchronously load JavaScript: The defer and async attributes allow you to load non-critical JavaScript files in the background. That way, they don’t block the browser from processing other resources 

• Compress and minify code: Both are techniques for making code files smaller so they load faster and don’t block the browser for too long. 

How to Improve LCP Request Discovery With a Plugin 

If much of the above seems a bit too technical for your skill level and your website runs on WordPress, you can also improve your site’s LCP Request Discovery insight using WP Rocket. 

The plugin is packed with features directly addressing this performance audit. Here’s what it automatically implements the moment you simply activate it: 

• Caching, including a separate mobile cache 

• Critical image optimization (meaning images above the fold aren’t lazy loaded) 

• Automatic lazy rendering 

• GZIP compression 

• Minification for CSS and JavaScript files 

In fact, when you install and activate the plugin, your site benefits from 80% of performance best practices. If that isn’t enough, you can optionally switch on these features to further improve LCP Request Discovery: 

• Preloading external files and fonts 

• Combine, defer, and asynchronously load JavaScript 

• Delay JavaScript execution until the user interacts with the page 

• Remove unused CSS 

• Lazy loading for images, including CSS backgrounds, videos, and iframes 

• Database optimization 

Activating and deactivating these is mostly as easy as checking a few boxes beginner-friendly user interface. 

For best results, combine WP Rocket with Imagify. The plugin automatically converts images uploaded to your site to modern formats as well as compresses and resizes them individually or in bulk without loss of quality.  

Case Study: Improve LCP Request Discovery Using WP Rocket 

Usually, at this point, we would show you how WP Rocket helps you easily improve the insight audit discussed in the article. However, LCP Request Discovery is a special case. That’s because, as mentioned above, if you have an up-to-date WordPress website, your CMS helps you automatically pass it. 

Unless you have a theme with very weird markup, WordPress’ already loads images in the HTML document, adds fetch priority to the most likely LCP element, and avoids using lazy loading for visuals high up on the page. 

On the other hand, as we have also discussed, there is more you can do to improve your LCP image, and WP Rocket helps you do so quickly and easily. 

To show you what impact that can have on your website’s performance, we have created a demo WordPress site running a default theme and several popular plugins. It also sports a prominent featured image serving as the LCP element. 

After running it through PageSpeed Insights, we found the following baseline performance results: 

From here, we installed and enabled WP Rocket. Besides its automatic performance improvements (see above the list of the options activated by default)  we switched on the following features: 

• Remove unused CSS 

• Load JavaScript deferred and delay its execution 

• LazyLoad for images 

• Preload and self-host fonts 

Then, we re-ran the test. Here’s what PageSpeed Insights showed this time around: 

That’s quite the improvement, especially if you consider that it took no more than three minutes to implement, wouldn’t you agree? Just imagine what such performance gains could do for your site’s user experience and search positions! 

LCP Request Discovery: Not a Problem on Your Website 

Optimizing your site for the LCP Request Discovery insight helps it improve its Largest Contentful Paint Core score and load faster for your visitors. Use the techniques in this guide to pass the audit with flying colors. 

Need help with that? Try WP Rocket risk-free for 15 days and let it do the heavy lifting for you.