If you run a WordPress website, you have probably seen Core Web Vitals mentioned in Google Search Console, PageSpeed Insights, or another SEO tool.
You may also have seen websites obsessing over scores like 90, 95, or 100.
But the score isn’t the important part.
Core Web Vitals are designed to measure how a real person experiences a web page:
- How quickly the main content appears
- How quickly the page responds when someone interacts with it
- Whether the page moves around while loading
Google currently uses three Core Web Vitals:
- Largest Contentful Paint (LCP)
- Interaction to Next Paint (INP)
- Cumulative Layout Shift (CLS)
Each one measures a different problem.
For a WordPress website, understanding what each metric actually measures is much more useful than blindly trying to make every PageSpeed warning disappear.
What Are Core Web Vitals?
Core Web Vitals are a set of user-experience metrics used to measure important parts of website performance.
The three current metrics cover:
| Metric | Measures | Good |
| LCP | Loading | 2.5 seconds or less |
| INP | Responsiveness | 200 ms or less |
| CLS | Visual stability | 0.1 or less |
These thresholds are evaluated using real user experiences, and Google also uses laboratory tools such as Lighthouse to help developers diagnose problems.
The important thing is that these aren’t three versions of the same speed test.
A page can have a good LCP but poor INP.
It can have excellent INP but terrible CLS.
So you need to look at all three.
What Does LCP Mean?
LCP stands for Largest Contentful Paint.
It measures how quickly the largest visible content element appears in the viewport.
That element is often:
- A hero image
- A large heading
- A featured image
- A large text block
- A video poster image
A good LCP is 2.5 seconds or less. Between 2.5 and 4 seconds needs improvement, while above 4 seconds is considered poor.
Example of a Bad LCP
Imagine someone opens your homepage.
The browser spends three seconds loading:
- Fonts
- JavaScript
- CSS
- Tracking scripts
- Large images
The visitor sees very little during that time.
Then the large hero section finally appears.
If that hero section is the largest content element, it may become your LCP element.
The problem isn’t necessarily the hero itself.
The browser may simply be taking too long to get everything required to display it.
What Causes Poor LCP in WordPress?
Common causes include:
- Slow hosting
- Poor server response time
- Missing page cache
- Large hero images
- Render-blocking CSS
- Too much JavaScript
- Slow fonts
- Third-party resources
- Incorrect image loading
- Poor CDN configuration
This is why simply compressing every image isn’t always the answer.
If your server takes two seconds before it even starts sending the page, reducing a 200 KB image to 150 KB won’t solve the main problem.
How to Improve LCP
Start with the LCP element itself.
Find out what it is.
Then determine why it arrives late.
For an image, check:
- Image dimensions
- File size
- Format
- Loading priority
- Whether it is lazy-loaded
- Whether it is served from the CDN
- When the browser discovers it
For a text-based LCP element, check:
- Server response
- CSS delivery
- Web fonts
- Render-blocking resources
- HTML delivery
Don’t guess.
Find the actual LCP element first.
What Does INP Mean?
INP stands for Interaction to Next Paint.
It measures how quickly a page responds after a visitor interacts with it.
Interactions include:
- Clicking a button
- Opening a menu
- Selecting a dropdown
- Typing into a field
- Tapping an interface element
A good INP is 200 milliseconds or less. Between 200 and 500 milliseconds needs improvement, while anything above 500 milliseconds is poor.
INP replaced First Input Delay (FID) as a Core Web Vital in March 2024.
Why Can WordPress Have Poor INP?
The biggest problem is often JavaScript.
A browser has a main thread that handles a lot of the work required to make a page interactive.
If JavaScript keeps that thread busy, the browser may not respond quickly to the visitor.
Common causes include:
- Large JavaScript bundles
- Too many plugins
- Page-builder scripts
- Sliders
- Popups
- Chat widgets
- Analytics
- Advertising scripts
- Social media widgets
- Complex animations
- Long JavaScript tasks
This is why a website can look fast but still feel slow when you click something.
How to Improve INP
Start by finding the JavaScript responsible for the delay.
Don’t immediately minify everything.
Ask:
Does this script need to run on this page?
If not, remove it.
If it is necessary but not immediately required, consider delaying it.
If it performs too much work, reduce the work.
For example, if a chat widget loads immediately on every page, you could consider loading it after the main page becomes usable.
The goal is not simply to make JavaScript files smaller.
The goal is to reduce the amount of work the browser has to perform when the visitor is trying to interact with the page.
For a deeper look at this problem, see our guide on reducing browser blocking time.
What Does CLS Mean?
CLS stands for Cumulative Layout Shift.
It measures how much visible content unexpectedly moves while a page loads.
You’ve probably experienced this yourself.
You start reading an article.
Then an image appears.
The text moves down.
You go to click a button.
An advertisement loads.
The button moves.
You click something else.
That’s a poor layout experience.
A good CLS score is 0.1 or less.
What Causes CLS in WordPress?
Common causes include:
- Images without dimensions
- Ads without reserved space
- Web fonts changing text layout
- Dynamically inserted content
- Late-loading banners
- Cookie notices
- Embedded content
- Unstable page-builder elements
Images Are a Common Cause
If the browser doesn’t know how much space an image will need, it may initially render the surrounding content and then move it when the image arrives.
Make sure images have appropriate dimensions.
WordPress normally handles responsive image markup well, but your theme, plugins, or custom code can still create problems.
Fonts Can Cause Layout Shifts
A fallback font may have different dimensions from the final web font.
When the custom font loads, text can change size or line wrapping.
That can move other elements.
Font loading needs to be handled carefully if you want both fast text rendering and stable layouts.
Why Are Core Web Vitals Important?
Core Web Vitals matter because they focus on things visitors actually experience.
A technically valid website can still feel terrible if:
- The main content takes too long to appear
- Buttons don’t respond quickly
- The page jumps around
- Visitors have to wait before they can interact
Google recommends achieving good Core Web Vitals as part of providing a strong page experience. However, Google also makes clear that good Core Web Vitals alone do not guarantee good rankings.
Search rankings involve many systems and signals.
So don’t treat Core Web Vitals as a ranking shortcut.
Are Core Web Vitals a Ranking Factor?
Core Web Vitals are part of Google’s page-experience considerations, but that doesn’t mean:
“Pass Core Web Vitals = rank higher.”
Google explicitly says there is no single page-experience signal that determines rankings, and good Core Web Vitals do not guarantee good rankings.
Relevance, content quality, authority, search intent, links, technical accessibility, and many other factors still matter.
Think about Core Web Vitals as one part of building a good website.
Not as an SEO trick.
What Is the Difference Between Lab Data and Field Data?
This is one of the most important things to understand.
You can test your website with PageSpeed Insights and get a result immediately.
But real visitors may experience something different.
That’s because there are two broad types of performance data.
Lab Data
Lab data is generated in a controlled testing environment.
Tools such as Lighthouse simulate a page load and report performance metrics.
It’s useful for finding problems.
Field Data
Field data comes from real users and real browsing conditions.
Visitors may have:
- Different devices
- Different internet connections
- Different locations
- Different browsers
- Different hardware
This data shows how the website performs for actual users.
Core Web Vitals are particularly valuable because they focus on real-world user experience.
Why Does My PageSpeed Score Change Every Time?
This is normal.
Performance tests aren’t performed under identical real-world conditions every time.
Your result can change because of:
- Network conditions
- Server load
- CDN location
- Cache status
- Test device
- Test location
- Third-party services
- Resource timing
One test might show 92.
Another might show 86.
Don’t panic over a small score difference.
Look for consistent problems.
More importantly, check field data when it is available.
How to Check Core Web Vitals for WordPress
There are several useful places to look.
Google PageSpeed Insights
Enter the URL and review the performance report.
You’ll see both diagnostic information and, when available, real-user data.
Google Search Console
Search Console has a Core Web Vitals report that groups URLs based on their performance data.
This is useful because you can identify patterns across many pages rather than testing one URL at a time.
For example, you might discover that:
- Most blog posts are good
- Product pages need improvement
- Category pages have poor CLS
- A particular template has bad LCP
That is much more useful than testing only your homepage.
Chrome DevTools
DevTools lets you investigate individual resources and browser activity.
You can inspect:
- Network requests
- JavaScript execution
- Images
- Fonts
- CSS
- Long tasks
This helps you move from:
“My INP is bad.”
to:
“This JavaScript is keeping the browser busy.”
That second statement gives you something you can actually fix.
What Are the Core Web Vitals Thresholds?
The current targets are:
| Metric | Good | Needs Improvement | Poor |
| LCP | ≤ 2.5s | 2.5–4s | > 4s |
| INP | ≤ 200ms | 200–500ms | > 500ms |
| CLS | ≤ 0.1 | 0.1–0.25 | > 0.25 |
These thresholds are designed to separate good, moderate, and poor experiences.
Notice something important:
There is no 90/100 requirement in this table.
Core Web Vitals are measurements of user experience.
A PageSpeed score is a separate performance score.
Don’t confuse the two.
Core Web Vitals vs PageSpeed Score
These are not the same thing.
Core Web Vitals
Focus on:
- Loading
- Responsiveness
- Visual stability
PageSpeed Insights score
Combines several Lighthouse performance measurements into a score.
You can have a high PageSpeed score and still have a Core Web Vital problem in field data.
You can also have a lower lab score while real users have acceptable Core Web Vitals.
This is why you should look at both.
How to Fix Poor Core Web Vitals in WordPress
There isn’t one universal fix.
The correct solution depends on the failing metric.
If LCP Is Poor
Investigate:
- Server response time
- Page caching
- Main image
- CSS delivery
- Fonts
- JavaScript
- CDN
- HTML delivery
If INP Is Poor
Investigate:
- JavaScript execution
- Long tasks
- Third-party scripts
- Page-builder code
- Plugin scripts
- Event handlers
- Heavy animations
If CLS Is Poor
Investigate:
- Image dimensions
- Ads
- Fonts
- Dynamic content
- Banners
- Embeds
- Page-builder elements
Don’t apply an INP solution to an LCP problem.
That sounds obvious, but it’s one of the reasons generic optimization checklists waste time.
Do WordPress Plugins Affect Core Web Vitals?
Yes.
Plugins can affect performance by adding:
- CSS
- JavaScript
- Fonts
- Images
- Database queries
- External requests
- Dynamic functionality
But this doesn’t mean you should remove every plugin.
The better question is:
What does this plugin add to the page?
A plugin can be perfectly reasonable if its functionality is important and its performance impact is small.
Another plugin may be unnecessary and add several frontend resources.
Measure the difference before deciding.
Do Page Builders Affect Core Web Vitals?
They can.
Page builders can generate:
- Large HTML structures
- Additional CSS
- JavaScript
- Nested elements
- Extra widgets
- Multiple responsive layouts
That doesn’t mean every website using Elementor or another builder will have poor Core Web Vitals.
It means you need to pay attention to what your particular implementation generates.
A simple page built with a page builder can perform well.
A complicated page with dozens of widgets can become expensive for the browser.
Does a CDN Improve Core Web Vitals?
A CDN can help, but it isn’t a guaranteed fix.
It may reduce the distance between visitors and cached resources.
That can improve resource delivery and sometimes help loading performance.
But if your page has:
- Huge JavaScript
- Slow PHP
- Poor caching
- Massive images
- Too many plugins
a CDN won’t solve the underlying problem.
If you’re considering one, start by understanding how a CDN works and what it actually changes.
Does a Cache Plugin Improve Core Web Vitals?
It can.
Caching can reduce the work your server performs and improve how quickly pages are delivered.
A good caching setup can help with LCP and overall loading performance.
But caching does not automatically fix:
- Excessive JavaScript
- Layout shifts
- Large images
- Third-party scripts
- Poorly built pages
If your website is slow for several different reasons, caching addresses only part of the problem.
Our WordPress speed optimization guide explains how to approach the broader performance problem instead of relying on one plugin.
Should You Aim for 100 on PageSpeed Insights?
No.
You should aim for a website that loads quickly, responds properly, stays stable, and works well for real visitors.
A score of 100 isn’t the objective.
If getting from 95 to 100 requires breaking a useful feature, removing something valuable, or adding complicated optimization rules, it may not be worth doing.
Performance optimization should improve the website, not turn the website into a benchmark experiment.
A Better Way to Improve Core Web Vitals
Use this process.
1. Find the failing metric
Is it LCP, INP, or CLS?
2. Find the element or resource causing it
Don’t guess.
Use PageSpeed Insights, Search Console, Lighthouse, and DevTools.
3. Fix the largest problem first
If a huge image is responsible for poor LCP, fix that before worrying about a tiny CSS file.
4. Test again
Make one meaningful change and measure the result.
5. Check real-user data
A lab improvement is useful, but you ultimately care about how visitors experience the site.
6. Monitor after updates
A new plugin, theme update, tracking script, or page redesign can change performance.
Performance isn’t finished forever.
Core Web Vitals Checklist for WordPress
Use this as a quick review:
LCP
- Page cache is working
- Server responds quickly
- Main content is discovered early
- LCP image isn’t unnecessarily lazy-loaded
- Hero image is correctly sized
- Critical CSS is handled properly
- Fonts aren’t delaying important content
INP
- Unnecessary JavaScript is removed
- Heavy scripts are delayed where appropriate
- Long tasks are investigated
- Third-party scripts are reviewed
- Page-builder scripts are kept under control
- Interactive elements respond quickly
CLS
- Images have dimensions
- Ads have reserved space
- Fonts don’t cause major reflow
- Dynamic content doesn’t unexpectedly push content
- Popups and banners don’t shift the page
- Embedded content has reserved space
Frequently Asked Questions
What are Core Web Vitals?
Core Web Vitals are three Google performance metrics that measure loading performance, responsiveness, and visual stability: LCP, INP, and CLS.
What are the three Core Web Vitals?
The three current Core Web Vitals are Largest Contentful Paint (LCP), Interaction to Next Paint (INP), and Cumulative Layout Shift (CLS).
What is a good LCP score?
A good LCP is 2.5 seconds or less at the relevant 75th-percentile threshold.
What is a good INP score?
A good INP is 200 milliseconds or less.
What is a good CLS score?
A good CLS is 0.1 or less.
Are Core Web Vitals a ranking factor?
Core Web Vitals are part of Google’s page-experience considerations, but passing them does not guarantee higher rankings. Google evaluates many signals when ranking pages.
How do I check Core Web Vitals?
Use Google PageSpeed Insights for individual pages and Google Search Console’s Core Web Vitals report for broader site-level URL groups. You can also use Chrome DevTools to investigate the resources causing performance problems.
Can a WordPress plugin fix Core Web Vitals?
A performance plugin can help with caching, CSS, JavaScript, and other optimizations, but there is no plugin that automatically fixes every Core Web Vitals problem. The correct fix depends on the failing metric and its cause.
Final Answer
Core Web Vitals are not simply three numbers you need to make green.
They tell you where the user experience is going wrong:
LCP: How quickly the main content appears.
INP: How quickly the page responds to interaction.
CLS: How stable the page remains while loading.
Once you understand that, optimization becomes much easier.
Don’t start by installing plugins.
Don’t start by chasing a PageSpeed score.
Start by finding the failing metric, identify what is causing it, fix that specific problem, and then measure again.
That approach produces a faster WordPress website without turning performance optimization into a never-ending checklist.