What Is Largest Contentful Paint (LCP)?

Saar Twito11 min read
Saar Twito
Saar TwitoFounder & SEO Engineer

Hi, I'm Saar - a software engineer, SEO specialist, and lecturer who loves building tools and teaching tech.

View author profile →

What Is Largest Contentful Paint?#

Largest Contentful Paint (LCP) is a Core Web Vital that measures how long it takes for the largest visible element on your page, often a hero image, banner or main headline, to render in the viewport. It is one of Google's three Core Web Vitals, alongside Interaction to Next Paint (INP) and Cumulative Layout Shift (CLS), and it feeds your overall performance score.

Key Facts (TL;DR)

  • Thresholds: ≤ 2.5 s is good and > 4.0 s is poor, at the 75th percentile of real visits.
  • Score weight: LCP is 25% of the Lighthouse performance score; Total Blocking Time is 30%.
  • Most common causes: on sites with poor LCP, Chrome's field data shows a slow server response and a late-starting LCP image cost far more than the image download.
  • Greadme's audits: text was the LCP element on 45% of 373 pages; only 33.7% of LCP images passed all three loading conditions.
Largest Contentful Paint: the thresholds on one axisField targets at the 75th percentile of visits.

Source: web.dev, Largest Contentful Paint thresholds; marker from Greadme Page Audit, 181 mobile audits that scored below 0.9 on LCP, Jul 2025–Apr 2026.

Think of LCP the way you think of a physical store's storefront: it measures how long the window display, your main content, stays blank.

Why LCP Matters for Search and for Your Score#

LCP measures how quickly a page's main content appears, and it counts in two places:

  • Google Search: Google's page experience documentation states that “Core Web Vitals are used by our ranking systems”, and adds that Search “always seeks to show the most relevant content, even if the page experience is sub-par”. A good LCP helps most where many pages are equally helpful.
  • Performance audit score: LCP carries 25% of the Lighthouse performance score, second only to Total Blocking Time at 30%, so a slow LCP holds the whole score down.

What Elements Count as the LCP Element?#

The browser identifies the largest element visible in the viewport as the page loads. LCP tracks the following element types:

  • <img> elements — hero images, product photos, banner images.
  • <image> inside <svg> — SVG-embedded images.
  • <video> elements — the poster image or the first frame, whichever is presented first.
  • Elements with a CSS background-image — large background images that are the dominant visual.
  • Block-level text elements — <h1>, <p>, <div> with substantial text, when text is the largest element.

Chromium-based browsers leave out elements users are unlikely to see as content: elements with an opacity of 0, elements that cover the full viewport (treated as background) and low-entropy placeholder images. Nothing excludes a header, a banner or an overlay by its position, so a cookie banner can be the LCP element. In Greadme's audits it was, on 7 sites. The LCP element can also change as the page loads.

Which kind of element wins varies by sample. Across the web, the HTTP Archive Web Almanac 2025 found an image as the LCP element on 76% of mobile pages and 85.3% of desktop pages, and text on 23.7% and 14.4%. In Greadme's LCP element study of 373 Page Audits, text was the LCP element far more often: on 45% of pages, most often the page's <h1>.

How to Check Your LCP Score#

LCP is measured in two ways: lab data (a simulated, controlled test) and field data (measurements from real visitors, collected by Chrome in the Chrome UX Report, CrUX). web.dev recommends judging LCP at the 75th percentile of page loads, separately for mobile and desktop.

  • Greadme Page Audit — shows your lab LCP beside the other lab metrics and, when Google has enough data, real visitors' Core Web Vitals; it also identifies the LCP element on each page, and pairs every issue with a copy-ready prompt for your AI assistant. This is the recommended starting point.
  • Greadme Site Audit — crawls up to 1,000 pages of your site, so you can pick one page per template (product, article, listing) to test with a Page Audit. The crawl itself checks SEO, images and page structure, not speed.
  • Google Search Console → Core Web Vitals report — shows how your pages perform “based on real world usage data”, which Google says comes from the CrUX report, for mobile and desktop separately.
  • Chrome DevTools → Performance panel — opens on a Live Metrics view that shows your local LCP and the LCP element, which you can hover to highlight on the page.

