How to fix a poor Largest Contentful Paint (LCP) score
Find the LCP element, split its time into server response, load delay, load time and render delay, and fix the largest part first. With Next.js examples.
By Sohail Hussain21 November 20266 min read
To fix a poor Largest Contentful Paint score, find which element is the LCP on mobile, split its load time into four parts (server response, resource load delay, resource load duration and render delay), and fix whichever part is largest. On most business sites the culprit is the hero image: discovered late, lazy-loaded by mistake, or several times bigger than it needs to be. The target is 2.5 seconds or less for 75% of visits, and anything over 4 seconds is rated poor.
The method below follows Google's guide to optimising LCP, with the specific fixes we apply on Next.js and WordPress sites.
How do you find what is slowing LCP?
Start with field data. Search Console's Core Web Vitals report tells you whether LCP fails on mobile, desktop or both, and groups the failing URLs. Lab tests on your own fast laptop will mislead you. Core Web Vitals explained covers the difference between field and lab data.
Find the LCP element. Run one failing URL through PageSpeed Insights on mobile and look for the diagnostic that names the Largest Contentful Paint element. Or record a page load in the Performance panel of Chrome DevTools with mobile throttling on. It is usually a hero image, a large heading or a block of text.
Break the time into parts. Both tools split LCP into four phases. Google's guidance gives a rough healthy balance:
| Part | What it covers | Healthy share of LCP |
|---|---|---|
| Time to first byte | Server and network until the HTML starts arriving | About 40% |
| Resource load delay | From first byte until the LCP image starts downloading | Under 10% |
| Resource load duration | Downloading the LCP image itself | About 40% |
| Element render delay | From download finished until it appears on screen | Under 10% |
If the LCP element is text, there is no resource to load, and the time sits in server response and render delay. Fix the largest part first. Enter your current figures in our Core Web Vitals checker to keep a before-and-after record.
When the cause is a theme, a plugin stack or a hosting setup rather than one image, this becomes the kind of performance work we do in our technical SEO service.
How do you cut server response time?
A slow first byte delays everything after it. The fixes, in order of impact:
- Serve pre-rendered HTML from a cache. A page assembled from a database on every request is slow by design. In Next.js, keep marketing pages static and cache data with
use cache; on WordPress, use full-page caching at the host or a plugin. - Use a CDN so the cached HTML is served from a location near the visitor. For an audience in India or the Gulf, a server in a single US or European region adds noticeable latency to every request.
- Remove redirects before the page.
httptohttpstowwwto the final URL can be three round trips before any HTML arrives. Link to the final URL directly. - Avoid per-visitor work in shared layouts. In Next.js, reading cookies or headers high in the tree can make every page render on request. Push that work down into the component that needs it, inside a Suspense boundary.
How do you make the LCP image start loading sooner?
Resource load delay is the gap between the HTML arriving and the browser starting to fetch the hero. It should be close to zero. It grows when the browser cannot see the image early:
- The image is a CSS background. The browser only finds it after downloading and parsing the stylesheet. Use an
<img>element, ornext/imagewithfill, instead. - The image is inserted by JavaScript, for example by a slider or a client-rendered component. Render it in the server HTML.
- The image is lazy-loaded.
loading="lazy"on the hero tells the browser to wait. Many themes andnext/imagelazy-load by default, so the hero needs an explicit exception.
Then raise its priority. In plain HTML:
<img
src="/images/hero-1200.webp"
srcset="/images/hero-800.webp 800w, /images/hero-1200.webp 1200w, /images/hero-1600.webp 1600w"
sizes="100vw"
width="1600"
height="900"
fetchpriority="high"
alt="Engineers inspecting a pump assembly on the factory floor"
/>
In Next.js 16, the same is <Image loading="eager" fetchPriority="high" ... />; the older priority prop is deprecated. Next.js image optimisation has the full component. Only one or two images per page should get high priority.
Avoid hero carousels. The first slide is often loaded late or lazily, and the LCP element can change as slides rotate.
How do you make the LCP image download faster?
Resource load duration is mostly file size.
- Serve it at the displayed size. A 4000-pixel photo shown 400 pixels wide on a phone wastes most of its bytes. Use
srcsetandsizesso phones get small files; our srcset generator builds the markup. - Use WebP or AVIF. Both are much smaller than JPEG at the same visual quality.
next/imageconverts automatically. - Compress before uploading. Our image compressor does it in the browser. For most hero images, a file under 200 KB on mobile is achievable.
- Serve it from the same origin or a CDN. A hero on a third-party host adds a DNS lookup and a new connection.
How do you remove render delay?
Render delay is the time between the image (or text) being ready and it appearing on screen. The browser is blocked by something else:
- Render-blocking CSS and scripts in the head. Large stylesheets, unused CSS from a page builder, and synchronous scripts all hold up the first render. Defer non-critical scripts and remove CSS the page does not use.
- Web fonts, when the LCP element is text. If text is invisible until the font arrives, LCP waits for the font. Use
font-display: swaporoptional, self-host the font, and preload only the one file the heading needs.next/fonthandles all three. - Content hidden until JavaScript runs. A hero that starts at
opacity: 0and fades in when a script runs is not counted until it becomes visible, so LCP includes the time to download and run that script. Animate secondary content if you like, but show the hero immediately. - Client-side rendering. If the page shell renders but the main content appears only after JavaScript fetches data, LCP includes all of that. Render the content on the server.
How do you confirm the fix worked?
Run PageSpeed Insights again straight away to check the lab numbers moved. Then wait. Field data is a 28-day rolling window, so the improvement appears gradually and is complete about four weeks after deployment. Use "Validate fix" in Search Console's Core Web Vitals report to start Google's own check.
If LCP is still poor after these fixes, the problem is usually structural: a heavy theme, a page builder, or a server that cannot cache. That is when a rebuild beats more tuning, and it is one of the reasons in why we build company websites with Next.js. For WordPress sites that are staying on WordPress, how to speed up WordPress covers the platform-specific fixes.
Was this guide useful?