SpeeJax Header
SpeeJax logo SpeeJax

Core Web Vitals Explained: Improving Website Performance in 2026

Website performance affects how quickly visitors see content, how smoothly they interact with pages, and whether the layout remains stable while loading. A website can look attractive and contain useful information yet still frustrate visitors because images load slowly, buttons respond late, or page elements suddenly move.

Google’s Core Web Vitals provide a way to measure these aspects of the user experience using real-world performance data. In 2026, the three Core Web Vitals remain Largest Contentful Paint (LCP), Interaction to Next Paint (INP), and Cumulative Layout Shift (CLS).

Improving these metrics involves more than achieving a high score in a speed-testing tool. Website owners need to understand what each metric measures, identify the technical causes of poor performance, and test improvements using both simulated tests and real-user data.

What Are Core Web Vitals?

Core Web Vitals are a group of user-experience metrics developed by Google to evaluate three important aspects of website performance: loading speed, interactivity, and visual stability.

They help website owners understand whether visitors can access the main content quickly, interact with page elements without unnecessary delays, and browse without unexpected changes to the layout.

The three metrics measure different performance characteristics:

  • Largest Contentful Paint (LCP): Measures how quickly the largest visible content element appears.
  • Interaction to Next Paint (INP): Measures how quickly a page responds to user interactions.
  • Cumulative Layout Shift (CLS): Measures unexpected movement of visible page elements.

Google recommends achieving good results for all three metrics at the 75th percentile of page visits, evaluated separately for mobile and desktop experiences.

Core Web Vitals thresholds in 2026

The following are the established Google performance thresholds.

MetricGoodNeeds ImprovementPoor
LCP2.5 seconds or lessMore than 2.5 to 4 secondsMore than 4 seconds
INP200 milliseconds or lessMore than 200 to 500 millisecondsMore than 500 milliseconds
CLS0.1 or lessMore than 0.1 to 0.25More than 0.25

A page needs to meet the good threshold for each metric to provide a good Core Web Vitals experience. A strong LCP result does not compensate for poor interactivity or visual stability.

These measurements also need to be understood at the 75th percentile rather than through an isolated test. For example, a good LCP at the 75th percentile means that at least 75% of measured page visits have an LCP of 2.5 seconds or less.

1. Largest Contentful Paint (LCP): Measuring Loading Performance

Largest Contentful Paint measures how quickly the largest visible content element renders within the visitor’s viewport.

This element is commonly a prominent image, video poster, or large block of text. On a business website, it might be the homepage hero image. On an article page, it could be the main heading or featured image.

LCP is useful because it provides an indication of when visitors can see the primary content they came to access.

What causes poor LCP?

Several technical problems can delay the appearance of the largest content element.

Slow server response times: When a web server takes too long to deliver the initial HTML document, the browser has to wait before it can begin processing the page. This delays subsequent loading activities.

Large image files: Oversized hero images and unoptimized featured images can take longer to download, particularly on slower mobile connections.

Render-blocking resources: Certain CSS and JavaScript resources can delay the browser from displaying the content.

Late discovery of important images: If the browser discovers the main image only after processing JavaScript or external stylesheets, the resource may start downloading later than necessary.

Excessive third-party scripts: Advertising scripts, tracking tools, chat widgets, and external integrations can compete for network and browser resources.

How to improve LCP

Improving LCP begins with identifying the element responsible for the measurement and determining where its loading time is being spent.

Improve server response time.

Use appropriate server-side caching, database optimization, efficient application code, and a suitable hosting environment. A content delivery network can also help deliver resources closer to visitors. Server-side rendering or static generation may help websites that otherwise depend heavily on client-side JavaScript before showing their main content.

Optimize important images.

Compress large images without unnecessarily sacrificing visual quality. Use modern formats such as WebP or AVIF where appropriate, and deliver responsive image sizes so mobile visitors do not download unnecessarily large desktop assets.

Prioritize the main content image.

When the LCP element is an image, make it discoverable early in the HTML. Avoid applying lazy loading to the main above-the-fold LCP image because this can delay its download.

