Speed is felt before it's measured.

A working notebook on what Google's own performance research says about load time and behavior, read carefully and written down in plain language.

Read a real Lighthouse report
Laptop screen displaying a Lighthouse performance report with a circular score gauge

Reading the score, not chasing it

Core metricLCP

The research

What Google's own research actually says

Google has published a fair amount of its own thinking on this over the years, mostly through web.dev, the Chrome team's engineering blog, and the public Chrome User Experience Report. None of it reads like marketing. It reads like engineers trying to explain why a page that loads in three seconds behaves so differently from one that loads in one.

The pattern that keeps showing up isn't a straight line. Bounce probability doesn't creep upward evenly as load time increases. It behaves more like a threshold effect: people tolerate a little friction, then their patience drops off quickly once a page crosses some point that varies by device, connection, and what they came to do.

"The relationship between speed and user behavior isn't linear. Small delays are absorbed. Past a certain point, tolerance falls away fast, and that point moves depending on what the user expects to happen next."

Paraphrased from Google's publicly available web performance documentation

This is why the blog exists in the current form. We're not trying to sell anyone a fix. We're trying to read the same public documents, the same CrUX dataset, the same HTTP Archive snapshots that Google references, and write down what we notice without inflating it into a bigger claim than the data supports.

Close-up of a browser developer tools network panel showing a waterfall of loading resources
The network waterfall is where the story usually starts, long before anyone opens a performance score.

Context matters

A one-second delay isn't one thing

Person holding a phone at a checkout screen with a loading indicator visible

On an e-commerce checkout

A delay lands inside a decision that's already fragile. The shopper has a competing tab open, a card in hand, and a dozen reasons to reconsider. A stalled page doesn't just cost a second, it hands back the moment of hesitation that the whole page was designed to move past.

Commuter on a train checking a phone with a partially loaded article page

On a blog or article page

The reader already clicked through from a search result or a link, so there's some existing intent to arrive. A slow load here is more likely to be read as clutter or irrelevance than as a reason to leave outright, though it still raises the odds. The bounce is often about relevance mismatch first, speed second.

This is the piece that gets flattened in most speed advice: the same delay, measured the same way, doesn't carry the same weight for every kind of page. Knowing which one you're running changes which metric deserves your attention first.

No code required

Diagnosing speed without reading a line of code

Lighthouse, the free auditing tool built into Chrome, produces a report most people glance at, note the score, and close. The score is the least interesting part. The Opportunities and Diagnostics sections underneath it are where the actual story lives, written in sentences rather than jargon.

  • The performance score is a weighted summary, not a grade. Two sites with the same number can have entirely different problems.
  • LCP tells you which single element the browser considers the "main content," and how long it took to appear.
  • CLS flags the visual jumping that happens when late-loading elements push things around after the reader has already started reading.
  • The Diagnostics list is roughly ordered by potential impact, but "potential" is doing a lot of work in that sentence.
Walk through an actual report

Priorities

Which fixes matter, and which are diminishing returns

Usually worth the attention

  • Compressing and correctly sizing images before they're served
  • Deferring scripts that aren't needed for the first paint
  • Reserving space for images and ads so layout doesn't shift
  • Trimming render-blocking stylesheets loaded above the fold

Often diminishing returns

  • Shaving another 40 milliseconds off an already-fast font load
  • Inlining tiny CSS fragments once the main bundle is already lean
  • Switching hosting providers when the bottleneck is actually the page itself
  • Chasing a perfect Lighthouse number after real users already load quickly

The pattern we keep seeing: the first few fixes on a slow page tend to matter a great deal. Somewhere past that, effort and perceptible benefit stop moving together, and further work becomes more about the number on the screen than the person looking at the page.

Felt speed

Why a fast-loading site can still feel slow

Designer reviewing wireframe skeleton screens on a tablet next to a laptop showing a finished layout
Skeleton screens and progress indicators change how waiting is experienced, independent of the actual load time.

A page can pass every metric in a Lighthouse report and still leave someone with the impression that it dragged. Perceived performance is the gap between how long something actually took and how long it felt like it took, and that gap is shaped by things a stopwatch doesn't capture.

A skeleton screen that appears instantly, even if the real content takes another second, tends to read as faster than a blank white page followed by an abrupt content flash. Small, well-timed motion can smooth over a wait. Abrupt layout jumps do the opposite, even on objectively quick pages, because they interrupt whatever the reader was already doing with their eyes.

This is the part of the conversation that gets skipped most often. Two pages can share an identical load time and produce different reactions, because one of them was designed with the waiting in mind and the other wasn't.

Behind the articles

Who writes here

Four people who read the same public research and disagree about parts of it more often than you'd expect.

Maren Kessler, research editor, smiling in a converted loft office

Maren Kessler

Research Editor

  • Tracks Google's published performance documentation
  • Translates studies into plain sentences
Devon Ualani, data analyst, reviewing charts on a laptop

Devon Ualani

Data Analyst

  • Works with public CrUX and HTTP Archive data
  • Checks whether common speed claims hold up
Priya Nadkarni, walkthroughs writer, pointing at a screen during a discussion

Priya Nadkarni

Walkthroughs Writer

  • Builds the screenshot-based Lighthouse explainers
  • Writes for readers who don't touch code
Samuel Ortiz, tools curator, working at a desk with multiple monitors

Samuel Ortiz

Tools Curator

  • Tests and documents the free tools page
  • Flags when a tool starts to overpromise
More on how we work

Start here

Walk through a real Lighthouse report

Screenshot by screenshot, with the jargon translated as we go. No prior knowledge of code assumed.

Open the walkthroughs

Or, if you'd rather explore

Browse the free tools we keep open

The public tools this blog actually references when writing an article, described plainly, limits included.

See the tools

Methodology

What we lean on to write this

Not certifications. Just the public datasets and standards behind every claim we make.

Chrome UX Report

Real-user field data collected by Chrome, publicly queryable, and the closest thing to ground truth we reference.

Lighthouse audits

Lab data run locally against public pages, useful for structure and diagnostics rather than absolute claims.

HTTP Archive

A historical, openly published crawl of how the web loads over time, updated on a regular public schedule.

web.dev documentation

Google's own explanations of the metrics behind Core Web Vitals, read in full rather than skimmed for headlines.