Skip to content
Technical SEO

LCP (Largest Contentful Paint)

The time until the largest visible content element is rendered.

LCP — Largest Contentful Paint — is the Core Web Vitals metric measuring the time from navigation start until the largest visible content element within the viewport finishes rendering, typically a hero image, a large block of text, or a video poster frame.

It is the loading-speed component of Core Web Vitals and, of the three metrics, the one most directly tied to classic performance fundamentals: server response time, resource load time, and render-blocking behaviour before the browser can paint that final element.

The official 'good' threshold is a p75 LCP under 2.5 seconds — at least three-quarters of a page's real-world visits must clear that bar. Between 2.5 and 4.0 seconds is 'needs improvement'; above 4.0 seconds is classified 'poor', and correlates with significantly higher bounce rates, particularly on mobile connections.

Most LCP failures trace back to a small set of causes: an unoptimised or oversized hero image, slow server response (Time to First Byte), render-blocking CSS or JavaScript loaded ahead of the LCP element, or client-side rendering delaying when the element even exists in the DOM.

How LCP is calculated and what counts as the element

The browser identifies the largest element rendered in the initial viewport — images, `<video>` poster frames, background images set via CSS on visible elements, and blocks of text are all eligible; elements that render off-screen or later than the initial viewport-relevant paint don't count.

LCP timing is measured from navigation start and includes everything that happens before that element can paint: DNS lookup, connection setup, server response time, resource download, and any render-blocking resources (unoptimised CSS, synchronous JavaScript) that delay the browser from getting to that paint at all.

Why LCP matters more in the AI-search era

As organic click volume becomes scarcer and more concentrated on high-intent commercial and local queries due to AI Overviews absorbing informational search, every click that does land carries more relative business value — and a slow first paint is one of the most reliable predictors of an immediate bounce before a visitor ever sees a page's actual content or offer.

How to diagnose an LCP problem

Start with field data — Search Console's Core Web Vitals report or the CrUX dashboard — to confirm the failure and identify which URL groups are affected, since a single-page Lighthouse test can look fine while real users on slower connections or devices experience a genuine failure.

Use PageSpeed Insights or Chrome DevTools' Performance panel to break down the LCP timing into its sub-phases: Time to First Byte, resource load delay, resource load time, and render delay, which together identify exactly where the time is being lost.

Common causes of slow LCP

Unoptimised hero images — oversized files, outdated formats like uncompressed JPEG or PNG instead of AVIF/WebP, and no responsive `srcset` — are the single most common cause on content-heavy and local service sites.

Slow server response time, often from shared or under-provisioned hosting, unoptimised database queries, or no server-side caching, adds directly to LCP before any client-side work even begins.

Render-blocking CSS and synchronous JavaScript loaded in the document head before the LCP element can paint are a frequent secondary cause, particularly on sites built on heavier CMS themes or page builders.

  • Oversized, unoptimised hero images with no modern format or responsive sizing.
  • Slow Time to First Byte from under-provisioned hosting or uncached server responses.
  • Render-blocking CSS/JS loaded ahead of the LCP element.
  • Client-side rendering delaying when the LCP element even exists in the DOM.

A step-by-step LCP fix process

Compress and correctly size the hero image or LCP element, serve it in AVIF or WebP via a CDN, and add `fetchpriority="high"` plus a `<link rel="preload">` hint so the browser fetches it as early as possible.

Improve Time to First Byte: enable server-side caching, use a CDN for edge delivery, and audit slow database queries or unnecessary server-side rendering work on the critical path.

Eliminate or defer render-blocking CSS and JavaScript above the LCP element — inline critical CSS, defer non-critical stylesheets, and load non-essential scripts with `defer` or `async`.

Where the LCP element is rendered client-side (common in React-heavy sites), ensure it can render from server-side or statically-generated HTML rather than waiting on a full client-side hydration cycle.

Re-measure using field data over a 28-day CrUX window to confirm the fix moved the actual p75 figure, not just a single lab test.

LCP for local Austin-area service business sites

Local service sites frequently lead with a large, unoptimised hero photo of a completed project or team — visually valuable but often the single biggest LCP cost on the homepage. Serving that image via a CDN in a modern format with proper sizing is usually the highest-leverage single fix available, ahead of any hosting migration or framework change.

How LCP relates to INP, CLS, and hosting choices

LCP, INP, and CLS together form Core Web Vitals, each covering a distinct dimension of page experience, and a fix for one does not automatically fix the others. LCP is also the metric most sensitive to hosting and CDN choices specifically, since server response time is a direct, unavoidable component of its timing.

LCP thresholds and typical remediation impact

Good≤ 2.5sPasses the Core Web Vitals threshold at p75.
Needs improvement2.5–4.0sOften fixable with image optimisation alone.
Poor> 4.0sUsually requires both server and client-side fixes.
Typical image-optimisation gain0.5–1.5s reductionFrom compression, modern format, and CDN delivery alone.

Frequently asked questions

What is a good LCP score?
2.5 seconds or under, measured at the 75th percentile of real user visits in the field. Between 2.5 and 4.0 seconds is 'needs improvement'; above 4.0 seconds is 'poor' under Google's Core Web Vitals thresholds.
What usually causes slow LCP?
Most commonly an unoptimised, oversized hero image, slow server response time (Time to First Byte), or render-blocking CSS and JavaScript loaded before the largest content element can paint.
Does image compression alone fix LCP?
It's often the single biggest lever, typically improving LCP by 0.5 to 1.5 seconds, but a genuinely poor score usually also needs server response and render-blocking-resource fixes to reliably clear the 2.5-second threshold.
How do I know which element counts as my LCP element?
Chrome DevTools' Performance panel and PageSpeed Insights both identify the specific LCP element for a page. It's usually a hero image, a large heading or text block, or a video poster frame in the initial viewport.
Does LCP matter on mobile more than desktop?
Effectively, yes — mobile connections and devices are typically slower and more variable, so LCP failures are more common and more consequential on mobile, and Google's field data reports mobile and desktop separately.
Example

A landscaping company's homepage LCP was 4.1 seconds, driven by a 3.2MB unoptimised JPEG hero image. Converting it to WebP at correct dimensions and serving it via a CDN with a preload hint reduced LCP to 1.9 seconds within the next CrUX reporting window.

Need this applied to your site?

We turn concepts like these into shipped work every week.