Where appropriate, use the fetchpriority=”high” attribute or a preload hint for the critical image. These techniques should be applied selectively rather than assigning high priority to multiple competing images.

Reduce render-blocking resources.

Review stylesheets and JavaScript files that prevent the browser from rendering important content. Remove unused code, reduce unnecessary dependencies, and defer nonessential scripts when their functionality is not required for the initial display.

Control third-party resources.

Load only the external scripts that provide meaningful value. Delay nonessential analytics, marketing integrations, and widgets when doing so does not interfere with their required functionality.

A useful diagnostic approach is to examine the four components of LCP: time to first byte, resource load delay, resource load duration, and element render delay. This helps identify whether the problem originates from the server, resource discovery, downloading, or browser rendering.

2. Interaction to Next Paint (INP): Measuring Responsiveness

Interaction to Next Paint evaluates how quickly a website responds visually after a visitor interacts with it.

These interactions can include clicking a button, selecting a menu item, tapping a navigation element, or entering information into an interactive form.

A page might appear fully loaded but still feel unresponsive when a visitor tries to use it. For example, clicking a product filter might produce no immediate visual response because the browser is busy executing JavaScript.

INP helps identify these problems by evaluating qualifying interactions throughout a page visit rather than focusing only on the first interaction.

What causes poor INP?

JavaScript execution is one of the common causes of poor interaction responsiveness.

When too much JavaScript runs on the browser’s main thread, the browser may be unable to process new input promptly.

Other causes include:

  • Long-running event handlers.
  • Excessive JavaScript execution during page initialization.
  • Large DOM structures that make rendering more expensive.
  • Complex animations and layout calculations.
  • Heavy third-party scripts.
  • Unnecessary work triggered by repeated user interactions.

INP is influenced by three parts of an interaction:

  1. Input delay: The time between the user’s action and the beginning of the event callbacks.
  2. Processing duration: The time required to execute the associated event callbacks.
  3. Presentation delay: The time the browser needs to render and display the next frame containing the visual response.

Understanding these components makes it easier to identify the actual source of an interaction delay.

How to improve INP

Reduce unnecessary JavaScript.

Remove unused scripts, reduce oversized JavaScript bundles, and load nonessential functionality only when required. Code splitting can help prevent every page from downloading and executing scripts that it does not need.

Break up long-running tasks.

Avoid making the browser execute large blocks of JavaScript without allowing it to process other work. Break complex operations into smaller tasks and yield to the main thread so the browser can respond to incoming interactions.

Simplify event handlers.

Keep click, tap, and keyboard event callbacks as lightweight as possible. Expensive processing can often be moved outside the immediate interaction handler or performed asynchronously.

Use web workers for suitable tasks.

Computationally intensive operations that do not require direct access to the DOM can sometimes be moved to web workers. This reduces the amount of work performed on the main browser thread.

Improve rendering efficiency.

Avoid unnecessary DOM updates, repeated layout calculations, and expensive visual changes. Large or complex page structures can make browser rendering more demanding.

Provide immediate visual feedback.

When a visitor clicks a button or submits a form, the interface should communicate that the action has been received. Loading indicators, button states, and appropriate progress feedback can make interactions easier to understand, although visual feedback alone does not replace the need to improve the underlying interaction latency.

INP optimization requires testing actual user interactions. A page that loads quickly may still have poor responsiveness when visitors use its menus, filters, search functions, forms, or other interactive components.

3. Cumulative Layout Shift (CLS): Measuring Visual Stability

Cumulative Layout Shift measures unexpected movement of visible page content.

Imagine opening an article and beginning to read the first paragraph. A few seconds later, an advertisement loads above the text, pushing the content downward. You lose your place and have to find the paragraph again.

This is a visual stability problem.

Unexpected layout shifts can also cause visitors to click the wrong button, select an unintended link, or interact with an element that moved while the page was loading.

Unlike LCP and INP, CLS is a unitless score rather than a measurement in seconds or milliseconds.

What causes poor CLS?

