blog

9 Website Performance Metrics To Track for Speed, SEO & UX

9 Website Performance Metrics To Track for Speed, SEO & UX

  • Anthony Pataray

  • Jun 16
  • 12 min read

Your website might look great, but if it loads like it’s running on dial-up, visitors bounce before they ever see your offer. Website performance metrics give you the hard numbers behind how your site actually behaves, from load times and server response to how users interact with each element on the page. Without tracking them, you’re essentially guessing why leads aren’t converting.


For local businesses especially, a slow or clunky site doesn’t just frustrate users, it tanks your search rankings. Google factors page speed and user experience directly into how it ranks your pages. That means poor performance costs you visibility and the qualified traffic that comes with it. It’s a problem we solve daily at Wilco Web Services when building and optimizing conversion-focused websites for our clients.


This article breaks down nine key metrics you should be monitoring, what each one actually measures, and how to use them to improve your site’s speed, SEO, and user experience. No fluff, just the numbers that matter and the tools to track them effectively.


1. Largest Contentful Paint (LCP)


Largest Contentful Paint measures how long it takes for the largest visible element on your page to fully render in the browser. That element is typically a hero image, a large heading, or a banner video, whichever takes up the most real estate above the fold. It’s the Core Web Vital most directly tied to how fast your page feels to a real user on arrival.


What LCP measures and why it matters


LCP is part of Google’s Core Web Vitals framework and directly influences your search rankings. When someone lands on your page, LCP captures the moment they can actually see the main content. A slow LCP means users stare at a partially loaded screen, and most won’t wait more than a few seconds before they hit the back button.


Google treats LCP as one of the strongest signals for page experience, which feeds directly into how your site ranks in search results.


What good looks like for LCP


Google’s benchmark is specific: LCP under 2.5 seconds is considered good, 2.5 to 4 seconds needs improvement, and anything above 4 seconds is poor. Your target is to hit that sub-2.5 threshold on both mobile and desktop, since Google uses mobile-first indexing for most websites.


How to measure LCP in the real world and in tests


Tracking this website performance metric requires two types of data. Field data comes from real users visiting your site and is captured inside Google Search Console under Core Web Vitals and through the Chrome User Experience Report. Lab data comes from Google PageSpeed Insights, which simulates load conditions in a controlled environment and pinpoints exactly which element triggered the LCP score.


What usually hurts LCP


The most common culprits are slow server response times, unoptimized images, and render-blocking resources like large CSS or JavaScript files that delay the browser from painting content. Third-party scripts such as chat widgets or ad trackers loaded in the document head can also push LCP well past the acceptable threshold.


Fixes that improve LCP fastest


Start by compressing images and converting them to modern formats like WebP or AVIF. Make sure your LCP element loads eagerly, not lazily, and preload it using the <link rel=”preload”> tag in your HTML head. If your server response is the real bottleneck, move to faster hosting or add a content delivery network to reduce the distance data travels to reach your visitors.


2. Interaction to Next Paint (INP)


Interaction to Next Paint replaced First Input Delay as a Core Web Vital in March 2024, making it one of the most critical website performance metrics you need to monitor today. It measures responsiveness throughout the entire user session, not just the first click.


What INP measures and why it matters


INP captures the longest interaction delay observed during a visit, including clicks, taps, and keyboard inputs. A high INP score tells you that your page feels sluggish or unresponsive, which destroys user trust and pushes visitors away before they convert.


Google replaced First Input Delay with INP because it gives a more complete picture of how responsive your page is across the full session, not just on arrival.


What good looks like for INP


INP under 200 milliseconds is Google’s threshold for a good score. Scores between 200 and 500 milliseconds need improvement, and anything above 500 milliseconds is considered poor on both mobile and desktop.


How to measure INP and find the worst interactions


Use the Chrome DevTools Performance panel to record interactions and identify which ones take the longest to resolve. Google PageSpeed Insights and the Chrome User Experience Report also surface real-user INP data broken down by page.


