Website speed optimization: how to make a slow site fast (and pass Core Web Vitals)

The short answer

Website speed optimization means making pages load quickly, respond to taps without delay and stay steady while they load. Google measures this with three Core Web Vitals: LCP, INP and CLS. For most small business sites, the biggest wins come from smaller images, fewer third-party scripts, leaner fonts and better hosting. Check real-visitor data first, then fix in order of impact.

On this page

If someone has told you your website is slow, or PageSpeed Insights gave you an orange or red number, the next step is not to install a speed plugin. It is to find out what is slow for real visitors, then fix the few things causing most of it.

This guide covers what Google measures, how to test properly and the fixes that matter most for a typical small business site. If you would rather hand the job over, it is what my speed and technical SEO sprint covers, starting at $600.

Why website speed matters, according to Google

Google measures speed and stability with Core Web Vitals. Its Core Web Vitals documentation calls them "a set of metrics that measure real-world user experience for loading performance, interactivity, and visual stability of the page."

They are part of what Google calls page experience, and Google is direct about their role: "Core Web Vitals are used by our ranking systems." It recommends that site owners "achieve good Core Web Vitals for success with Search and to ensure a great user experience generally."

Google is just as clear about the limits:

  • There is no single page experience signal: "There is no single signal."
  • "Google Search always seeks to show the most relevant content, even if the page experience is sub-par."
  • Good results in Core Web Vitals reports "doesn't guarantee that your pages will rank at the top of Google Search results."

So speed will not lift a weak page above a much more useful one. Where many pages are similarly helpful, Google says good page experience can help. And a page that loads quickly on a phone gives more visitors the chance to get in touch.

The three Core Web Vitals in plain English

Each Core Web Vital measures a different frustration: waiting for the page, waiting for a response, and watching things jump around.

  • Largest Contentful Paint (LCP) is how long the biggest thing on screen, usually the main photo or headline, takes to appear.
  • Interaction to Next Paint (INP) is how quickly the page reacts when someone taps a button, opens a menu or types in a form.
  • Cumulative Layout Shift (CLS) is how much the layout moves while the page loads, like a paragraph that slides down just as you tap a link. It is a score, not a time.

These are the current thresholds from web.dev and the Search Console report:

MetricWhat it measuresGoodNeeds improvementPoor
LCPLoading2.5 seconds or lessUp to 4 secondsOver 4 seconds
INPResponsiveness200 milliseconds or lessUp to 500 millisecondsOver 500 milliseconds
CLSVisual stability0.1 or lessUp to 0.25Over 0.25

One detail trips people up. web.dev says "a good threshold to measure is the 75th percentile of page loads, segmented across mobile and desktop devices." In plain terms, at least three in four visits need to be in the good range, with phones and computers judged separately. Your office computer on fast Wi-Fi is not the visit that decides it.

How to measure page speed properly

Google's tools show two kinds of data, and they answer different questions.

Field data: what real visitors experienced

Field data comes from the Chrome User Experience Report (CrUX), which "collects anonymized, real user measurement data for each Core Web Vital." PageSpeed Insights shows it at the top of its report, covering visits "over the previous 28-day collection period."

This data drives the Core Web Vitals assessment, which a page passes when "the 75th percentiles of all three metrics are Good." If a page has too few visitors, PageSpeed Insights falls back to data for the whole site. If the site has too few, there is no field data at all.

Lab data: one simulated visit

The score out of 100 comes from Lighthouse running one simulated visit. It is repeatable and lists specific issues, which makes it good for diagnosis.

It also cannot see everything. web.dev notes that tools like Lighthouse "cannot measure INP," because nobody is tapping anything, so Lighthouse measures Total Blocking Time, which "is lab-measurable and is a proxy for INP." Lab testing "is not a substitute for field measurement." When the two disagree, trust field data for what visitors experience and use the lab report to work out why.

Search Console: the whole site at once

The Core Web Vitals report in Search Console uses the same CrUX data but covers the whole site. It groups "pages that have a similar user experience," such as all your blog posts, and rates each group separately for mobile and desktop.

A group takes "the slowest status assigned to it for that device type," so one weak metric is enough to fail. Once you have fixed an issue, you can start a 28-day monitoring session to confirm the fix holds.

Website speed optimization: the fixes that matter most

These are the fixes I check on almost every small business site, roughly in order of how often they make a real difference.

Images: usually the biggest win

A common pattern is a large photo at the top of the page, uploaded straight from a camera or stock library at several times the size it is shown. That photo is often the element that sets your LCP.