Images without defined dimensions: When an image loads without reserved space, the browser may initially render surrounding content without accounting for its final size.

Advertisements and embedded content: Advertisements, video players, maps, and third-party widgets may expand after the initial page rendering and push existing content out of position.

Dynamically inserted elements: Promotional banners, notification bars, and other components can cause layout changes when they appear above existing content.

Web font loading: Replacing a fallback font with a downloaded web font can change text dimensions, line breaks, and element heights.

How to improve CLS

Specify image and video dimensions.

Include width and height attributes on images and video elements where appropriate. CSS aspect-ratio can also reserve the necessary space before media finishes loading.

For example:

<img

  src=”featured-image.webp”

  width=”1200″

  height=”675″

  alt=”Featured article image”

>

The browser can use these dimensions to calculate the image’s aspect ratio and allocate the required space during layout.

Reserve space for advertisements.

If a page contains advertising placements, define appropriate dimensions or minimum container heights before the advertisement loads. This prevents late-loading content from unexpectedly pushing other elements downward.

Allocate space for embeds and widgets.

Reserve the expected display area for video players, social media embeds, maps, and other external components. Where possible, use fixed aspect ratios or appropriately sized containers.

Manage font loading.

Use suitable fallback fonts and minimize differences between fallback and web font metrics. Critical fonts can be loaded early where appropriate, and CSS font metric overrides can help reduce layout changes when fonts are replaced.

Avoid inserting content above existing elements.

When promotional messages or dynamically generated content need to appear, consider whether they can be displayed in an already reserved area or positioned without displacing content the visitor is using.

Improving CLS is particularly important for article pages, ecommerce product pages, landing pages, and websites containing advertising or multiple embedded components.

How to Measure Core Web Vitals in 2026

Measuring performance correctly is just as important as making technical improvements. Website owners should use both field data and laboratory testing because the two methods provide different information.

Google PageSpeed Insights

PageSpeed Insights is a practical starting point for evaluating individual webpages.

Enter a URL to receive performance information for mobile and desktop environments. The report provides two types of data:

  • Field data: Real-user performance information from the Chrome User Experience Report (CrUX), when sufficient data is available.
  • Lab data: A controlled performance test generated through Lighthouse, including diagnostic information and optimization recommendations.

The field data helps show how visitors have experienced the page. The laboratory results help developers identify potential technical problems under controlled conditions.

PageSpeed Insights uses a trailing 28-day collection period for CrUX field information. A recently published page or a page with insufficient real-user samples may not have individual URL-level data. In that situation, the tool may show origin-level information instead, when available.

Google Search Console

Google Search Console includes a dedicated Core Web Vitals report based on real-world usage data.

It organizes URLs into groups with similar performance characteristics and identifies whether their reported experience is Good, Needs Improvement, or Poor.

The report separates mobile and desktop performance, allowing website owners to identify problems that affect one device category more severely than another.

This is particularly useful for larger websites where manually testing every URL would be impractical.

Search Console does not necessarily display every indexed URL. Pages or URL groups without sufficient reporting data may be omitted or represented by higher-level origin groups.

Chrome DevTools

Chrome DevTools provides more detailed diagnostic information for developers.

Its Performance panel can help identify layout shifts, expensive JavaScript operations, slow rendering, and long-running tasks.

Developers can also inspect network activity to understand when important resources begin loading and whether a script or stylesheet is delaying the page.

These diagnostics are particularly useful when a PageSpeed Insights report identifies a problem but does not provide enough information to locate its underlying cause.

Real User Monitoring

Real User Monitoring (RUM) involves collecting website performance measurements from actual visitors.

Developers can use the JavaScript web-vitals library to collect relevant metrics and send the information to an analytics or monitoring system.

RUM is useful for understanding differences between devices, browsers, page templates, and user experiences.

It can also help identify problems that appear only after visitors interact with a page, such as layout shifts caused by dynamically loaded content or poor responsiveness triggered by a particular interface component.

Field Data vs. Lab Data: Why Both Matter

One of the most important distinctions in website performance testing is the difference between field data and laboratory data.