What usually hurts INP


Heavy JavaScript execution on the main thread is the primary driver of a poor score. Third-party scripts, large event handlers, and synchronous DOM updates all compete for processing time and delay the browser’s response to user input.


Fixes that reduce input delay and main-thread work


Break long JavaScript tasks into smaller chunks using setTimeout or the Scheduler API. Defer non-critical scripts and move heavy processing off the main thread with Web Workers wherever your codebase allows it.


3. Cumulative Layout Shift (CLS)


Cumulative Layout Shift measures how much your page’s content unexpectedly moves during load. It’s one of the Core Web Vitals and a website performance metric that directly affects conversions, because a shifting layout causes users to click the wrong element or abandon the page before they act.


What CLS measures and why it matters


CLS calculates a score based on the size and distance of each unexpected element shift while the page loads. Every time text, images, or buttons jump without a user triggering it, your CLS score climbs and the experience degrades for both visitors and Google’s ranking systems.


What good looks like for CLS


Google’s threshold for a good CLS score is 0.1 or below. Scores between 0.1 and 0.25 need improvement, and anything above 0.25 is poor and will hurt both your rankings and your ability to convert visitors into leads.


A CLS score above 0.25 signals to Google that your page delivers a poor experience, which feeds directly into where you rank in search results.


How to measure CLS and spot shifting elements


The Google PageSpeed Insights diagnostics section surfaces the specific elements causing shifts on your page. Chrome DevTools’ Performance tab also lets you record a page load and pinpoint each individual shift event along with its score contribution.


What usually causes layout shifts


Images and ads without declared dimensions are the leading cause of high CLS. Late-loading fonts that swap out placeholder text, along with third-party embeds that push content down after the initial render, also drive scores up.


Fixes that prevent unexpected movement


Set explicit width and height attributes on every image, video, and iframe so the browser reserves space before content loads. Preload custom fonts or use font-display: optional to stop late font swaps from shifting surrounding text downward.


4. Time to First Byte (TTFB)


Time to First Byte measures how long your browser waits before it receives the first byte of data from the server. It’s a foundational website performance metric that underpins every other load time measurement because nothing else can happen until your server responds.


What TTFB measures and why it matters


TTFB captures the total time from the browser sending a request to receiving the first byte of the server’s response. A slow TTFB delays every downstream metric, including LCP and FCP, so fixing it early produces compounding improvements across your entire performance profile.


A high TTFB is often the root cause of multiple slow Core Web Vitals scores at once, making it one of the most impactful fixes you can prioritize.


What good looks like for TTFB


Google recommends a TTFB under 800 milliseconds for a good score. Anything above 1,800 milliseconds is considered poor and signals that your server infrastructure or backend processing needs direct attention.


How to measure TTFB by location and device


Google PageSpeed Insights reports TTFB as part of its lab data, while Chrome DevTools’ Network tab shows the exact breakdown of connection time, waiting time, and receiving time for each request your page makes.


What usually slows down server response


Shared hosting environments, unoptimized databases, and the absence of server-side caching are the most common causes of a high TTFB. Slow DNS lookup times also add latency before the connection even starts.


Fixes that improve server and caching performance


Upgrade to a faster hosting tier or a dedicated server, and implement server-side caching to avoid regenerating pages on every request. Adding a CDN reduces the physical distance between your server and the visitor, cutting response time significantly.


5. First Contentful Paint (FCP)


First Contentful Paint marks the moment when the browser renders the first visible element from your DOM, whether that’s text, an image, or a canvas. It’s one of the key website performance metrics that tells you how quickly your page starts showing users something real instead of a blank screen.


What FCP measures and why it matters


FCP captures the time from navigation start to the first content element appearing on screen. A fast FCP signals to users that the page is loading, which reduces early bounce rates and keeps visitors engaged while the rest of the content finishes rendering.


What good looks like for FCP