Why it helps: Google's guide to optimizing LCP lists the fixes plainly: "Use modern image formats," "Compress images" and "Serve the optimal image size." web.dev says "WebP and AVIF will generally provide better compression than older formats, and should be used where possible." Two more details matter as much as file size:

  • Set a width and height. web.dev says to "Always include width and height size attributes on your images and video elements," so the browser reserves the space and the text below does not jump. This is one of the most common CLS fixes.
  • Lazy load images further down, never the main one. loading="lazy" lets the browser "completely defer the loading of offscreen images" until someone scrolls near them. But "Never lazy-load your LCP image, as that will always lead to unnecessary resource load delay." For the main image, web.dev suggests fetchpriority="high" instead.
<img src="/images/office-1200.webp" width="1200" height="800" fetchpriority="high" alt="Our office">
<img src="/images/team-800.webp" width="800" height="600" loading="lazy" alt="The team">
The main image loads first with its space reserved; images further down wait until they are needed.

How to check: Right-click the main image and open it in a new tab. If a photo shown 1,200 pixels wide is really 4,000 pixels wide, you have found your first fix. Also check that your theme is not lazy loading the image at the top.

Fonts: fewer files, served from your own site

Each font weight and style is a separate file to download. Three families in four weights each means twelve files before the text settles, and a late font can shift the layout when it replaces the fallback.

Why it helps: web.dev's font guidance puts it simply: "The fastest font to deliver is a font that isn't requested in the first place." What I do:

  • Use fewer families and weights. Two families is plenty for most sites, and "a single variable font can be used as a replacement for multiple font files."
  • Self-host in WOFF2. Serving fonts from your own domain "eliminates a third-party connection setup." web.dev admits the real-world difference "is less clear cut," but you gain full control, and WOFF2 "offers the best compression."
  • Preload one or two fonts at most. Preloading "comes at the cost of taking away browser resources from the loading of other resources."
  • Pick a font-display setting. font-display: swap shows text in a fallback font straight away, at the risk of "the jarring shift when the font arrives late." With optional, "the web font won't be used if it arrives late."

How to check: In Chrome, right-click the page, choose Inspect, open the Network tab, filter to fonts and reload. Count the files.

Third-party scripts: chat widgets, trackers and embeds

Chat widgets, booking popups, trackers, heatmap tools and embedded videos or maps all load code from someone else's server. In my experience, together they are often the biggest drag on an otherwise well built site.

Why it helps: web.dev's INP guidance explains that loading and running scripts "can introduce long tasks on the main thread," and while the browser is busy, it cannot respond to a tap. That is why heavy scripts so often cause a poor INP.

web.dev's advice for a slow script is to "Remove it if it doesn't add clear value to your site." Load the ones you keep asynchronously. For heavy embeds, I often show a lightweight placeholder, such as a still image of a video, and load the real thing only when someone clicks.

How to check: List every tool ever added and ask who still uses it. Then test with one tool removed and compare.

Heavy themes, page builders and too many plugins

Multipurpose themes and drag-and-drop builders are popular for a good reason: you can change pages without a developer. The trade-off is that they are built to do everything, so they can load code for features you never use and wrap content in layers of extra markup. On WordPress, web.dev notes that "performance is impacted by the number and quality of plugins, or what themes are used."

Why it helps: Less code means less to download and process. The INP guidance notes that "When a page's DOM is small, rendering work usually finishes quickly," and deeply nested builder blocks are rarely small. One badly built plugin can do more harm than several light ones.

This is not a case against builders: editing your own pages has real value. It is a cost to weigh, and my Webflow and WordPress comparison may help if you are choosing.

How to check: View the source of your contact page. If a short page loads dozens of stylesheet and script files, it is carrying extra weight. Deactivate doubtful plugins one at a time on a staging copy and retest.

Server response, caching and a CDN

Before anything appears, your server has to send the first part of the page. That wait is Time to First Byte (TTFB), and web.dev says "most sites should strive to have a TTFB of 0.8 seconds or less." Everything else waits for it, and redirect chains add to it: "One common contributor to a high TTFB is redirects."

Why it helps: Caching keeps a ready-made copy of a page so it does not have to be rebuilt from the database on every visit. A CDN (content delivery network) keeps copies of your files in many locations, so a visitor in Sydney is not waiting on a server in Texas. web.dev says that if your site is not using a CDN, it "should be a high priority to pursue in optimizing your TTFB."

How to check: Test a page with little on it, such as your privacy page. If even that is slow to start, the problem is the server, not your images. Ask your host whether page caching and a CDN are set up.

Render-blocking CSS and JavaScript

Some files must load before the browser shows anything. Chrome's documentation treats a script in the head of the page without an async or defer attribute as render-blocking, and stylesheets block rendering unless marked otherwise.

Why it helps: Chrome's recommended fixes are to "inline critical styles required for the first paint," load the rest afterward, add async or defer to non-critical scripts, and delete the rest: "Code that isn't being used at all should be removed."

