Learn what Core Web Vitals are, why they matter for SEO and how to improve LCP, INP and CLS performance.
Core Web Vitals are a set of Google performance metrics designed to measure how users experience a web page. They focus on three areas that matter to real visitors: how quickly the main content loads, how responsive the page feels when someone interacts with it, and whether the layout remains stable while the page loads.
For businesses, Core Web Vitals are not just a technical SEO concern. They affect user experience, conversion rates, trust, lead generation and the overall quality of your website. A slow or unstable website can frustrate visitors before they ever read your content or complete a form.
In this guide, we explain what Core Web Vitals are, why they matter, how they are measured and how to improve LCP, INP and CLS with practical optimisation techniques.
What Are Core Web Vitals?
Core Web Vitals are performance and user experience metrics created by Google to help website owners understand how real users experience their pages.
The current Core Web Vitals are:
- Largest Contentful Paint (LCP): measures loading performance.
- Interaction to Next Paint (INP): measures responsiveness.
- Cumulative Layout Shift (CLS): measures visual stability.
These metrics are part of Google’s broader page experience signals. Google provides official guidance on Core Web Vitals through web.dev and Google Search Central.
| Metric | What It Measures | Good Score |
|---|---|---|
| LCP | How quickly the main content loads | 2.5 seconds or less |
| INP | How quickly the page responds to interaction | 200 milliseconds or less |
| CLS | How visually stable the page is | 0.1 or less |
Passing Core Web Vitals does not guarantee better rankings, but poor performance can reduce user satisfaction and make your website less competitive.
Why Core Web Vitals Matter
Core Web Vitals matter because they measure the parts of website performance that users notice most.
A website can have good branding, strong content and attractive design, but if it loads slowly, shifts around or responds poorly, users may leave before converting.
Core Web Vitals affect:
- User experience
- SEO performance
- Conversion rates
- Mobile usability
- Lead generation
- Paid media performance
- Trust and credibility
- Accessibility and usability
For lead generation websites, performance is especially important. If a page takes too long to load or a form is difficult to interact with, potential enquiries can be lost.
If your website gets traffic but fails to generate enough enquiries, our guide on why your website is not generating leads explains other common causes.
Are Core Web Vitals A Ranking Factor?
Core Web Vitals are part of Google’s page experience signals. They are not usually the strongest ranking factor on their own, but they can contribute to how Google evaluates page quality and user experience.
Content relevance, authority, internal linking, technical SEO and search intent remain critical. However, if two pages are otherwise similar, the page that delivers a better user experience may have an advantage.
Core Web Vitals are also important because they affect user behaviour. Slow loading, poor responsiveness and unstable layouts can increase frustration, reduce engagement and lower conversion rates.
That means Core Web Vitals should not be treated as a box-ticking SEO exercise. They should be part of a broader website quality strategy.
For wider technical SEO issues, read our guide to technical SEO issues and how to fix them.
Largest Contentful Paint (LCP)
Largest Contentful Paint measures how long it takes for the largest visible content element on a page to load.
This is often a hero image, heading block, banner, video thumbnail or large content section above the fold.
LCP is important because it reflects when users feel that the main content of the page has loaded.
What Is A Good LCP Score?
| LCP Score | Status |
|---|---|
| 2.5 seconds or less | Good |
| 2.5 to 4 seconds | Needs improvement |
| More than 4 seconds | Poor |
Common Causes Of Poor LCP
Poor LCP is often caused by large assets, slow servers or render-blocking resources.
- Oversized hero images
- Unoptimised image formats
- Slow server response times
- Render-blocking CSS or JavaScript
- Heavy page builders or themes
- Poor caching
- Large web fonts
- Slow third-party scripts
- No CDN
How To Improve LCP
To improve LCP, focus on loading the main above-the-fold content faster.
- Compress and resize hero images.
- Use modern image formats such as WebP or AVIF.
- Preload the main hero image where appropriate.
- Improve hosting and server response times.
- Use a content delivery network.
- Remove unnecessary render-blocking CSS and JavaScript.
- Reduce plugin and theme bloat.
- Use effective caching.
- Optimise fonts and avoid loading unnecessary font weights.
- Prioritise above-the-fold content.
Interaction To Next Paint (INP)
Interaction to Next Paint measures how responsive a page feels when users interact with it.
INP looks at interactions such as clicks, taps and keyboard inputs. It measures the time between the user interaction and the next visual response from the page.
INP replaced First Input Delay as a Core Web Vital because it gives a broader view of responsiveness throughout the user session.
What Is A Good INP Score?
| INP Score | Status |
|---|---|
| 200 milliseconds or less | Good |
| 200 to 500 milliseconds | Needs improvement |
| More than 500 milliseconds | Poor |
Common Causes Of Poor INP
Poor INP is often caused by heavy JavaScript, inefficient event handling or third-party scripts.
- Large JavaScript bundles
- Too many third-party scripts
- Heavy tracking tags
- Complex forms
- Slow event handlers
- Long main-thread tasks
- Unoptimised frontend frameworks
- Excessive plugin scripts
- Poorly implemented animations
How To Improve INP
To improve INP, reduce the amount of work the browser needs to do when users interact with the page.
- Reduce unnecessary JavaScript.
- Split large JavaScript bundles.
- Remove unused scripts and plugins.
- Defer non-critical JavaScript.
- Optimise event handlers.
- Break long tasks into smaller tasks.
- Reduce third-party tracking scripts.
- Use lighter frontend components.
- Avoid unnecessary animations on interaction-heavy pages.
- Test forms, menus and key CTAs on mobile devices.
Cumulative Layout Shift (CLS)
Cumulative Layout Shift measures how much visible content unexpectedly moves while a page is loading.
Layout shift is frustrating because users may try to click something, only for the page to move and cause them to click the wrong element.
What Is A Good CLS Score?
| CLS Score | Status |
|---|---|
| 0.1 or less | Good |
| 0.1 to 0.25 | Needs improvement |
| More than 0.25 | Poor |
Common Causes Of Poor CLS
- Images without width and height attributes
- Video embeds without reserved space
- Ad slots loading late
- Cookie banners pushing content down
- Fonts causing text to reflow
- Dynamically injected content
- Late-loading banners or widgets
- Incorrect lazy loading implementation
How To Improve CLS
- Add width and height attributes to images.
- Reserve space for videos, embeds and iframes.
- Avoid injecting content above existing content.
- Use stable ad slot dimensions.
- Optimise font loading.
- Avoid late-loading banners that push content down.
- Test cookie banners and pop-ups carefully.
- Use CSS aspect ratios for responsive media.
How To Measure Core Web Vitals
You can measure Core Web Vitals using several tools. Some show lab data, while others show field data from real users.
| Tool | Best For |
|---|---|
| PageSpeed Insights | Checking individual URLs using lab and field data |
| Google Search Console | Monitoring Core Web Vitals across groups of URLs |
| Lighthouse | Testing performance in a controlled lab environment |
| Chrome DevTools | Diagnosing frontend performance issues |
| CrUX | Reviewing real-world Chrome user experience data |
PageSpeed Insights is a useful starting point, but it should not be the only tool used. Real performance needs to be checked across templates, devices, network conditions and user journeys.
For a broader list of tools, see our guide to website speed test tools.
Lab Data vs Field Data
Core Web Vitals reports often include both lab data and field data.
Lab data is collected in a controlled testing environment. It is useful for debugging and testing changes.
Field data is collected from real users. It reflects how actual visitors experience your website across devices, locations and network conditions.
| Data Type | Strength | Limitation |
|---|---|---|
| Lab data | Useful for debugging specific issues | May not reflect real users |
| Field data | Reflects real-world experience | Can take time to update |
Common Reasons Websites Fail Core Web Vitals
Large Images
Oversized images are one of the most common causes of slow loading. Hero images, banners, background images and uncompressed uploads can all damage LCP.
Too Much JavaScript
Heavy JavaScript can slow down rendering and make pages feel unresponsive. This is especially common on websites with many plugins, tracking tools or interactive components.
Poor Hosting
Slow hosting can increase server response times and delay the start of page loading. Better hosting, caching and CDN usage can make a significant difference.
Theme Or Template Bloat
Some themes and templates load far more code than necessary. This can affect LCP, INP and overall page speed.
Poor Font Loading
Large font files, too many font weights or poorly configured font loading can cause layout shifts and slow rendering.
Third-Party Scripts
Analytics tools, chat widgets, heatmaps, advertising pixels and embedded tools can all affect responsiveness and loading performance.
CMS Limitations
Some CMS setups make it difficult to control frontend output, scripts, images and templates. If your platform is limiting performance, read our guide on whether your CMS is holding your business back.
How To Improve Core Web Vitals
Improving Core Web Vitals requires a combination of technical SEO, frontend development, hosting optimisation, image optimisation and UX thinking.
Prioritise Important Pages
- Homepage
- Service pages
- Landing pages
- High-traffic blog posts
- Lead generation pages
- Product or category pages
Optimise Images
- Resize images to the dimensions actually needed.
- Use WebP or AVIF where supported.
- Compress images before upload.
- Avoid using huge desktop images on mobile.
- Lazy load non-critical images.
- Preload the main hero image where appropriate.
Reduce JavaScript
- Remove unused scripts.
- Audit third-party tags.
- Reduce plugin-generated scripts.
- Defer non-essential JavaScript.
- Split large bundles.
- Avoid unnecessary frontend libraries.
Improve Hosting And Server Response
- Use quality hosting suited to your traffic.
- Enable server-level caching.
- Use a CDN.
- Optimise database queries.
- Review PHP, CMS and server configuration.
For ongoing technical support, see our website maintenance and support services.
Optimise CSS
- Remove unused CSS.
- Minify CSS files.
- Inline critical CSS where appropriate.
- Reduce framework bloat.
- Load non-critical styles later.
Optimise Fonts
- Use fewer font families.
- Limit font weights.
- Use modern font formats.
- Preload important fonts.
- Use font-display settings carefully.
- Avoid layout shifts caused by font swaps.
How To Improve Core Web Vitals On WordPress
WordPress websites can perform well, but poor themes, excessive plugins and unoptimised media can create Core Web Vitals problems.
- Use high-quality hosting.
- Remove unnecessary plugins.
- Replace heavy plugins with lighter alternatives.
- Use caching.
- Optimise images and convert to WebP or AVIF.
- Minimise unused CSS and JavaScript.
- Review page builder output.
- Lazy load non-critical images.
- Preload key resources.
- Limit third-party scripts.
- Keep WordPress, plugins and themes updated.
If you are planning a WordPress build or rebuild, our guide to choosing a WordPress development agency explains what to look for in a technical partner.
Core Web Vitals For Headless CMS Websites
Headless CMS websites can achieve excellent Core Web Vitals, but performance still depends on implementation.
A headless architecture does not automatically guarantee fast performance. Poor frontend code, large JavaScript bundles, inefficient APIs or heavy third-party scripts can still create problems.
- Static generation where appropriate
- Server-side rendering when needed
- Image optimisation
- Code splitting
- API performance
- CDN delivery
- Reduced JavaScript bundle size
- Efficient hydration
If you are deciding between platforms, read our guide to Headless CMS vs WordPress.
Core Web Vitals Checklist
| Area | Checklist Item |
|---|---|
| LCP | Optimise the largest above-the-fold image or content block |
| LCP | Improve server response time |
| LCP | Remove render-blocking CSS and JavaScript |
| INP | Reduce JavaScript execution time |
| INP | Remove unnecessary third-party scripts |
| INP | Test forms, menus and buttons on mobile |
| CLS | Add width and height attributes to images |
| CLS | Reserve space for embeds and dynamic content |
| CLS | Review font loading and layout shifts |
| General | Use PageSpeed Insights and Search Console together |
| General | Prioritise commercially important pages first |
Common Core Web Vitals Myths
Myth 1: Passing Core Web Vitals Guarantees Rankings
Passing Core Web Vitals does not guarantee rankings. Content quality, relevance, authority and search intent remain essential.
Myth 2: Better Hosting Fixes Everything
Better hosting can help, but it will not fix oversized images, heavy JavaScript, layout shifts or poor frontend architecture.
Myth 3: A Plugin Can Fix Core Web Vitals Automatically
Plugins can help, especially on WordPress, but they cannot solve every issue. Many problems require technical review and development work.
Myth 4: Desktop Scores Are Enough
Mobile performance is often more important and more challenging. A website can perform well on desktop but poorly on mobile.
The Business Impact Of Improving Core Web Vitals
Improving Core Web Vitals can support better business outcomes because users are more likely to stay, engage and convert on a fast, stable website.
- Lower bounce rates
- Higher engagement
- More completed forms
- Improved landing page performance
- Better mobile experience
- Stronger trust and credibility
- More efficient paid traffic
Core Web Vitals should therefore be viewed as part of conversion optimisation, not just SEO.
If your website has performance, UX or conversion issues, our website audit services can help identify what is holding it back.
When To Get Professional Help
You may need professional help if Core Web Vitals issues are affecting key pages and simple fixes are not enough.
- Persistent poor PageSpeed scores
- Core Web Vitals warnings in Google Search Console
- Slow mobile performance
- Heavy JavaScript
- Complex WordPress plugin issues
- Poor hosting or caching configuration
- High-traffic pages that are underperforming
- Conversion issues on key landing pages
A proper performance audit should identify the root causes, prioritise fixes and explain which changes will have the biggest impact.
For technical implementation, our web development agency team can support performance optimisation, frontend improvements and CMS development.
Final Thoughts
Core Web Vitals measure how users experience your website. They focus on loading performance, responsiveness and visual stability.
LCP measures how quickly the main content loads. INP measures how responsive the page feels. CLS measures whether the layout stays stable.
Improving Core Web Vitals can support SEO, user experience and conversion performance, especially on mobile devices.
The best results usually come from combining technical SEO, frontend development, hosting improvements, image optimisation and UX thinking.
If your website is slow, unstable or underperforming, start by measuring your Core Web Vitals, then prioritise the changes that affect your most important pages.