What Causes Poor LCP? Industry Data and Greadme's Audits#

LCP is the sum of four parts: the time to the first byte of the HTML (TTFB), the resource load delay before the browser starts fetching the LCP image, the resource load duration of downloading it, and the element render delay before it appears. A text LCP has no resource to load, so only the first and last parts apply. Two kinds of evidence show where the time goes. They measure different things, so they are kept apart below.

Industry findings: what real Chrome users experience

Google's web.dev team analysed Chrome UX Report field data for origins whose LCP element is an image. Their article Common misconceptions about how to optimize LCP reports that “image download time is almost never the bottleneck”. For origins with poor LCP, the median time spent in each part was:

Where the time goes on sites with poor LCPMedian, across origins with poor LCP, of each origin's 75th-percentile LCP subpart. Real Chrome users (field data), image LCPs only.
  1. Time to first byte (TTFB)2.3 s
  2. Resource load delay (waiting to start the image)1.3 s
  3. Element render delay360 ms
  4. Resource load duration (downloading the image)350 ms
View the data as a table
LCP subpartMedian time
Time to first byte (TTFB)2.3 s
Resource load delay (waiting to start the image)1.3 s
Element render delay360 ms
Resource load duration (downloading the image)350 ms

Source: web.dev, Common misconceptions about how to optimize LCP (Chrome UX Report data; last updated Aug 20, 2024).

Two causes dominate. A slow server response comes first: web.dev notes that for at least half of these origins, the TTFB “alone nearly guarantees” that LCP can't reach the 2.5-second threshold. The late start comes second: “the median site with poor LCP spends almost four times as long waiting to start downloading the LCP image as it does actually downloading it.”

Web-wide crawls show why images start late. web.dev's guide to the most effective ways to improve Core Web Vitals makes discovery its first LCP recommendation (“Ensure the LCP resource is discoverable from the HTML source and prioritized”) and reports that 35% of LCP images had source URLs not discoverable in the initial HTML. The Web Almanac 2025 found that about 16% of pages lazy-load their LCP image, and that fetchpriority="high" appears on 17.3% of mobile and 16.3% of desktop pages with an LCP image.

Greadme's findings: 373 Page Audits

Greadme's LCP element study read the LCP element Lighthouse named in 373 Page Audits of 298 sites (lab measurements, May 12 to October 23, 2026: from the day Greadme began storing Lighthouse's LCP breakdown with every audit, not only when it failed, so pages whose LCP failed Lighthouse's check aren't over-counted). Of the 205 audits with an image or video LCP, only 33.7% passed all three of Lighthouse's loading conditions. 63.4% lacked fetchpriority="high", 28.8% weren't discoverable in the initial HTML, and 7.3% were lazy-loaded. Hero images set as CSS backgrounds were not discoverable 60% of the time, against 19.1% for an <img>. Lighthouse's image-delivery check also flagged 57.4% of LCP <img> elements as larger than their displayed size, in an older format or under-compressed, with a median estimated saving of 53 KiB: a possible saving in bytes, not a measure of what slowed LCP.

How the two compare

MeasureIndustry (web-wide)Greadme (373 audits)
LCP element is an image76% mobile, 85.3% desktop pages (Web Almanac 2025)55% of audits (images and videos)
LCP element is text23.7% mobile, 14.4% desktop pages (Web Almanac 2025)45% of audits
LCP image not discoverable in the initial HTML35% of LCP images (web.dev, citing the Web Almanac 2024)28.8% of LCP images
LCP image lazy-loadedAbout 16% of pages (Web Almanac 2025)7.3% of LCP images
LCP image has fetchpriority="high"17.3% mobile, 16.3% desktop pages with an LCP image (Web Almanac 2025)36.6% of LCP images
Slow server response (TTFB)The largest part of LCP on sites with poor LCP (web.dev, field data)Not part of the LCP study (Greadme Page Audit reports it separately; see fix 2)