How to check: The lab section of PageSpeed Insights flags render-blocking files. Test carefully after fixing them, because deferring the wrong script can break a menu or a form.

A worked example: this website

This website is plain static HTML built by a short Node script, hosted on Netlify, with self-hosted fonts, and it scores 100 in Lighthouse lab tests on mobile and desktop.

Two honest caveats: that is a lab score, and a new site may not have enough visitors yet for field data. A studio site also has fewer moving parts than a shop.

Not every site should be plain HTML. I build on WordPress or Webflow when a client wants to edit pages themselves, and the principles are the same: right-sized images, few fonts and few scripts.

What speed work will and will not do for you

What it can do:

  • Turn a failing Core Web Vitals assessment into a passing one, which Google's ranking systems take into account.
  • Give a useful page a fairer chance against pages that are similarly relevant.
  • Keep visitors who would give up before the page appears, which matters even more when you pay for each click.

What it will not do:

  • Outrank a more relevant page. Google shows the most relevant content "even if the page experience is sub-par."
  • Fix thin content, missing service pages or pages Google cannot index.
  • Turn visitors into leads on its own. A fast page with a vague offer is still a vague page.

I treat speed as a bar to clear, not a score to max out. Get important pages into the good range for real visitors, then spend your time on content, links and making it easy to get in touch. My new website SEO checklist covers the other technical basics.

How to speed up a website: where to start

If you want to do this yourself, this is the order I would follow.

  1. Test your home page and main service page in PageSpeed Insights on mobile, and note whether the field data passes.
  2. Open the Core Web Vitals report in Search Console to see which page groups fail, and on which metric.
  3. Match the metric to its usual causes. Slow LCP points to the main image, server response or render-blocking files. Poor INP points to too much JavaScript, often from third parties. High CLS points to images without dimensions, embeds without reserved space, late-loading content or fonts.
  4. Fix the main image on your key templates first, because one fix improves every page using that template.
  5. Remove scripts and plugins you do not need before adding anything new, including speed plugins.
  6. Retest in the lab to confirm each fix, then give the field data its 28-day window to catch up.

Speed slips as new images, tools and plugins get added, so recheck after any significant change. That is one reason my website care plans include a monthly SEO health check, from $99 a month.

Most slow sites are slow for two or three reasons, not a dozen. Once those are fixed, staying fast is mostly about being choosy with what you add.

More questions

What is a good PageSpeed score?

PageSpeed Insights treats a performance score of 90 or above as good, 50 to 89 as needing improvement and below 50 as poor. Do not chase 100: Lighthouse's own documentation says a perfect score "is extremely challenging to achieve and not expected." The score is a lab estimate, so the Core Web Vitals assessment from real visitors matters more.

Why is my mobile score lower than desktop?

Because the mobile test is much harsher. For mobile, PageSpeed Insights simulates the page load conditions of a mid-tier phone on a mobile network, while the desktop test uses an emulated desktop with a wired connection. The same page has to do the same work with less processing power and a slower connection. Since phones are measured separately, fix mobile first.

Does hosting matter for website speed?

Yes, mainly through server response time. web.dev notes that shared hosting is generally slower and advises making sure "your website's host is capable of handling the traffic you send to it." Better hosting will not fix oversized images or heavy scripts, but on a slow host every page starts late. Check server response before paying for an upgrade.

Why does my score change every time I test?

Some movement is normal. Lighthouse's documentation says "A lot of the variability in your overall Performance score and metric values is not due to Lighthouse." Google lists local network availability, the test machine's hardware and other work competing for it as causes. Run the test a few times, look at the typical result and base decisions on field data.

Sources

  1. Understanding Core Web Vitals and Google search results, Google Search Central
  2. Understanding page experience in Google Search results, Google Search Central
  3. Web Vitals, web.dev
  4. Core Web Vitals report, Search Console Help
  5. About PageSpeed Insights, Google for Developers
  6. Lighthouse performance scoring, Chrome for Developers
  7. Optimize Largest Contentful Paint, web.dev
  8. Optimize Cumulative Layout Shift, web.dev
  9. Choose the right image format, web.dev
  10. Browser-level image lazy loading for the web, web.dev
  11. Best practices for fonts, web.dev
  12. Efficiently load third-party JavaScript, web.dev
  13. Optimize Interaction to Next Paint, web.dev
  14. Optimize Time to First Byte, web.dev
  15. Eliminate render-blocking resources, Chrome for Developers

Keep reading

Tell me about your website

A 20-minute video call, no slides and no pressure. Bring your current site or your plan, and you'll leave with the three changes I'd make first, whether or not we work together.

Chat