CharacteristicField DataLab Data
Measurement environmentReal visitor experiencesControlled simulation
Main purposeUnderstand actual performanceDiagnose technical issues
Device conditionsVary across real usersSimulated device conditions
Network conditionsVary across real usersControlled test conditions
Useful forMonitoring actual experienceTesting and debugging improvements

A laboratory test might show that a page has a strong performance score, but real visitors could experience slower loading because of older smartphones, weaker network connections, or additional scripts that are not triggered during the test.

There is another important distinction concerning INP. A laboratory test without user interactions cannot directly measure actual INP because the metric requires interaction data. Lighthouse uses Total Blocking Time (TBT) as a useful laboratory diagnostic for potential responsiveness problems.

TBT and INP are related to main-thread activity, but they are not interchangeable metrics.

Similarly, laboratory measurements of CLS may miss shifts that occur later when users interact with the page. Real-user monitoring can reveal these additional problems.

The most reliable approach is to use laboratory testing to identify potential causes and field data to verify the experience visitors actually receive.

A Practical Process for Improving Website Performance

Improving Core Web Vitals is more effective when website owners follow a consistent measurement and optimization process.

Step 1: Establish a performance baseline

Start by examining important pages using PageSpeed Insights and Google Search Console.

Prioritize pages that attract significant traffic or support important business activities, such as:

  • Homepage.
  • Service pages.
  • Product pages.
  • Category pages.
  • High-traffic articles.
  • Contact and enquiry pages.

Record the LCP, INP, and CLS results separately for mobile and desktop.

Step 2: Identify the largest performance problems

Avoid changing several technical components without understanding the underlying issue.

For poor LCP, examine server response time, important image loading, and render-blocking resources.

For poor INP, investigate JavaScript execution, long tasks, event handlers, and expensive rendering operations.

For poor CLS, identify the elements responsible for unexpected movement, including images, advertisements, fonts, and dynamically inserted content.

Step 3: Prioritize improvements by impact

Fix issues that affect multiple important pages before focusing on isolated problems.

For example, a shared header script that blocks rendering across an entire website may deserve attention before a minor image-loading problem on a low-traffic article.

Similarly, correcting image dimensions in a reusable page template can improve visual stability across hundreds of URLs.

Step 4: Test changes before deployment

Use a staging environment or controlled testing process to check whether the proposed changes improve performance without breaking website functionality.

An optimization that reduces JavaScript execution but prevents a navigation menu or enquiry form from working correctly is not a successful improvement.

Check the actual affected components, responsive layouts, and important user journeys.

Step 5: Monitor performance after deployment

Run laboratory tests again to identify immediate changes, then monitor field data as new visitor measurements become available.

CrUX uses a rolling 28-day reporting window, so field-data results do not necessarily reflect a technical change immediately.

Monitor mobile and desktop results independently. Continue investigating pages that remain outside the recommended thresholds.

How Core Web Vitals Affect SEO in 2026

Core Web Vitals are relevant to SEO because Google includes them in its ranking systems as part of a broader approach to page experience.

However, their influence needs to be understood accurately.

Good Core Web Vitals scores do not guarantee higher rankings. Google considers multiple ranking signals, and its systems continue to prioritize relevant content when determining which pages best answer a search query.

A webpage with excellent performance can still struggle in organic search if its content does not satisfy user intent, lacks useful information, or fails to address the topic adequately.

Likewise, a page with strong content may still create a frustrating experience if it loads slowly or its interface is difficult to use.

For SEO, improving Core Web Vitals should therefore be part of a wider website optimization strategy that also includes:

  • Helpful, relevant, and original content.
  • Proper technical SEO and crawlability.
  • Logical website architecture.
  • Mobile usability.
  • Secure HTTPS delivery.
  • Clear navigation.
  • Accessible page design.
  • Effective internal linking.

The objective should be to create pages that are both useful to searchers and technically efficient to access.

Common Core Web Vitals Mistakes to Avoid

Several optimization mistakes can prevent websites from achieving meaningful improvements.

