A slow website loses customers: how to make your site faster

5 min read
Illustration of a speedometer over a website screen, representing loading speed

Summary: Speed is measured with real-user data (Core Web Vitals: LCP, INP and CLS) and diagnosed with lab tests (Lighthouse/PageSpeed Insights). The most common gains come from correctly sized, modern-format images, less JavaScript, lean critical CSS, caching and a server that responds quickly.

Open your website on your phone using mobile data. If you got impatient, so will your customers. But "it's slow" isn't a diagnosis. To fix it, you need to know what is slow: the server taking too long to respond, the main image arriving late, a script blocking a tap on a button, or the layout jumping while it loads. Each problem has its own metric and fix.

The three metrics that matter (Core Web Vitals)

Thresholds recommended by Google (75th percentile of real users)
MetricWhat it measuresGoodPoor
LCPTime until the largest visible element (usually the main image or heading) appearsup to 2.5 sabove 4 s
INPHow quickly the page responds to interactions (taps, clicks, keys)up to 200 msabove 500 ms
CLSHow much the layout "jumps" while loadingup to 0.1above 0.25

INP replaced the old FID as a Core Web Vital in March 2024. Thresholds and definitions are at web.dev/vitals.

Lab vs. field: why the score changes

PageSpeed Insights shows two different things:

  • Field data (top of the report): from the Chrome User Experience Report (CrUX), covering 28 days of real visits. This reflects your users' actual experience. Low-traffic sites may not have it.
  • Lab data (the 0 to 100 score): a single Lighthouse run simulating a phone with a slow connection and a throttled processor. It's for diagnosis, and it varies from run to run.

In the current Lighthouse version, the heaviest weights in the score are Total Blocking Time, LCP and CLS (weights change between versions). A score of 100 isn't required; the goal is green Core Web Vitals in the field. Google treats these metrics as part of page experience, but its documentation makes clear that relevant content still matters more for ranking.

How to find the bottleneck

  1. Run PageSpeed Insights on the mobile version of your most important page (home page or a service page that receives ad traffic).
  2. See which metric is poor. High LCP, high INP and high CLS have different causes.
  3. Open the LCP diagnostics. The report shows the LCP element and splits its time into phases: server response (TTFB), resource load delay, load duration and render delay.
  4. In Chrome DevTools (F12 → Performance tab), record loading and interactions to spot long JavaScript tasks.
  5. In Search Console, the Core Web Vitals report groups URLs with the same problem using field data.

Images: the quickest win

Use modern formats (WebP or AVIF), serve the right size for each screen with srcset, and always declare width and height, which reserve space and prevent CLS.

<img src="service-800.webp"
     srcset="service-400.webp 400w, service-800.webp 800w, service-1200.webp 1200w"
     sizes="(max-width: 600px) 100vw, 800px"
     width="800" height="450" alt="Team installing solar panels on a roof"
     loading="lazy" decoding="async">

Lazy loading done right

The loading="lazy" attribute defers off-screen images, which is great. But never apply it to the main image at the top: that delays LCP. For the hero image, do the opposite and give it priority (web.dev: lazy loading, fetchpriority):

<img src="banner.webp" width="1200" height="600" alt="..." fetchpriority="high">

JavaScript: less is faster

  • Remove unused libraries and plugins (DevTools' Coverage panel shows code that never runs).
  • Load non-essential scripts with defer or async.
  • Third-party widgets (chat, pixels, maps, embedded videos) are among the biggest INP offenders. Load them only when the user interacts, where possible.
  • Break up long tasks: any task over 50 ms on the main thread can delay the response to a tap.

CSS and fonts

  • Inline the CSS needed for the first screen and load the rest without blocking rendering.
  • Remove unused styles, especially from full frameworks where only a small part is used.
  • For web fonts, use font-display: swap and limit the number of weights and variants.

Server and caching

If TTFB often exceeds about 0.8 s, the problem starts at the server: overloaded hosting, slow database, no page cache. Enable compression (Brotli or Gzip), HTTP/2 or HTTP/3 and browser caching for static files. Example for Apache (.htaccess), adjust to your server:

<IfModule mod_expires.c>
  ExpiresActive On
  ExpiresByType image/webp "access plus 1 year"
  ExpiresByType image/avif "access plus 1 year"
  ExpiresByType text/css "access plus 1 month"
  ExpiresByType application/javascript "access plus 1 month"
</IfModule>

Files with long cache lifetimes need a version in the name or URL (e.g., style.css?v=12) so changes reach visitors.

How to evaluate the results

  • Compare Lighthouse before and after over several runs (the score fluctuates).
  • Track the Core Web Vitals report in Search Console: field data takes about 28 days to reflect changes.
  • In Analytics, watch engagement rate and conversions on the optimized pages.

You can do part of this yourself; the code and server work is usually faster with people who do it every day. Our website maintenance plan includes this kind of tuning. When a site is too old, it sometimes pays to build a new one that's lightweight from the start. If the server is the bottleneck, see shared hosting or VPS.

Sources and references

Frequently asked questions

What's a good PageSpeed score?

Above 90 is considered good in Lighthouse. But what matters most is having field Core Web Vitals (LCP, INP and CLS) within the recommended thresholds.

Why does the score change every time I test?

The lab test is a single page load and varies with network, server and third-party scripts. Run it a few times and compare the median.

Does speed improve Google rankings?

Core Web Vitals are part of the page experience signals Google uses, but content relevance weighs more. The surest gain is visitors who don't give up before seeing the page.

Can I lazy load every image?

No. Use it for images below the first screen. On the main hero image, lazy loading delays LCP; use fetchpriority="high" there instead.

WebP or AVIF?

Both are well supported by current browsers. AVIF usually produces smaller files; WebP encodes faster. Test the visual quality of both for each image.

Is your website slow?

We analyze its loading and tell you what will fix it, without pushing what you don't need.

Read also

Written by Mário Moreno, founder of Agência hetsi, which has been building websites and handling digital marketing for businesses in Brazil and abroad since 2000. Mário Moreno on LinkedIn