Largest Contentful Paint (LCP) is the time from when a page starts loading to when the largest element visible in the viewport finishes rendering. It is one of Google's three Core Web Vitals, alongside CLS and INP, and it is the one that best matches what a visitor means by "the page has loaded".
The thresholds are measured at the 75th percentile of real visits:
- Good: 2.5 seconds or less
- Needs improvement: 2.5 to 4 seconds
- Poor: over 4 seconds
This guide covers what LCP measures, how to find the element that is setting your LCP, how to work out which of its four phases is slow, and the fix for each — plus the WordPress-specific causes that come up most often.
What LCP Actually Measures
As a page loads, the browser keeps track of the largest content element it has painted in the viewport so far. Every time something bigger appears, that becomes the new LCP candidate. Recording stops as soon as the visitor interacts — a tap, a scroll or a key press — and the last candidate standing is the LCP element. Its render time is the LCP value.
Only certain elements can be the LCP element:
<img>elements, and<image>elements inside an SVG<video>elements (the poster image, or the first frame)- Elements with a background image set through CSS
url() - Block-level elements containing text, such as a heading or paragraph
In practice, on an article or landing page it is usually the hero image. On a product page it is the main product photo. On a text-only page it is often the headline or the first paragraph — which is why a slow web font can be an LCP problem.
How to Find Your LCP Element
You cannot fix LCP until you know which element it is, and it is frequently not the one you would guess — a cookie banner or a large block of intro text can beat the hero image. Three ways to find it:
- PageSpeed Insights or Lighthouse. In the Diagnostics section, the audit titled "Largest Contentful Paint element" (in newer versions, "LCP breakdown") shows the element itself, with the description "This is the largest contentful element painted within the viewport." Directly beneath it is the time spent in each of the four phases described below — the single most useful table for diagnosing LCP.
- Chrome DevTools. Open the Performance panel. The live metrics view shows your LCP as the page loads and names the element; hover it to highlight it on the page. Recording a trace adds an LCP marker to the timeline, so you can see what the browser was doing just before it.
- A few lines of JavaScript. Paste this into the console and reload to log each LCP candidate as it appears:
new PerformanceObserver((list) => { const entries = list.getEntries(); const lcp = entries[entries.length - 1]; console.log('LCP', Math.round(lcp.startTime), 'ms', lcp.element); }).observe({ type: 'largest-contentful-paint', buffered: true });
Test on mobile settings. The LCP element on a phone is often a different element from the one on desktop, because the layout reflows and different content lands in the viewport.
LCP by Phase: Where the Time Goes
Google breaks every LCP into four consecutive phases. They add up exactly to the LCP time, so finding the largest one tells you what to fix:
| Phase | What it covers | Target |
|---|---|---|
| Time to First Byte | From navigation until the first byte of HTML arrives, including redirects, DNS, connection and server time | ~40% |
| Resource load delay | From the first byte until the browser starts downloading the LCP resource | <10% |
| Resource load duration | How long the LCP resource takes to download | ~40% |
| Element render delay | From the resource finishing until the element is actually painted | <10% |
The shares are Google's own guidance, not hard rules, but they are a useful check. If load delay or render delay is taking a large part of your LCP, that time is almost entirely wasted, and it is usually the cheapest to win back. If your LCP element is text, the two resource phases are zero and everything happens in TTFB and render delay.
Fix 1: Slow Server Response (TTFB)
Google rates a TTFB of 0.8 seconds or less as good. On a 2.5-second LCP budget, TTFB much above a second leaves too little time for everything else, however well optimised the front end is.
In August 2026 we measured the homepage of every Australian domain in the Tranco top-1 million list — 6,421 sites that responded — for our Australian web delivery report. The median TTFB was 480 ms, measured from an Australian connection. A quarter of sites took longer than 924 ms, and 23% took longer than a full second — a large part of the budget spent before the browser has seen a single tag.
Two findings from that scan are directly relevant to LCP:
- A CDN on its own did not make the first byte faster. Sites behind a CDN had a median TTFB of 525 ms, against 329 ms for sites served straight from their origin. The likely reason is that most CDN setups do not cache HTML by default: the page request still goes all the way to the origin, plus an extra hop. A CDN speeds up images, CSS and scripts; it only speeds up TTFB when the HTML is cached at the edge too.
- Redirects are common and they count. 56% of homepages redirected at least once before serving the page — typically
example.com.autowww.example.com.au, or HTTP to HTTPS. Each redirect is a full round trip, and all of it lands in the TTFB phase of LCP. Link to your final URL everywhere you control the link.
The fixes for a slow TTFB, roughly in order of how often they are the answer:
- Full-page caching. A CMS that builds each page from the database on every request is the most common cause. Cache the rendered HTML — at the server (Varnish, nginx FastCGI cache, a WordPress caching plugin) or at the edge (caching headers plus a CDN rule that caches HTML).
- Host close to your visitors. A server in the United States adds around 150–200 ms of round-trip time for every visitor in Australia, several times over during connection setup. Move the origin, or cache HTML at an edge location near your audience.
- Remove redirect hops on your most visited entry points.
- Profile the slow requests. Uncached pages that stay slow usually point to database queries (missing indexes, N+1 queries) or an underpowered hosting plan.
Fix 2: Resource Load Delay (Late Discovery)
If the LCP image is only discovered late — because JavaScript inserts it, or it is a CSS background — the browser spends time doing nothing about it. The fix is to make the LCP resource visible in the initial HTML and to mark it as important:
- Use a real
<img>tag in the HTML. The browser's preload scanner finds<img>tags before any CSS or JavaScript has run. Images injected by JavaScript, and CSS background images, are only found much later. - Add
fetchpriority="high"to the LCP image. All major browsers support it, and it moves the image ahead of less important downloads:<img src="hero.jpg" fetchpriority="high" width="1200" height="600" alt="..."> - Preload it when the image cannot be in the HTML directly (a CSS background, or an image chosen by a script):
<link rel="preload" as="image" href="hero.jpg" fetchpriority="high"> - Never lazy-load the LCP image.
loading="lazy"on an above-the-fold image tells the browser to wait until layout is complete before even requesting it. It is one of the most common LCP bugs we see, and one of the easiest to fix. Lazy-load images below the fold only.
Fix 3: Resource Load Duration (a Heavy File)
The browser found the image promptly but it takes too long to download. Make it smaller — the image optimisation guide covers this in depth:
- Use modern formats. WebP is typically 25–35% smaller than JPEG at the same visual quality; AVIF is often smaller again. Serve them with a fallback:
<picture> <source srcset="hero.avif" type="image/avif"> <source srcset="hero.webp" type="image/webp"> <img src="hero.jpg" fetchpriority="high" alt="..."> </picture> - Size the image for how it is displayed. An image shown at 800 pixels wide does not need a 4,000-pixel source.
- Serve smaller images to smaller screens with
srcsetandsizes, so phones do not download the desktop hero:<img src="hero-1200.jpg" srcset="hero-600.jpg 600w, hero-1200.jpg 1200w" sizes="100vw" alt="..."> - Compress it. For a full-width hero, under about 200 KB is a sensible target. Squoosh, ImageOptim or a build step using sharp will get most images there.
- Let an image CDN do the work. Cloudflare Images, Imgix and Cloudinary resize and convert images on the fly. This is where a CDN genuinely helps LCP.
Fix 4: Element Render Delay
The image has arrived, but the browser cannot paint it yet because it is still busy with other work — usually CSS or JavaScript that blocks rendering. See render-blocking resources for the detail:
- Defer non-critical JavaScript. Add
deferorasyncso scripts stop blocking the parser:<script src="analytics.js" defer></script> - Inline critical CSS — the styles needed for above-the-fold content — and load the rest without blocking.
- Cut JavaScript bundle size. Code-split, tree-shake and remove unused libraries. A large bundle takes real time to parse and run on a mid-range phone.
- Audit third-party scripts. Chat widgets, A/B testing and tag managers loaded in the head all hold up the first paint. A/B testing tools that hide the page until they have run are especially costly.
- Render content on the server. A single-page app that ships an empty
<div id="root">cannot paint anything until its JavaScript has downloaded and run. Server-side rendering or static generation (Next.js, Nuxt, SvelteKit, Astro) puts the LCP element in the initial HTML. - Use
font-display: swapwhen the LCP element is text in a web font, so the text shows in a fallback font instead of staying invisible while the font downloads:@font-face { font-family: 'Custom'; src: url('custom.woff2') format('woff2'); font-display: swap; }
Largest Contentful Paint on WordPress
WordPress sites hit the same four phases, but the causes are predictable enough to check directly:
- No page cache. Without caching, every visit runs PHP and database queries before the first byte, which shows up as a slow TTFB. A caching plugin (WP Rocket, LiteSpeed Cache, W3 Total Cache) or host-level caching usually makes the biggest single difference.
- The hero image is lazy-loaded. Recent versions of WordPress (6.3 onwards) try to leave the likely LCP image eager and give it
fetchpriority="high". But many themes, page builders and optimisation plugins apply their own lazy loading to every image, which undoes this. Most caching plugins, WP Rocket included, let you exclude specific images from lazy loading — put the hero on that list. - The hero is a background image or a slider. Page builders often set the hero as a CSS background on a section, and sliders usually build their slides with JavaScript. Both delay discovery (Fix 2). A plain image block, or a preload for the first slide, fixes it.
- Too many plugins adding scripts to the head. Each one adds to render delay. Check which scripts load on every page and whether they need to.
- Oversized uploads. A 5 MB photo straight off a camera, used full-width, is a resource load duration problem. Resize before uploading, or use a plugin that converts uploads to WebP.
A Diagnostic Workflow
- Measure. Run the URL through Site Speed Check for the mobile and desktop LCP, the score against Google's thresholds, and the opportunities that affect it — server response time, redirects, render-blocking resources, image formats and sizing.
- Find the element using the Lighthouse "Largest Contentful Paint element" audit or the DevTools Performance panel.
- Find the slow phase in the phase breakdown, and compare it against the rough shares above.
- Apply the fix for that phase only. Optimising the image does nothing if the problem is a two-second TTFB.
- Check field data. Lab tests like Lighthouse use one simulated device and connection. Google's assessment uses real Chrome users over the previous 28 days, so after a fix, lab results change immediately while field data catches up over about four weeks.
The Short Version
Most slow LCPs come down to one of three things: a server that answers slowly because HTML is not cached, a hero image that is too heavy or found too late, or scripts in the head that delay painting. Find the element, find the slow phase, fix that phase. Once your 75th percentile is under 2.5 seconds, visitors see your main content in about the time they expect — and the page passes the Core Web Vital that sites fail most often.