Chasing a perfect Lighthouse score: A high laboratory performance score does not automatically mean that real users have a good experience. Field data should remain an important part of performance evaluation.

Lazy-loading the main hero image: Applying lazy loading to the LCP image can delay its discovery and download. Lazy loading is more appropriate for noncritical images further down the page.

Optimizing only desktop performance: Mobile and desktop users can experience different performance problems. Always examine both device categories.

Ignoring third-party scripts: External advertising, analytics, tracking, and chat scripts can consume significant browser resources and affect performance.

Using unnecessary plugins: A plugin can introduce additional scripts, stylesheets, database operations, or external requests. Review actual performance costs rather than assuming every plugin is harmful or that every plugin is necessary.

Making changes without retesting: Removing a script or changing an image format may improve one metric while creating another issue. Test the complete page after every significant optimization.

Treating Core Web Vitals as a ranking guarantee: Technical performance supports a better page experience, but it does not replace content quality, relevance, or other SEO requirements.

Frequently Asked Questions

What are the three Core Web Vitals in 2026?

The three Core Web Vitals in 2026 are Largest Contentful Paint (LCP), Interaction to Next Paint (INP), and Cumulative Layout Shift (CLS). They measure loading performance, responsiveness, and visual stability respectively.

What is a good Core Web Vitals score?

A good Core Web Vitals result requires an LCP of 2.5 seconds or less, an INP of 200 milliseconds or less, and a CLS score of 0.1 or less. These thresholds should be evaluated at the 75th percentile of page visits, separately for mobile and desktop.

Is Core Web Vitals a Google ranking factor?

Google confirms that Core Web Vitals are used by its ranking systems. However, they are only part of a broader evaluation of page experience. Good scores do not guarantee higher rankings because search relevance and other ranking signals remain important.

What replaced First Input Delay (FID)?

Interaction to Next Paint replaced First Input Delay as a Core Web Vital on March 12, 2024. INP evaluates responsiveness across qualifying interactions throughout a page visit, providing a broader picture than measuring only the delay before the first interaction.

How often should Core Web Vitals be checked?

Website owners should monitor Core Web Vitals regularly, particularly after major website updates, theme changes, new plugin installations, or modifications to JavaScript and page templates. Google Search Console and PageSpeed Insights help monitor field performance, while laboratory testing helps diagnose changes.

Why does PageSpeed Insights show different results from Google Search Console?

The tools can display different information because laboratory tests and field measurements use different environments. PageSpeed Insights combines Lighthouse diagnostics with CrUX real-user data, while Search Console focuses on real-user performance grouped by similar URLs and device categories. Their reporting periods and data availability can also affect the results.

Conclusion

Core Web Vitals provide a practical framework for understanding how visitors experience website performance. LCP measures how quickly important content appears, INP evaluates responsiveness to interaction, and CLS identifies unexpected movement in the page layout.

Improving these metrics requires identifying the technical causes of poor performance rather than simply chasing higher scores in testing tools. Image optimization, efficient JavaScript, faster server responses, stable layouts, and careful management of third-party resources all contribute to better website experiences.

For businesses and website owners in 2026, the most effective approach is to combine laboratory diagnostics with real-user measurements, prioritize the pages that matter most, and monitor performance after every significant technical change. The ultimate goal is not just to pass a performance assessment, but to make the website faster, more responsive, and easier for visitors to use.

More Guides

Cloud Hosting Providers Compared for Growing Websites

Cloudflare APO and WordPress Caching: Understanding the Differences

Cloudflare vs Bunny CDN: Features, Pricing and Performance

Common WordPress Optimization Mistakes That Slow Down Websites

Core Web Vitals Explained: Improving Website Performance in 2026

CSS Optimization Techniques for Faster Frontend Experiences

Cumulative Layout Shift: Causes, Examples and Prevention

Custom Website Development vs Template-Based Websites

Ecommerce Website Performance: Challenges and Optimization Priorities

Error Tracking Software and Its Importance in Web Applications

Essential Software for Freelance Web Developers

FlyingPress vs WP Rocket vs LiteSpeed Cache: A Feature Comparison