Website Performance Test

Benchmark your site against Google's performance standards, see exactly which resources slow it down, and get a prioritized fix list.

Free • No Registration • Lighthouse Powered

What a Website Performance Test Measures

A performance test is broader than a simple load-time check. It runs your page in a controlled browser, records every network request and JavaScript task, and produces a weighted score for how quickly the page renders and responds. W3Test runs Google Lighthouse, so the score you see uses the same methodology Google publishes for PageSpeed Insights and the Chrome UX Report.

The result is a single 0–100 performance score built from several lab metrics, plus a diagnostics list that explains why the score is not higher. That combination is what makes a performance test useful: the score tells you whether there is a problem, and the diagnostics tell you where.

Performance Score vs Real User Experience

A lab test runs on a simulated connection and device with a cold cache. Your real visitors arrive on different networks, with warm caches, often while other tabs are open. That is why a page can score 95 in a test and still feel slow to some users. Treat the lab score as a repeatable baseline, then compare it with field data such as Core Web Vitals in Search Console.

  • Use lab tests to catch regressions. Run the same page after each deploy and watch the score and diagnostics change.
  • Use field data to understand users. Real-user metrics reveal slow devices and networks that a simulation cannot reproduce.
  • Compare like with like. Desktop and mobile runs use very different CPU and network throttling, so never compare a desktop score with a mobile score.

The Metrics Behind the Score

  • First Contentful Paint (FCP): when the browser paints the first text or image. A slow FCP usually points to blocking CSS, slow fonts or a slow server.
  • Total Blocking Time (TBT): the total time the main thread is too busy to respond to input. This is the lab metric most closely tied to a poor Interaction to Next Paint score.
  • Speed Index (SI): how quickly the visible parts of the page are painted. It rewards progressive rendering over a late full-page paint.
  • Largest Contentful Paint (LCP): when the largest visible element appears. Most often the hero image, a heading or a background image.
  • Cumulative Layout Shift (CLS): how much visible content moves while loading. Caused by images, ads and embeds without reserved space.
  • Time to Interactive (TTI): when the page is quiet enough to respond reliably to input.

Common Performance Problems and Their Fixes

Oversized images

Images served far larger than their rendered size are the most common cause of a poor LCP. Resize them, serve WebP or AVIF, and add width and height attributes.

Unused JavaScript

Analytics, chat widgets and carousels often ship code the page never uses. Defer non-critical scripts, load widgets on interaction and remove what you no longer use.

Slow server response

A high Time to First Byte delays every later metric. Add page caching, a CDN, and check for slow database queries or missing indexes.

Render-blocking CSS and fonts

Third-party CSS and web fonts block the first paint. Inline critical CSS, self-host fonts, preload the main font file and limit the number of weights.

How Often Should You Run a Performance Test?

Run a test before and after every significant release, after adding a third-party script, and whenever you change hosting or a CDN setting. For production monitoring, schedule automated checks so you notice gradual regressions that no single deploy seems to cause. W3Test can store each run so you can compare results over time instead of relying on memory.

Mobile and Desktop Are Different Tests

Mobile runs apply a slower CPU and a constrained network, and they usually score 20–40 points lower than desktop. Since most organic traffic is mobile, use the mobile result as your primary benchmark. If the mobile score is poor while desktop is fine, the problem is almost always JavaScript execution or an image that is too large for a phone to decode quickly.

Related Tools