Where they agree: late discovery and missing priority are common in both, at broadly similar rates for discovery (28.8% of LCP images in Greadme's audits, 35% in web.dev's figures). The image file is a different matter. In the field data the download is the smallest part of a poor LCP, while Greadme's audits flagged 57.4% of LCP <img> files as larger or heavier than needed (median estimated saving 53 KiB). An oversized hero is common, but a lab flag says the file could be smaller, not that its download is what makes LCP late. Where they differ: Greadme's sample has far more text LCPs, fewer lazy-loaded LCP images and more fetchpriority than the web-wide figures. The data can't say why. Greadme's audits are of pages people chose to check, 334 of 373 of them homepages and 112 run by signed-out visitors in a single week, counted once per page and device in a lab test, while the Web Almanac crawls millions of pages, so the two percentages aren't directly comparable and Greadme's sample shouldn't be read as representative of the web. The LCP study also didn't analyze TTFB, the largest part in the field data, although Greadme Page Audit records it in two separate ways: real visitors' TTFB from the Chrome UX Report, where Google has enough traffic (stored with audits from 15 October 2026 onward), and the server response time observed in the lab test. The two aren't interchangeable: one is what real visitors experienced over 28 days, the other is one request from Google's test server.

7 Ways to Improve Your LCP Score#

The first two address the causes the field data points to. web.dev's guide to optimizing LCP presents its steps “in order, starting with the optimizations that are likely to have the biggest impact”, with eliminating resource load delay first.

1. Make the LCP Image Discoverable and Prioritized

Put the LCP image in the server's HTML as an <img>, not added later by JavaScript, and mark it with fetchpriority="high". web.dev advises setting it on the image “if you think it's likely to be your page's LCP element”, and warns that setting a high priority on more than one or two images makes it unhelpful. If the hero has to be a CSS background, preload it in the <head> with fetchpriority="high" on the preload.

<!-- An <img> hero: in the HTML, eager, and marked as important -->
<img src="/hero.webp" alt="…" width="1200" height="630" fetchpriority="high">

<!-- A CSS background hero: preload it so the browser finds it early -->
<link rel="preload" as="image" href="/hero.webp" type="image/webp" fetchpriority="high">

For responsive images: Use imagesrcset and imagesizes attributes on the preload tag so the correct size is preloaded for each device.

2. Improve Server Response Time (TTFB)

LCP cannot start until the browser receives the first byte of HTML, and in the field data above TTFB is the largest part of LCP on sites with poor LCP. web.dev calls a TTFB of 800 ms or less a rough guide for most sites, and lists multiple redirects, visitors far from the server, poor networks and uncacheable responses among the possible reasons for a slow one. Use server-side caching, remove redirect chains, or serve from the edge. Greadme Page Audit shows both measures: real visitors' TTFB in its speed section when Google has enough data for your page or site, and the server response time observed in the lab test.

3. Eliminate Render-Blocking Resources

CSS and JavaScript that block rendering delay everything, including your LCP element. For a text LCP, the render delay is everything after the first byte. Inline only the critical CSS needed for above-the-fold content; defer or async-load the rest. If your page builds its content with JavaScript in the browser, the LCP element waits for that code too; web.dev notes that server-side rendering or static HTML often has an advantage for LCP.

4. Right-Size and Compress the Hero Image

Serving a 2000px image to a 375px phone wastes bytes (see how to size images properly). Use srcset and sizes to serve device-appropriate dimensions, and a modern format such as WebP or AVIF. It's worth doing, but the field data above suggests it is rarely the main bottleneck, so check discovery and server response first.

5. Use a Content Delivery Network (CDN)

A CDN serves your HTML, images and static assets from servers close to each visitor. web.dev's field-data analysis recommends it for slow TTFB, because a CDN “can get your content closer” to visitors far from your server.

6. Lazy-Load Below-the-Fold Images (Never the LCP Image)

Apply loading="lazy" to images that are not in the initial viewport. Never apply it to the LCP image: web.dev is explicit that lazy-loading the LCP image “will always lead to unnecessary resource load delay”. The mistake is less common than late discovery or a missing priority, but not rare: about 16% of pages web-wide (Web Almanac 2025) and 7.3% of LCP images in Greadme's audits.

