Page Speed Optimisation: A Practical Guide for Business Websites

Key Takeaways

• A one-second delay in page load time can reduce conversions by up to 7%, making speed a direct revenue issue, not just a technical one.
• Google uses Core Web Vitals as a confirmed ranking factor — sites that fail LCP, INP, and CLS benchmarks are at a measurable SEO disadvantage.
• Images account for the majority of page weight on most business websites; switching to WebP or AVIF formats typically cuts image file sizes by 25–34% compared to JPEG (Google WebP study) with no visible quality loss.
• Third-party scripts (chat widgets, analytics, ad trackers) are among the most common hidden causes of slow load times — a structured audit can often recover 1–2 seconds without any design changes.

How fast does your website need to be? If you ask most business owners, they'll say "fast" — but that doesn't tell you much. The question that actually matters is: how fast do your visitors expect it to be?

According to research by Google, 53% of mobile users will abandon a page that takes longer than three seconds to load. For a business website, that isn't a technical metric — it's lost revenue walking out the door before you've had a chance to say hello.

Page speed optimisation is one of the highest-return improvements you can make to an existing website. Unlike a full redesign, many speed improvements can be made without touching a single word of content or altering the visual design at all. Yet it's consistently overlooked by small and medium businesses, often because the causes aren't visible to the naked eye.

This guide covers everything you need to know: why speed matters, how to measure it accurately, and the practical steps you can take — from image formats to server configuration — to make your website meaningfully faster.

Why Does Page Speed Matter for Business Websites?

Speed sits at the intersection of user experience, SEO, and commercial performance. Improving it tends to improve all three simultaneously.

What does slow actually cost you?

The evidence is clear and consistent across industries. Portent's speed-revenue research found that the highest-converting e-commerce sites load in one second or under, with conversion rates dropping roughly 4.42% for every additional second of load time between seconds one and five. For a detailed breakdown of how speed directly affects e-commerce revenue, see our post on e-commerce website speed and conversion.

For service businesses — consultancies, agencies, healthcare practices, trades — the dynamic is slightly different but the stakes are just as real. A slow website communicates something to visitors before they've read a single word: this business doesn't take care of the details. That first impression shapes whether a visitor trusts you enough to pick up the phone.

Speed as a ranking signal

Google confirmed Core Web Vitals as a ranking factor in 2021 and has continued to refine the signals. The three metrics that matter most are:

• Largest Contentful Paint (LCP): How quickly does the main visible content load? Target: under 2.5 seconds.
• Interaction to Next Paint (INP): How responsive is the page to user input? Target: under 200 milliseconds.
• Cumulative Layout Shift (CLS): Does the page jump around as it loads? Target: under 0.1.

For a fuller breakdown of what these metrics mean and how they're calculated, our post on Core Web Vitals explained covers each one in detail.

Failing these benchmarks doesn't mean an automatic ranking penalty, but it does mean you're competing at a disadvantage against sites that pass them — particularly in competitive local markets where other signals are closely matched.

How to Measure Your Page Speed Accurately

Before you optimise anything, you need an accurate baseline. There are three tools worth knowing.

Google PageSpeed Insights

PageSpeed Insights is the most widely used tool and the one most directly tied to Google's own assessment of your page. It provides both lab data (simulated) and field data (real user experience from the Chrome User Experience Report). Field data takes 28 days to accumulate, so if your site is new or recently changed, you may only see lab data initially.

The output is scored from 0–100. Aim for 90+ on desktop and 70+ on mobile. Mobile scores are typically lower because the tool simulates a mid-range device on a throttled connection — which is closer to real-world conditions than many people assume.

GTmetrix

GTmetrix gives you a waterfall chart showing exactly which resources are loading, in what order, and how long each takes. This is invaluable for identifying which specific files are slowing your page down. You can also test from multiple locations, which matters if your audience is geographically distributed.

WebPageTest

WebPageTest is the most powerful of the three and is favoured by developers. It supports advanced testing scenarios including multi-step journeys, repeat view testing (to measure caching effectiveness), and filmstrip view (showing exactly what the page looks like at each 100ms interval during load).

Run tests on all three tools before you start any optimisation work. Record your baseline scores. Then re-test after each change so you can attribute improvements accurately.

