Largest Contentful Paint (LCP) measures when the largest eligible image, text block, or video in the visible viewport has rendered, counted from the beginning of navigation. It is a Core Web Vital intended to approximate when a page’s main content becomes visible. Google’s current “good” target is 2.5 seconds or less at the 75th percentile (p75), measured separately for mobile and desktop.
What LCP measures
LCP is not the same as total page-load time, time to first paint, or time to interactive. The browser tracks eligible content in the initial viewport while the page loads. Candidate elements can change, so the final LCP element may be a later, larger element rather than the first content that appeared.
Eligible candidates generally include prominent images, poster images, video frames, background images loaded through CSS, and large blocks of text. LCP includes navigation-related time such as redirects, connection setup, and server response. That is why a real-user result can be slower than a warm, local test.
LCP thresholds: good, needs improvement, and poor
Google’s guidance evaluates the 75th percentile of visits, not an individual fastest or slowest load. Segment the result by device category because mobile and desktop experiences differ.
Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minuteWindows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstall#1 Best Overall
- Used Book in Good Condition
| p75 LCP | Google classification | Meaning |
|---|---|---|
| 2.5 seconds or less | Good | The recommended user-experience target. |
| More than 2.5 and up to 4.0 seconds | Needs improvement | Some visitors wait noticeably for the main content. |
| More than 4.0 seconds | Poor | The main content is arriving too late for a reliable experience. |
These are metric guidance thresholds, not a promise that every visitor will see the same timing. Definitions and browser implementations can receive updates, so check current Google documentation when maintaining a monitoring program.
Measure LCP with field and lab data
Use field data to learn what real visitors experience, then use lab tools to reproduce and explain the problem. Neither type replaces the other.
Field measurement: the outcome for real users
- PageSpeed Insights: view Chrome User Experience Report (CrUX) data when the page has sufficient coverage.
- Chrome DevTools: inspect available CrUX information while working on a page.
- Search Console: review the Core Web Vitals report across groups of URLs.
- Site RUM: collect your own real-user segments with the
web-vitalsJavaScript library.
CrUX is anonymized measurement from real Chrome users. URL-level data may be unavailable; PageSpeed Insights can then show origin-level data. Treat an origin result as an approximation, because it can differ from the specific page. Always compare mobile with desktop and, where available, your own RUM segments.
Rank #2
RUM implementation details
The web-vitals library is the practical wrapper around browser APIs because it handles important metric details. A direct implementation must account for backgrounded pages, back-forward-cache restores, iframe content, and prerendered pages whose timing should begin at activation. These cases can make in-page measurements differ from CrUX.
Lab measurement: the explanation for a problem
Use Lighthouse, Chrome DevTools Performance, or WebPageTest to identify the LCP element, its network request, and the timing gaps around it. Controlled tests are useful during development and in CI, but they can differ from visitors’ devices, networks, locations, cache states, redirects, and personalized content. Compare a lab result with the corresponding field result before choosing a fix.
Break LCP into four bottlenecks
The optimization guide from the Chrome team divides LCP into four consecutive parts. Together they add up to the final LCP time.
Rank #3
| Component | What it covers | Typical investigation |
|---|---|---|
| TTFB | Navigation start until the first byte of the HTML response. | Server distance, redirects, cache misses, and response generation. |
| Resource load delay | From the first HTML byte until the LCP resource begins loading. | Late discovery, CSS or JavaScript dependency, or low request priority. |
| Resource load duration | Time spent downloading the LCP image or other resource. | Excessive bytes, unsuitable dimensions, format, or slow delivery. |
| Element render delay | From resource completion until the element is painted. | Render-blocking CSS, JavaScript work, or a busy main thread. |
Find the longest measured part before changing code. Improving a shorter part may leave total LCP nearly unchanged when another component is the constraint.
Diagnose the timing pattern
High TTFB
Check for multiple redirects, a server far from visitors, cache misses, query parameters that defeat caching, and other slow response paths. A high TTFB consumes so much of the 2.5-second budget that the target can become difficult or impossible to reach without fixing delivery first.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Large TTFB-to-FCP gap
If the first HTML byte arrives but First Contentful Paint follows much later, inspect render-blocking assets and substantial client-side rendering work.
Large FCP-to-LCP gap
If something paints quickly but the final LCP arrives late, look for late discovery of the LCP resource, JavaScript-managed content, or rendering work that delays the final element.
How to improve LCP
After identifying the LCP element and its timing breakdown, apply the fix that matches the measured bottleneck.
Reduce TTFB
- Remove unnecessary redirects, especially chains before the document response.
- Place content and origin infrastructure closer to major visitor populations where practical.
- Fix cache misses and cache-busting query parameters that prevent reusable responses.
- Investigate slow server-side rendering, database work, and other response-generation paths.
Reduce resource load delay
- Make the likely LCP resource discoverable in the initial HTML whenever possible.
- Do not apply
loading="lazy"to an above-the-fold LCP image. - Consider
fetchpriority="high"for the single important LCP image; do not mark many images high priority. - Preload a resource only when it cannot be discovered early through HTML and the preload is justified.
- Verify request priorities and discovery timing in the DevTools network waterfall.
Reduce resource load duration
- Serve an image at dimensions appropriate for the rendered slot rather than downloading an oversized original.
- Compress the resource and choose a suitable modern image format when browser support and content allow.
- Check delivery from the image’s actual origin, not just the page’s HTML response.
Image compression is not a complete LCP strategy. In a Chrome field-data analysis, the majority of poor-LCP origins spent less than 10% of p75 LCP downloading the LCP image. That finding describes the analyzed origins, not every website; compression helps most when download duration is the measured bottleneck.
Recommended Free Tools
Best Value
Reduce element render delay
- Remove or defer unused and non-critical CSS.
- Reduce render-blocking styles and synchronous scripts in the document head.
- Break up long main-thread tasks and avoid waiting for JavaScript before exposing the main content.
- Use server rendering or static generation when it makes the LCP content and resource URL available earlier, while checking whether the rendering approach increases TTFB.
Use reported subparts as clues, not budgets
A Chrome field-data analysis reported these median p75 subparts for origin groups. They are descriptive values from that analysis, not universal targets or an optimization budget.
| LCP bucket | TTFB | Image load delay | Image load duration | Render delay |
|---|---|---|---|---|
| Good | 600 ms | 350 ms | 160 ms | 230 ms |
| Needs improvement | 1,360 ms | 720 ms | 270 ms | 310 ms |
| Poor | 2,270 ms | 1,290 ms | 350 ms | 360 ms |
The pattern shows why response time and late discovery can dominate poor experiences even when image transfer itself is relatively short.
A repeatable LCP workflow
- Establish the field result. Check CrUX in PageSpeed Insights, DevTools, or Search Console, and segment mobile and desktop. Use origin data cautiously when URL data is missing.
- Confirm with your own RUM. If you operate the site, collect LCP by page, device, connection, geography, and template with
web-vitals. - Reproduce in a lab. Run Lighthouse, DevTools Performance, or WebPageTest and identify the final LCP element and its request.
- Calculate the four parts. Separate TTFB, resource load delay, resource load duration, and element render delay.
- Fix the largest constraint. Change server delivery, discovery and priority, bytes, or rendering work according to the measured part.
- Retest the waterfall. Rerun controlled diagnostics and confirm that the intended timing component changed.
- Verify in the field. Wait for representative real-user data and check whether p75 improved on both relevant device categories.
Choosing the right measurement method
| Method | Best use | Main limits |
|---|---|---|
| CrUX through PageSpeed Insights, DevTools, or Search Console | Determine whether real Chrome users meet the target. | URL-level data may be unavailable; distinguish page from origin and mobile from desktop. |
Site RUM with web-vitals |
Analyze your own visitors and custom segments. | Requires instrumentation, data collection, and careful handling of lifecycle edge cases. |
| Lighthouse, DevTools, or WebPageTest | Reproduce causes and test changes before release. | Controlled devices, networks, caches, locations, redirects, and content may not match real users. |
The practical division is simple: field data tells you whether visitors have a problem; lab data helps you find the code or delivery step causing it.
Quick Recap
Common LCP mistakes
- Optimizing total page load instead of the LCP element: a page can finish loading many secondary resources while its main content is still delayed.
- Using only a lab score: a repeatable test cannot represent every visitor’s network, device, cache, or location.
- Compressing every image first: if TTFB, discovery, or render delay is longer, fewer image bytes may not change LCP materially.
- Lazy-loading the hero image: delaying the likely LCP resource directly increases resource load delay.
- Preloading or prioritizing too many resources: competing high-priority requests can delay the resource that matters most.
- Reading origin data as page data: an origin aggregate can hide a slow template or URL.
- Declaring success after a single run: verify the change with field data over time at p75.
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