Google considers an FCP under 1.8 seconds good, with scores between 1.8 and 3 seconds needing improvement and anything above 3 seconds classified as poor. Target the sub-1.8 threshold on both mobile and desktop.


A slow FCP is often the earliest warning sign of deeper rendering bottlenecks that will hurt your LCP and overall user experience scores.


How to measure FCP and confirm render progress


Google PageSpeed Insights reports FCP in its lab results and flags specific issues slowing it down. Chrome DevTools’ Performance panel lets you record a page load and see exactly when the first content pixels appear on the timeline.


What usually delays the first render


Render-blocking CSS and JavaScript in the document head are the primary causes of a slow FCP. Slow server response times compound the delay further before the browser can even begin parsing the page.


Fixes that speed up the first visible content


Eliminate or defer render-blocking resources and inline only the critical CSS needed for above-the-fold content. Reducing your TTFB also directly cuts FCP since the browser cannot paint anything until the server delivers the HTML.


6. Total Blocking Time (TBT)


Total Blocking Time measures the total duration the main thread is blocked long enough to prevent user input from being processed. It’s a lab-only website performance metric that directly predicts how responsive your page will feel before a user ever clicks anything.


What TBT measures and why it matters


TBT adds up every blocking period that exceeds 50 milliseconds during page load, specifically between First Contentful Paint and Time to Interactive. Each task running longer than 50ms contributes its excess time to the TBT score, giving you a direct signal of JavaScript overhead on your page.


A high TBT score almost always predicts a poor INP score in the field, making it one of the most actionable metrics you can optimize in a controlled lab environment.


What good looks like for TBT


Google considers a TBT under 200 milliseconds good. Scores between 200 and 600 milliseconds need improvement, and anything above 600 milliseconds signals serious main-thread congestion that damages both your rankings and user experience.


How to measure TBT and find long tasks


Google PageSpeed Insights reports TBT directly in its lab results. Use the Performance panel in Chrome DevTools to record a page load and identify every long task in the main thread track by duration.


What usually blocks the main thread


The most common causes of a high TBT score include:


  • Large JavaScript bundles parsed synchronously during load

  • Third-party scripts loaded in the document head without deferral

  • Excessive DOM size that forces costly layout recalculations


Fixes that cut blocking JavaScript time


Split large JavaScript files into smaller chunks using code splitting, and load non-critical scripts with the defer or async attribute. Removing unused JavaScript through tree-shaking cuts the total parsing time the browser must complete before your page becomes interactive.


7. Speed Index


Speed Index measures how quickly the visible content of your page populates during load, giving you a single score that reflects the overall visual progression a real user experiences. Unlike metrics tied to a specific element, Speed Index captures the entire above-the-fold rendering journey from start to finish.


What Speed Index measures and why it matters


Speed Index calculates the average time at which visible parts of your page are displayed, weighting earlier moments more heavily than later ones. It’s one of the core website performance metrics tracked in Lighthouse because it reflects perceived load speed rather than any single technical event.


A page can have a fast LCP but still feel slow if content fills in gradually, and Speed Index captures exactly that gap.


What good looks like for Speed Index


Google Lighthouse considers a Speed Index under 3.4 seconds good, with scores between 3.4 and 5.8 seconds needing improvement and anything above 5.8 seconds rated poor across both mobile and desktop conditions.


How to measure Speed Index consistently


Run your pages through Google PageSpeed Insights, which reports Speed Index as part of its Lighthouse lab audit alongside the other timing metrics. Repeat tests across different network conditions to get a consistent baseline you can track over time.


What usually makes a page feel slow


Large above-the-fold images that load progressively and render-blocking scripts that delay paint are the primary drivers of a poor Speed Index score. Unoptimized web fonts that cause invisible text during load also contribute significantly.


Fixes that improve perceived load speed


Prioritize loading critical above-the-fold content first by inlining essential CSS and deferring everything else. Serving properly sized, pre-compressed images through a CDN cuts the time it takes for visible content to fill in and brings your Speed Index down consistently.