Image Optimisation: The Biggest Win for Most Websites

Images are typically the single largest contributor to page weight. On the average business website, they account for 50–70% of total page size. Optimising them is usually where the biggest speed gains come from.

Switch to modern formats: WebP and AVIF

JPEG and PNG have been the web standard for decades, but they're not efficient by modern standards. WebP — developed by Google — offers roughly 25–35% smaller file sizes than JPEG at equivalent visual quality. AVIF, the newer format, can achieve 50% smaller files than JPEG and is now supported by all major browsers.

The practical approach for most business websites is to serve WebP as the default and keep JPEG/PNG as a fallback for older browsers. If you're on a modern CMS or framework, this can often be handled automatically. Next.js, for example, serves WebP or AVIF automatically via its `<Image>` component — one of the reasons we build on it.

Use responsive images

Serving a 2,000px wide image to a mobile user viewing a 375px screen is wasteful. The browser downloads the full image then scales it down — wasting bandwidth and time. Responsive images use the `srcset` attribute to serve the appropriately sized file for the viewport.

The difference is significant. A hero image that's 800KB at full size might be 120KB when correctly served at mobile dimensions. That's almost 700KB shaved from the first thing a mobile visitor downloads.

Implement lazy loading

Images below the fold — those the visitor hasn't scrolled to yet — don't need to load immediately. Lazy loading defers these images until they're about to enter the viewport. The `loading="lazy"` attribute is now natively supported in all modern browsers and requires no JavaScript library.

Be careful not to lazy load your hero image or any above-the-fold content. These should load immediately, as they directly affect your LCP score.

Compress before upload

Even in modern formats, images should be compressed before upload. Tools like Squoosh (browser-based, free) and ImageOptim (Mac app) let you find the balance between quality and file size before your image ever reaches a server. As a rule of thumb, most web images can be compressed to under 200KB without visible quality loss; hero images should be under 400KB.

Code Optimisation: Reducing What the Browser Has to Parse

After images, the next biggest contributors to slow pages are usually JavaScript and CSS files that are larger than they need to be.

Minification and bundling

Minification removes whitespace, comments, and unnecessary characters from code files. A JavaScript file that's 150KB in development might compress to 60KB minified. Modern build tools — Webpack, Vite, esbuild — handle this automatically, but it's worth verifying your production build is minified and not serving development builds.

Bundling combines multiple small files into fewer larger ones, reducing the number of HTTP requests the browser needs to make. Fewer requests means faster perceived load times, even if the total byte count is similar.

Tree shaking

Tree shaking is the process of removing unused code from your JavaScript bundles. If your project imports a large utility library but only uses three functions from it, tree shaking strips out everything else. This requires a module bundler that supports it (most modern ones do) and ES module syntax.

A common culprit is icon libraries. Importing an entire icon library when you only use twelve icons bloats your bundle significantly. Import only the icons you need.

Critical CSS inlining

The browser needs to download and parse your CSS before it can render the page. If your stylesheet is large, this creates a render-blocking delay. One solution is to identify the CSS required to render above-the-fold content — the "critical CSS" — and inline it directly in the `<head>` of the HTML document. The rest of the stylesheet loads asynchronously.

Tools like Critical automate the extraction process. The performance gain is particularly noticeable on first load and for mobile users on slower connections.

Defer non-critical JavaScript

Scripts that aren't needed for the initial render should be loaded with `defer` or `async` attributes, or moved to the bottom of the `<body>`. This prevents them from blocking the browser's parsing of the HTML document.

Server Optimisation: Making Delivery Faster

Even perfectly optimised code and images will be slow if your server is the bottleneck.

Caching

Caching stores copies of your files so they don't need to be regenerated or re-fetched on every request. There are two main types relevant to business websites:

Browser caching: Tells the browser how long to keep a cached copy of each resource. Static assets — images, fonts, CSS, JS — rarely change and can be cached for months. Your server sends `Cache-Control` headers to instruct the browser.

Server-side caching: For dynamic sites (e.g., WordPress), caching plugins generate static HTML from dynamic pages and serve that directly, bypassing the database query cycle entirely. WP Super Cache and WP Rocket are the most widely used.

Content Delivery Networks (CDNs)

