Core Web Vitals become useful when you stop treating them as a score to polish and start treating them as evidence of what visitors experience. I want the main content to arrive promptly, buttons to respond when pressed, and the page to stay still while somebody reads it. Those are practical requirements, not just technical SEO boxes.
In this tutorial, I will show you how I measure Largest Contentful Paint, Interaction to Next Paint and Cumulative Layout Shift, identify the underlying causes, and check whether a fix actually worked. I will also explain why a green laboratory report can sit beside a failing real user assessment without either report being broken.
Quick answer: measure real users, then diagnose
Start with field data to establish the problem, use laboratory tools to investigate it, and validate the release with both. Core Web Vitals describe loading, responsiveness and visual stability. They do not describe every aspect of performance, and passing them does not guarantee rankings, conversions or a good website.
| Metric | What it measures | Good threshold | Typical investigation |
|---|---|---|---|
| LCP | When the largest eligible visible content element renders | 2.5 seconds or less | Server response, resource discovery and rendering |
| INP | Responsiveness across qualifying interactions | 200 milliseconds or less | Long tasks, event handling and presentation delay |
| CLS | Unexpected layout movement, calculated using session windows | 0.1 or less | Missing dimensions, late content and font changes |
Assessment uses the 75th percentile of visits, with mobile and desktop considered separately. For a group to pass the Core Web Vitals assessment, all three metrics need to meet their good thresholds. Do not confuse a Lighthouse performance score with that assessment: they are different measurements built from different inputs.
Step 1: establish a reliable baseline
I begin with Google Search Console to see which URL groups have issues and which device category is affected. Groups help prioritise template problems, but they do not prove that every individual URL behaves identically. I choose representative pages from each important template, including products, categories, articles and key landing pages.
Next, I inspect those URLs in PageSpeed Insights. Its field section can show URL data or broader origin data when URL coverage is unavailable. Read that distinction carefully. An origin result describes an aggregation across the site, not necessarily the specific page you pasted into the tool.
Separate historical evidence from immediate tests
Chrome UX Report data reflects a rolling collection period rather than a test performed at the moment you open the report. A deployment today will not instantly replace the historical experience. Conversely, a fast test today does not prove last month's visitors had a fast experience.
Where traffic and privacy requirements allow, I also use real user monitoring to segment performance by template, device, geography and navigation type. Record the measurement library and implementation details. Different collection methods can produce differences, so compare like with like instead of treating every dashboard as interchangeable.
- Record the tested URL, device category and date.
- Note whether field data represents the URL or origin.
- Save the current metric distribution, not just a pass label.
- Record recent releases, consent behaviour and third party changes.
For a closer explanation of the reports, use my PageSpeed Insights guide. The important point here is to write a baseline you can repeat rather than collect screenshots nobody will revisit.
Step 2: reproduce the problem consistently
Laboratory testing lets me control conditions and inspect a trace. I test a representative mobile experience, then repeat the run because individual results vary. Browser extensions, background activity, network conditions and cache state can all change what appears to be a simple before and after comparison.
Use the same browser setup, viewport, throttling approach and test location when comparing changes. Separate a cold first visit from a repeat visit. Both matter, but mixing them can make a caching improvement look like a universal improvement when it only helps returning visitors.
Test journeys, not just initial loads
A page can load reasonably and then become unpleasant when somebody opens navigation, chooses a variant or accepts cookies. Record a performance trace while carrying out those actions. Test the consent state your visitors actually encounter, including the moment third party scripts become eligible to run.
A standard Lighthouse navigation run does not measure a full visit's INP. Total Blocking Time can expose main thread pressure in a laboratory setting, but it is not INP under another name. I use it as a diagnostic signal, then test interactions directly and compare them with field measurements.
Keep a small test matrix rather than chasing every URL. For example, an illustrative shop might test a category filter, a product variant selector and an add to basket action. That covers different interaction patterns without pretending that one homepage run represents the whole business.
Step 3: find and fix the LCP bottleneck
First identify the LCP element in a performance trace. It might be a hero image, a heading or another eligible content block. Do not assume the largest image file is the measured element. The element can also change between screen sizes, page states and loading sequences.
I break the investigation into server response, resource discovery, resource download and the delay before the browser can render the element. Improving the wrong part wastes time. Compressing an image will not solve a long wait before the browser even discovers its address.
Get the main response moving
If the initial document is slow, investigate application work, database queries, cache misses, redirects and network distance. Appropriate caching and a content delivery network can help, but neither fixes every slow origin. Check personalised responses carefully so performance work does not leak account information or serve the wrong content.
Make the important resource discoverable
For a likely above the fold LCP image, prefer an image reference the browser can discover in the initial HTML. Avoid lazy loading that critical image. Consider fetch priority hints where appropriate, and use preloading selectively when the normal discovery path is genuinely late. Too many high priority resources compete with one another.
Serve suitable image dimensions and use responsive image markup so small screens do not download unnecessarily large files. Choose an efficient format supported by your audience, but preserve acceptable quality. Check the actual selected resource in browser tools rather than assuming the markup produces the intended download.
Remove unnecessary rendering delays
A downloaded image can still wait behind styles, scripts or hidden states. Inspect render blocking CSS, scripts that change visibility, and components that wait for hydration before showing useful content. Keep essential styling available without forcing the whole design system into the critical path.
Change one identifiable bottleneck at a time when possible. If the trace shows a faster resource download but unchanged LCP, investigate the remaining delay instead of declaring the optimisation a failure or adding more preloads blindly.
Step 4: improve interaction responsiveness
INP describes responsiveness using qualifying interactions across a page visit. It considers the delay before an event handler runs, time spent processing the interaction, and the delay before the next paint. That means a button can feel slow even when its own handler is short, because unrelated work is occupying the main thread.
I reproduce the slow action while recording a browser performance trace. Then I identify what was running before, during and immediately after the interaction. Look for large script execution tasks, expensive component updates, repeated layout calculations and third party code that runs at awkward moments.
Reduce work before distributing work
Remove unnecessary JavaScript and duplicate integrations before trying clever scheduling. Smaller bundles may help loading, but responsiveness also depends on what the downloaded code does. A small script that repeatedly rebuilds a large interface can still cause a poor experience.
Break long tasks into smaller units where the application permits it, and yield to the browser between nonessential chunks. Move suitable computation to a worker when the work does not require direct access to the document. These approaches need engineering judgement: splitting a task incorrectly can create race conditions or inconsistent state.
Give immediate, meaningful feedback after an action. A loading state can show that a request started, but it must not disguise a broken workflow. Keep expensive follow up work out of the initial response where possible, and prevent repeated clicks from triggering duplicate requests.
For filters and search interfaces, avoid rerendering everything on every keystroke without need. Debouncing can reduce repeated work, but excessive delay makes the control feel unresponsive. Test with realistic content volumes, not an empty development database that hides the expensive behaviour.
Step 5: stop unexpected layout shifts
CLS captures unexpected movement, using session windows rather than simply adding every shift across an entire visit. Some shifts shortly after user input are excluded under the metric's rules, but that is not permission to create an unstable interface. People still notice controls moving away from their pointer.
My first checks are media dimensions and reserved space. Give images intrinsic width and height where appropriate, or otherwise reserve their aspect ratio. Reserve realistic space for embeds, adverts and asynchronously loaded components. A placeholder should resemble the eventual layout rather than collapse to nothing.
Check fonts, banners and dynamic content
Font changes can alter line lengths and push everything below a heading. Review fallback fonts, loading behaviour and font metrics. Test the visual result on a clean cache, because a locally cached font can hide the shift you are trying to diagnose.
Cookie notices, promotional strips and account messages can introduce movement when inserted above existing content. Decide whether space should be reserved or whether another presentation is more appropriate. Do not solve the metric by covering important content with an inaccessible overlay.
Use layout shift visualisation and the performance trace to locate the source. The element that moved is not always the element that caused the movement. A paragraph jumping down may be the victim of an image expanding higher on the page.
Test beyond the first screen. Scroll through long articles, open accordions and trigger recommendations. Lazy loaded content near the viewport can create shifts later in the visit, which a short initial loading test may miss entirely.
Step 6: prioritise and validate releases
I prioritise a shared template fault affecting valuable journeys before an isolated cosmetic improvement. Combine performance evidence with page importance and implementation risk. A global navigation script deserves different attention from an unused widget on a legacy page.
Write an acceptance criterion for each change. Instead of saying “improve mobile speed”, specify that the main product image should be discoverable in the initial response, or that opening the menu should no longer trigger the identified long task. That gives the developer something concrete to verify.
After deployment, repeat the controlled tests and check important functionality. Then monitor real user trends as fresh visits accumulate. Segment results where possible: an improvement on one template can disappear inside an origin average if other templates remain unchanged.
Keep a release annotation and a rollback plan. Performance work can damage analytics, accessibility, checkout or personalisation if scripts are removed without understanding their purpose. I want a faster working website, not a fast blank page.
My wider technical SEO audit process puts these findings alongside crawling and indexing issues. Performance deserves attention, but an inaccessible or nonindexable landing page has a different and more immediate problem.
Core Web Vitals implementation checklist
- Choose representative templates and important user journeys.
- Record field data separately for mobile and desktop.
- Check whether each field report describes a URL or origin.
- Repeat laboratory tests under consistent conditions.
- Identify the actual LCP element and its loading breakdown.
- Trace slow interactions rather than guessing from bundle size.
- Inspect layout shifts throughout realistic journeys.
- Agree specific engineering changes and acceptance criteria.
- Test functionality, accessibility and tracking after deployment.
- Monitor new field data and retain release notes.
I keep this checklist with the ticket rather than in a separate report nobody opens. Include the affected template, a reproduction path and the evidence supporting your diagnosis. A developer should not need to recreate your entire investigation before understanding the request.
Before closing a performance ticket, I also check the next likely regression source. If editors regularly upload oversized hero images, document the required dimensions and update the publishing workflow. If a marketing integration caused the long task, agree how future integrations will be assessed. Otherwise, the same fault can return in the next campaign. Add lightweight monitoring to the templates you changed and give somebody responsibility for reviewing it. Performance is easier to maintain when ownership is clear, the baseline is recorded, and the team knows which changes require another test. That is more useful than a one off optimisation exercise.
Common mistakes that waste optimisation time
Chasing a perfect score instead of a better experience is the biggest mistake I see. A score is a useful diagnostic summary, not the commercial objective. Do not remove necessary functionality simply because it changes a synthetic result.
Another mistake is installing several optimisation plugins that all rewrite the same assets. Conflicting cache, minification and script delay settings can break the page or produce inconsistent results. Establish which layer owns each responsibility and test the generated output.
Do not assume desktop success proves mobile success. Different hardware, networks and layouts change the bottleneck. Likewise, a fast homepage does not clear a slow product template, and a logged out test does not represent a signed in dashboard.
Finally, avoid promising a ranking increase from passing Core Web Vitals. Page experience matters, but search visibility also depends on relevance, content, links and other technical conditions. Report the performance improvement you measured, and keep any ranking attribution appropriately cautious.
Core Web Vitals FAQ
Why does PageSpeed Insights disagree with Search Console?
Check the reporting period, device category and whether the data applies to a URL, an origin or a group of similar URLs. Also separate laboratory results from real user data. Those differences often explain the apparent disagreement without either tool being wrong.
Can I measure INP without real visitors?
You can investigate responsiveness by interacting with the page while recording performance data. However, a controlled session is not a substitute for the distribution of real visits. Use laboratory interaction testing to diagnose, and field measurement to understand actual experience.
Should every image use lazy loading?
No. Images well below the initial viewport are good candidates, but lazy loading a likely LCP image can delay its discovery or request. Review placement, resource priority and actual browser behaviour rather than applying one setting to every image.
How quickly will a fix appear in field reports?
Historical field reports need new visits and time before they fully reflect a release. Your own monitoring may show emerging changes sooner, depending on traffic and reporting setup. Use immediate laboratory checks alongside longer term field validation rather than expecting an instant replacement.
Do good Core Web Vitals guarantee better rankings?
No. They support a better page experience, but they do not override relevance or solve indexing problems. I treat them as one part of maintaining a useful website. If you need help deciding which technical issues deserve attention first, see my SEO audit service.