8. Total Page Size


Total page size tracks the combined weight of every file your page downloads, including HTML, CSS, JavaScript, images, fonts, and third-party resources. It’s one of the most straightforward website performance metrics to understand but one of the most commonly overlooked in ongoing site management.


What total page size measures and why it matters


Every byte your browser downloads adds directly to load time, especially on mobile connections where bandwidth is limited. A bloated page drives up your LCP, Speed Index, and TTFB scores simultaneously, creating compounding performance problems across the board.


What good looks like for page weight


Under 1MB is a realistic target for most business websites, with many high-performing pages coming in well under that threshold. Lighthouse flags pages that exceed 1.6MB as having excessive network payloads that actively hurt mobile performance.


Keeping your total page size under 1MB reduces data usage for mobile visitors and directly improves nearly every other load time metric on your site.


How to measure page size and identify the biggest files


Open Chrome DevTools and check the Network tab after a full page load. The bottom of the panel shows your total transfer size and request count, and sorting by file size instantly reveals your heaviest resources.


What usually bloats a page


Uncompressed images are the single largest contributor to excessive page weight on most sites. Unminified CSS and JavaScript, multiple font families, and unused code loaded on every page all add significant unnecessary weight.


Fixes that reduce image, font, CSS, and JS weight


Compress images using modern formats like WebP or AVIF and serve them at the correct display size rather than scaling down with CSS. Minify your CSS and JavaScript, remove unused code through tree-shaking, and limit font families to two or fewer to keep total page weight lean.


9. Error Rate


Error rate tracks how often your server returns failed responses to browsers and crawlers, making it one of the most underappreciated website performance metrics in any site audit. A rising error rate quietly destroys both search visibility and user experience before you notice traffic dropping.


What error rate measures and why it matters


Error rate captures the percentage of requests your server answers with 4xx or 5xx status codes, covering everything from missing pages to server crashes. Every failed response represents a visitor or a crawler that hit a dead end on your site.


A consistently high error rate signals broken infrastructure to Google’s crawlers, which directly limits how much of your site gets indexed and ranked.


What good looks like for error rate


Your target is an error rate as close to 0% as possible. Even a 1% error rate on a busy site translates into thousands of failed requests each month, each one a missed opportunity to convert a visitor or preserve link equity across your pages.


How to measure errors across SEO, UX, and ops


Google Search Console surfaces crawl errors and 404s that affect your search visibility directly. Your hosting provider’s server logs give you the full picture of all 4xx and 5xx responses across every request, including ones visitors never see.


What usually causes 4xx and 5xx spikes


Deleted or renamed pages without proper redirects are the leading cause of 404 spikes. Common 5xx triggers include:


  • Overloaded servers that run out of resources during traffic spikes

  • Failed database connections that block page rendering

  • Misconfigured settings after a hosting migration or plugin update


Fixes that reduce errors and protect conversions


Set up 301 redirects immediately whenever you delete or move a page. Configure automatic alerts tied to your server error logs so you catch rate spikes before they compound into ranking or conversion losses.


What to do next


Tracking these nine website performance metrics gives you a complete picture of where your site is losing visitors, rankings, and revenue. Start by running your pages through Google PageSpeed Insights to get baseline scores for LCP, INP, CLS, and the other metrics covered here. Prioritize fixes by impact: server response and image optimization typically deliver the fastest gains across the most metrics at once.


Once you have your scores, build a monthly audit routine so you catch regressions before they compound into ranking drops or conversion losses. Small changes, like a new plugin or an uncompressed image upload, can push a metric from good to poor without any obvious warning sign.


If your site is underperforming and you want a team that can diagnose and fix it for you, get in touch with Wilco Web Services. We build and optimize conversion-focused websites that rank higher and turn more visitors into paying clients.

 
 
 
Related Articles

Table of Contents