A CDN stores copies of your static assets at servers distributed around the world. When a visitor loads your site, they receive files from the nearest server rather than your origin server. This reduces latency — the time it takes for a request to travel to the server and back.

For UK businesses serving primarily UK audiences, a CDN may seem unnecessary — but even within the UK, edge servers in London, Manchester, and Birmingham meaningfully reduce load times for users far from your hosting location. Cloudflare's free tier is sufficient for most small business sites.

HTTP/2 and HTTP/3

HTTP/2 allows multiple requests to be sent over a single connection simultaneously (multiplexing), significantly improving performance over HTTP/1.1 which handles requests sequentially. HTTP/3 improves further with a different underlying transport protocol. Both are supported by modern hosting providers and are typically enabled by default — but worth verifying, particularly on older hosting accounts.

Server-side compression

Gzip and Brotli compression reduce the size of text-based resources (HTML, CSS, JS) before they're sent to the browser, which decompresses them locally. Brotli typically achieves 15–20% better compression than Gzip. Both should be enabled at the server level — your hosting provider's documentation will explain how for your specific setup.

For a deeper look at how your hosting environment affects performance, our comparison of shared hosting vs managed hosting is worth reading.

Font Optimisation: A Frequently Overlooked Culprit

Custom fonts make a significant difference to brand recognition, but they can also be a meaningful source of render delay if not handled carefully.

Self-host your fonts

Serving fonts from a third-party CDN (including Google Fonts, unless using the `display=swap` parameter) creates an additional DNS lookup and connection before the font can load. Self-hosting fonts — storing them on your own server alongside your other assets — eliminates this dependency.

Use `font-display: swap`

Without `font-display: swap`, the browser will wait for the custom font to load before rendering any text. With it, the browser shows the fallback system font immediately and swaps in the custom font once it's ready. This prevents invisible text during load and improves perceived performance significantly.

Subset your fonts

If you're only using Latin characters and a handful of special characters, there's no reason to download a font file that includes Cyrillic, Greek, and Vietnamese glyph sets. Font subsetting strips out unused glyphs, often reducing font file sizes by 60–80%. Glyphhanger is a useful tool for this.

Preload key fonts

For fonts used in above-the-fold headings, a `<link rel="preload">` hint tells the browser to fetch the font early in the loading process, before it encounters it in the CSS. This prevents a flash of unstyled text on first render.

Third-Party Script Audit: Finding Hidden Performance Drains

Third-party scripts are often the biggest invisible performance drain on business websites. Every script you add — a chat widget, a cookie consent banner, an analytics tag, a social sharing button, a heatmap tool — adds weight, adds network requests, and introduces dependencies you don't control.

What a script audit looks like

Open GTmetrix or WebPageTest and look at the waterfall chart. Filter by third-party domains. Note:

• Which scripts are loading?
• How large are they?
• Are they blocking the main thread?
• Are any of them timing out or loading slowly?

It's common to find scripts that were added years ago for tools no longer in use — old live chat providers, abandoned A/B testing tools, social widgets nobody clicks. Removing these costs nothing and can recover significant performance.

Loading scripts strategically

Scripts that don't affect the initial render should be loaded with a `defer` or `async` attribute, or loaded after user interaction (e.g., the cookie consent banner could trigger a chat widget load only after the user accepts). Next.js provides a `<Script>` component with strategy options (`beforeInteractive`, `afterInteractive`, `lazyOnload`) that make this straightforward.

Google Tag Manager can be a source of performance problems if it's used to load many tags without governance. Audit your GTM container regularly — unused or redundant tags should be removed.

Before and After: What Optimisation Looks Like in Practice

To make this concrete, consider a typical small business WordPress site before and after a focused optimisation sprint.

Before: PageSpeed mobile score 34. LCP 8.2s, INP 420ms, CLS 0.18. Total page weight: 4.2MB. 47 requests. Largest culprits: unoptimised hero image (1.8MB JPEG), render-blocking CSS from three plugin stylesheets, and an abandoned live chat script still loading on every page.

After: PageSpeed mobile score 71. LCP 2.9s, INP 140ms, CLS 0.04. Total page weight: 1.1MB. 28 requests. Changes made: hero image converted to WebP and resized (now 190KB), plugin CSS consolidated and deferred, live chat script removed, caching plugin configured, CDN enabled.