7. Reduce Third-Party Script Impact

web.dev lists a main thread blocked by long tasks among the causes of element render delay. Analytics trackers, chat widgets and social embeds add main-thread work and network requests, so audit your third-party scripts and defer or remove those the first view doesn't need.

Common LCP Problems and Fixes#

Problem: Hero Image Takes 4+ Seconds to Load

What's happening: most often the image starts loading late (it isn't in the initial HTML, or nothing marks it as a priority), or the server responds slowly. An oversized file adds to it.

Fix: put the image in the HTML with fetchpriority="high" (or preload a CSS background), speed up the server response, then right-size and compress the file.

Problem: LCP Element Has loading="lazy"

What's happening: The LCP image was incorrectly given lazy loading, causing the browser to delay fetching it until it enters the viewport — which is too late.

Fix: Remove loading="lazy" from the LCP element. Only apply lazy loading to images below the fold.

Problem: LCP Varies Dramatically Between Visits

What's happening: Inconsistent server response times, no caching, or the LCP element is loaded dynamically via JavaScript after page paint.

Fix: Enable server-side caching, use a CDN, and ensure the LCP element is present in the initial HTML — not injected by JavaScript after load.

Problem: Mobile LCP Much Worse Than Desktop

What's happening: the image download is not usually the main difference: for origins with poor LCP, web.dev found the median image load duration only 20% slower on mobile than on desktop.

Fix: check the mobile audit for the same causes, in order: discovery and priority, server response, render-blocking resources. Then serve mobile a right-sized image with srcset.

FAQ#

What is a good LCP score?

Google defines a good LCP as 2.5 seconds or less. Scores between 2.5s and 4.0s "need improvement," and anything above 4.0s is considered poor. These thresholds apply to the 75th percentile of real-user page loads (field data), not just lab measurements.

Is LCP a Google ranking factor?

LCP is one of the three Core Web Vitals, and Google's page experience documentation says “Core Web Vitals are used by our ranking systems.” It also says there is “no single signal” and that relevance comes first: page experience helps most when many pages are equally helpful. Search Console's Core Web Vitals report, which shows how your pages do, is built from real-visitor (CrUX) data.

What is the most common cause of poor LCP?

In Chrome's field data for sites with poor LCP, a slow server response (TTFB) takes the most time, followed by the wait before the LCP image starts loading; downloading the image takes the least. In Greadme's 373 Page Audits, the most common loading problem was an LCP image without fetchpriority="high" (63.4% of LCP images), then one that wasn't discoverable in the HTML (28.8%).

What is the difference between LCP and FCP?

web.dev defines First Contentful Paint (FCP) as the time from navigation “to when any part of the page's content is rendered on the screen”, even a small logo. LCP instead “marks the point in the page load timeline when the page's main content has likely loaded”.

How much of the performance score is LCP?

In the current version of Lighthouse, LCP is 25% of the performance score. Total Blocking Time carries 30%, Cumulative Layout Shift 25%, and First Contentful Paint and Speed Index 10% each.

Can JavaScript frameworks cause bad LCP?

Yes. Client-side rendered apps (React, Vue, Angular) that inject the LCP element via JavaScript after the initial HTML is parsed often have poor LCP because the browser can't discover or preload the element early. Server-side rendering (SSR) or static generation (SSG) puts the LCP element in the initial HTML, where the browser can find it right away.

How do I find out which element on my page is the LCP element?

Run Greadme Page Audit and the report will identify the LCP element on each audited page along with its load timing. For local debugging, open Chrome DevTools and go to the Performance panel: its Live Metrics view shows the LCP element, and hovering it highlights the element on the page.

Conclusion#

LCP is a Core Web Vital and a quarter of the Lighthouse performance score. The evidence points to where the time goes: on sites with poor LCP, a slow server response and an LCP image that starts loading late cost far more than the image download. Fix discovery and priority first, then the server response and render-blocking resources, then the image itself.

Run Greadme Page Audit to identify the LCP element on each page you audit, then work through the optimizations above in order.