Website speed is one of those things business owners don't notice: they have fast internet, a powerful laptop, and the site has long been sitting in their browser cache. A customer opens the same page on their phone on a train and sees a blank screen, jumping buttons, and a menu that doesn't respond to taps. They don't wait. They go back to search and open a competitor.
Below we look at how speed is tied to leads, advertising, and rankings, what the Core Web Vitals metrics mean, how to check your site's speed, and what usually slows it down. At the end there's a step-by-step plan and a checklist you can go through with your developer.
Why page speed affects leads
A lead comes from someone who waited for the page, understood the offer, and made it to the form. A slow site gets in the way at every step: some visitors leave before the first screen appears, others when a button doesn't respond or the form shifts under their finger.
- Visitors leave. The longer the blank screen, the more people close the tab, especially on mobile connections where delays are more noticeable.
- Ads get more expensive. You pay for a click in Google Ads or Meta Ads even if the page never finished loading. A slow landing page turns part of your budget into bounces. In Google Ads, landing page experience is also part of an ad's Quality Score.
- Trust suffers. A site that stutters and freezes feels sloppy, and that impression carries over to the company.
That's why speed is part of conversion, not a technical detail. It makes sense to start speeding up the pages your ads point to and where your leads come from.
How speed is tied to Google rankings
Google explicitly lists Core Web Vitals among the page experience signals its ranking systems take into account. At the same time, Google itself stresses that good scores don't guarantee high rankings, and relevance to the query remains the main factor. Speed helps when everything else is equal more than it pulls a weak page to the top.
There's an indirect effect too. Search engines pay attention to how people interact with results, and slow loading makes that interaction worse: more people bounce back to the results page, fewer pages get viewed. So speeding up a site helps with search beyond the official signal, though it's more honest to call that influence indirect.
A fast site won't overtake a competitor on its own, but a slow one easily loses what your content and ads have earned.
Core Web Vitals: LCP, INP, and CLS
Core Web Vitals are the three metrics Google uses to describe how a person experiences a page loading. In 2024, INP replaced the older FID metric, so older articles may list a different set.
- LCP (Largest Contentful Paint): when the largest element above the fold appears on screen, usually the hero image, a banner, or the headline. It answers the question "when did the page load?"
- INP (Interaction to Next Paint): how quickly the page responds to taps, clicks, and keyboard input. A poor INP is a menu that opens with a lag, or a button that does nothing when you press it.
- CLS (Cumulative Layout Shift): how much elements jump around while loading. A classic example: someone aims for a button, a banner loads above it, and they tap the wrong thing.
| Metric | Good | Needs improvement | Poor |
|---|---|---|---|
| LCP: main element loads | up to 2.5 s | 2.5–4 s | over 4 s |
| INP: response to input | up to 200 ms | 200–500 ms | over 500 ms |
| CLS: layout shift | up to 0.1 | 0.1–0.25 | over 0.25 |
Google evaluates the metrics at the 75th percentile: a page counts as good if at least three out of four visits meet the threshold. Mobile and desktop data are assessed separately, and mobile is almost always worse.
Lab data vs. real-user data
Speed is measured in two ways, and mixing them up is a common source of wrong conclusions.
Lab data is a test of a single page load under set conditions: a specific device, network speed, no cache. Lighthouse and the lower part of the PageSpeed Insights report show it. The test is reproducible and explains causes in detail, but it describes one artificial scenario.
Real-user data is collected from actual visits. Google's main source is CrUX (Chrome User Experience Report): statistics from the Chrome browser over the last 28 days. You'll see it at the top of PageSpeed Insights and in the Core Web Vitals report in Search Console, which groups similar pages. You can also send Core Web Vitals from your own visitors to Google Analytics using Google's web-vitals library.
How to check your website's speed
Free tools cover most needs. Each one answers its own question.
- PageSpeed Insights. The place to start: it shows CrUX data for the page and the site, a lab measurement, and a list of recommendations. Check not just the homepage but service pages, the catalog, and product pages too.
- Lighthouse. The same engine, built into Chrome (the Lighthouse tab in DevTools). Handy for checking a page before it's published or on a staging server.
- WebPageTest. An in-depth test from different locations, browsers, and network types. It shows a waterfall chart (which file blocks rendering, and when) and a video of the screen filling in.
- The Network tab in your browser. A list of every request the page makes, with size and timing. This is where you quickly spot a multi-megabyte image, a dozen fonts, or a chat script loading before the content.
What slows a site down and how to fix it
Images
The most common cause of a slow LCP is heavy images: stock photos weighing several megabytes, a 4,000-pixel-wide banner served to a phone, PNG where a compressed format would do.
- Serve images in modern formats like WebP or AVIF: at the same quality they're usually much lighter than JPEG and PNG.
- Prepare several sizes and list them in srcset so a phone doesn't download the version meant for a large monitor.
- Use loading="lazy" for images below the fold, and load the main above-the-fold image right away.
- Set width and height on images so the browser reserves space in advance and the layout doesn't jump.
That's how the covers on our blog work: if the browser supports WebP, the server sends that format, and the cards use srcset with two sizes, so a phone picks the lighter version.
Fonts
Until a font loads, the browser may not show text at all. font-display: swap helps: text appears immediately in a system font and is swapped when the brand font is ready. Preload the main weight, drop the weights you don't use, and subset the font to the characters you actually need, such as Latin letters and digits. A subset like that weighs several times less than the full file.
Third-party scripts
A live chat, a callback widget, a quiz, several analytics tags, ad pixels, a map: each one feels light on its own, but together they hog the phone's CPU and hurt INP. Do an audit: which of these are actually used and actually bring in leads? Load the rest with a delay, after the main content or on the user's first interaction.
Heavy libraries and animations
Big JavaScript libraries pulled in for a single slider, animations on every block, a background video in the hero. All of it has to be downloaded and executed before the page becomes responsive. Build animations on transform and opacity, which browsers handle cheaply, and split code into chunks that load only where they're needed.
Hosting and TTFB
TTFB is time to first byte, how long the server takes to start responding. While the server is thinking, the browser has nothing to show, and no amount of image optimization makes up for it. Google's benchmark is under 0.8 seconds. Causes of a slow TTFB: overloaded cheap hosting, heavy database queries, no page cache, a server far from your visitors.
Caching, CDN, and compression
Static files (images, styles, scripts, fonts) should be cached in the browser for a long time so they aren't downloaded again on a repeat visit. A CDN serves them from servers closer to the user. The server should compress text files with gzip or Brotli: it's a configuration setting and cuts the amount of data transferred almost for free. For sites where pages rarely change, static generation works well: ready-made HTML is served instantly, with no computation on the server.
Website speed optimization: the order of work
Speeding up a site pays off when you go from measurement to cause, not from a list of tips found online.
- Pick the key pages. The homepage, ad landing pages, service pages, the catalog, a product page: the pages that bring in leads and revenue.
- Capture a baseline. Real-user data from PageSpeed Insights and Search Console plus a lab measurement. Write the numbers down so you have something to compare against.
- Find the causes. For each poor metric, figure out what's dragging it down: which element is the LCP, which script blocks responsiveness, what shifts the layout.
- Fix the cheapest, most visible things first. Usually images, unnecessary third-party scripts, fonts, compression, and caching.
- Move on to the server and code. Hosting, page caching, heavy libraries, rendering. This costs more, so first make sure the quick wins are exhausted.
- Verify the result and lock it in. CrUX data updates over 28 days, so the effect doesn't show up in reports right away. From then on, check speed after every update.
The main rule: measure first, then fix, then measure again. Otherwise it's easy to spend a week on something that never affected speed.
When we build websites, speed is part of the project from the start: image formats and sizes, fonts, deferred widget loading, server-side rendering. You can see examples of our sites in our projects.
Checklist: how to speed up a website
- Core Web Vitals checked on key pages using real-user data, separately for mobile.
- Images served in WebP or AVIF, in several sizes via srcset.
- Images below the fold lazy-load; the main image loads right away.
- Images, banners, and embeds have set dimensions, so the layout doesn't jump.
- Fonts use font-display, the main weight is preloaded, unused characters and weights are removed.
- Chats, widgets, analytics tags, and pixels audited; the remaining ones load with a delay.
- No heavy libraries for a single feature; animations don't strain the CPU.
- Server response time (TTFB) is within the norm; page caching is on.
- Static files are cached in the browser; a CDN is connected if needed.
- gzip or Brotli compression is on.
- Speed is checked after every site update and every new widget.
FAQ
What page load speed counts as good?
The benchmark is Google's Core Web Vitals thresholds: the main page element appears within 2.5 seconds, the response to an interaction takes no more than 200 milliseconds, and layout shift stays under 0.1. Judge by real-user data, and not just averages: the thresholds should hold for 75% of visits, including mobile.
Why does PageSpeed Insights give a different score every time?
The lab test loads the page from scratch each time, and network speed, server load, and third-party scripts vary from run to run. So the score drifts by a few points. Compare the median of several runs and look at the real-user data block, which is more stable.
Will speeding up my site boost my rankings on its own?
Don't count on it. Speed is one of many signals, and relevance to the query matters more. But a slow site hurts visitor behavior: people leave more often, view fewer pages, and submit fewer requests, and search engines pay attention to user experience. So speeding up helps with search too, but don't expect miracles in rankings from it alone.
Can I speed up a site built on a website builder or an off-the-shelf CMS?
Partly. Almost everywhere you can compress images, remove unnecessary widgets and tags, turn on caching, and connect a CDN. But if the template or platform itself is slow, your options are limited: you can't always replace a heavy theme or shared hosting. Then it's worth weighing whether to keep optimizing or move the site.
How often should I check my site's speed?
After every noticeable update: a new block on the homepage, a widget, an analytics tag, an ad pixel. Otherwise, checking the Core Web Vitals report in Search Console and PageSpeed Insights for key pages once a month is enough. New problems most often arrive together with new third-party scripts.