This kind of improvement is achievable without a redesign. The site looks identical. The difference is invisible to the eye but highly visible in the data — and in the experience of every visitor who no longer waits eight seconds for the page to appear.

For a broader look at what contributes to a website that drives business, our post on signs your website is costing you customers is worth a read alongside this guide.

How Does Ongoing Maintenance Affect Page Speed?

A website that's fast on launch day won't necessarily stay fast. Plugins get added, images are uploaded without compression, new scripts accumulate, and hosting environments age. Speed optimisation is not a one-time task — it's part of ongoing website management.

This is one of the core functions of a SiteCare plan — regular monitoring and maintenance to ensure your site continues performing well over time, not just at launch. Our website maintenance guide covers the full scope of what good ongoing site management involves.

If you're not sure where your site currently stands, a website audit is a practical starting point. It surfaces performance issues alongside security, SEO, and accessibility problems — giving you a prioritised list of what to address first.

For sites where performance is deeply constrained by a legacy platform or template, the most pragmatic solution is sometimes a custom website built performance-first from the ground up. If a rebuild also involves moving platforms or domains, our website migration SEO guide covers how to protect your rankings through the transition.

Frequently Asked Questions

What is a good page speed score for a business website?

On Google PageSpeed Insights, aim for 90+ on desktop and 70+ on mobile. Mobile scores are lower across the board because the tool simulates a mid-range device on a throttled connection. A score in the 70s on mobile is generally considered good for a content-rich business site. Anything below 50 on mobile warrants attention. More important than the score itself are the individual Core Web Vitals: LCP under 2.5s, INP under 200ms, and CLS under 0.1.

How much can page speed affect my Google rankings?

Page speed is a confirmed ranking factor via Core Web Vitals, but it's one signal among hundreds. In practice, it's most impactful in competitive niches where other signals (backlinks, content quality, authority) are closely matched between you and your competitors. A site failing Core Web Vitals won't be penalised dramatically, but it will rank below an otherwise equivalent site that passes them. Speed also affects engagement metrics like bounce rate and time on page, which may have indirect effects on rankings.

Can I improve page speed without a developer?

Some improvements are straightforward without technical expertise: installing a caching plugin (WordPress), using an image compression tool before uploading, and removing unused plugins. Others — code minification, server configuration, critical CSS extraction — require developer involvement. A site audit will tell you which changes will have the highest impact, so you can decide whether to DIY or bring in professional help.

Why does my website score differently on desktop vs mobile?

PageSpeed Insights uses different test conditions for desktop and mobile. Mobile testing simulates a mid-tier Android device on a 4G connection with CPU throttling applied. Desktop testing assumes faster hardware and a wired connection. Real-world mobile conditions for many UK users (particularly in rural areas) can be slower than even the simulated test environment, making mobile optimisation particularly important.

How often should I test my page speed?

Test when you make significant changes to your site — adding new sections, installing plugins, changing your theme or framework — and run a quarterly baseline check even when nothing has changed. New plugin updates, third-party script changes, and server environment changes can all affect speed without any action on your part.

Does switching hosting provider improve speed?

It can, significantly. Shared hosting — where your site shares server resources with hundreds of others — is a common cause of slow server response times (TTFB). Moving to managed hosting or a platform with dedicated resources can improve TTFB from 800ms+ to under 200ms, which has a direct knock-on effect on all other load time metrics. Our post on shared hosting vs managed hosting explains the differences in detail.

Related Reading

• Core Web Vitals Explained: What They Mean for Your Website
• Website Maintenance: What It Is and Why It Matters
• Shared Hosting vs Managed Hosting: Which Is Right for Your Business?
• Signs Your Website Is Costing You Customers
• E-commerce Website Speed and Conversion: Why Every Second Counts

Page speed is one of the most tangible, measurable improvements you can make to a business website — and one of the few where the gains show up in both the analytics and the P&L. If you'd like an honest assessment of where your site stands and what the highest-priority improvements are, our website audit is a practical starting point. Or if you're ready to rebuild on a performance-first foundation, get in touch to talk through what a custom website built for speed could look like for your business, or view our pricing to find the right package.