Website speed is not a technical vanity metric. It decides whether a visitor waits for your page to appear, whether Google is comfortable ranking it against a faster competitor, and whether the visit turns into a call or a filled-in form. If your Cleveland business website takes longer than about three seconds to become useful on a phone, that is a cost you are paying every day it stays that way.
This is the practical version. What page speed is measured by now, what good looks like as a number, why sites get slow, and the order to fix things in so you are not shaving two hundred milliseconds off a script while a four megabyte hero image sits untouched at the top of the homepage.
What slow page speed costs you.
The figures that circulate in this industry are worth knowing and worth holding loosely. Around 53 percent of mobile visits are said to be abandoned when a page takes longer than three seconds. A one second delay in page response is commonly quoted as a 7 percent reduction in conversions. Amazon once calculated that a one second slowdown would cost the company $1.6 billion a year. Those numbers are old, they are averages across enormous samples, and not one of them was measured on your site. Quote them if you like, but do not build a business case on them.
What survives the caveats is the direction of travel. Waiting is friction, and on a phone in a parking lot on two bars of signal that friction is far worse than it looks on the office fiber connection where you last checked the site. Your slowest pages have the most to gain, and the gain shows up as inquiries rather than as a score out of a hundred.
Speed sits underneath everything else you spend money on. Paid traffic lands on a slow page and some of it leaves before anything renders, so you pay twice. It sits underneath the rest of the search work too, because the quickest way to waste a hard-won ranking is to win the click and lose the visitor in the first two seconds.
Core Web Vitals are the scoreboard Google uses.
Google assesses page experience with three metrics, collectively called Core Web Vitals. They cover loading, responsiveness and visual stability. A page passes when it meets the recommended target for all three at the 75th percentile of real visits, meaning three quarters of your visitors have to get the good experience.
| Metric | What it measures | Good | Needs improvement | Poor |
|---|---|---|---|---|
| Largest Contentful Paint (LCP) | Time until the largest visible element in the viewport renders | 2.5 seconds or less | 2.5 to 4.0 seconds | Over 4.0 seconds |
| Interaction to Next Paint (INP) | Time to paint a visual response after a tap, click or key press | 200 milliseconds or less | 200 to 500 milliseconds | Over 500 milliseconds |
| Cumulative Layout Shift (CLS) | How much visible content moves unexpectedly during the visit | 0.1 or less | 0.1 to 0.25 | Over 0.25 |
The 75th percentile detail matters more than most people realize. A site can look healthy in a desktop test and still fail, because the quarter of visitors on three year old Android phones over a mobile network are the ones setting the number.
Largest Contentful Paint measures when the page looks loaded.
LCP marks the moment the largest visible element in the viewport finishes rendering. On most business sites that is the hero image or the headline block on top of it. Good is 2.5 seconds or less. Four things dominate it: how long the server takes to return the first byte, whether CSS and JavaScript block the browser before it may paint, how many bytes the hero image weighs, and whether that image was discovered late because a slider script had to run first.
Interaction to Next Paint measures whether the page answers you.
INP measures how long the page takes to paint a visual response after an interaction, across the whole visit, and reports close to the worst of those interactions rather than the first. Good is 200 milliseconds or less. It replaced First Input Delay, which only looked at the first interaction and flattered pages that became sluggish once the visitor started using them. If a mobile menu takes half a second to open after a tap, INP catches it. The usual cause is long JavaScript tasks holding the main thread.
Cumulative Layout Shift measures things moving under your thumb.
CLS scores how much visible content jumps around while the page loads and while it is used. Good is 0.1 or less. The causes are boring and fixable: images and iframes without width and height attributes, embed slots with no space reserved, cookie banners injected above the content after first paint, and fonts that swap in at a different size to the fallback.
Field data and lab data answer different questions.
Field data is what real Chrome users experienced on your site over a trailing 28 day window, collected in the Chrome User Experience Report. Lab data is one simulated load on a fixed device profile and a throttled connection. Field data tells you whether you have a problem. Lab data tells you what is causing it, and being repeatable it is what you work against while fixing.
Two consequences follow. A low traffic page may have no field data of its own, in which case the assessment falls back to the group of similar pages, so one neglected template can drag its neighbors down. And field data lags by design, so do not judge a fix after 48 hours and conclude nothing happened.
How to measure your own site properly.
- PageSpeed Insights. Paste in a URL. The top of the report is field data from real visitors, if Google has enough of it. The bottom is a fresh Lighthouse lab run. Test more than the homepage: the top service page, the contact page and the busiest blog post behave very differently.
- The Core Web Vitals report in Search Console. The site-wide view. It groups URLs by template and reports how many are good, need improvement or are poor, split by mobile and desktop. Start with mobile, the version most of your visitors are on.
- Lighthouse in Chrome DevTools. Run it locally with mobile emulation and CPU throttling on. The diagnostics list and the JavaScript treemap name the specific file costing you the time, which is the part PageSpeed Insights summarizes rather than itemizes.
- A real phone on a real network. Borrow a mid-range Android handset, turn off the office wifi, and load the site the way a customer standing outside your building would. This catches what no lab profile does: fonts that flash, sticky headers that swallow half the screen, taps that do not register.
- Re-measure after each change. Bundling six fixes into one deployment means you learn nothing about which one mattered, and if something breaks you unpick all six.
Why sites get slow. The usual causes.
- Uncompressed images. The most common problem on small business sites. A photo straight off a phone is often 3,000 to 6,000 pixels wide and several megabytes, displayed in a slot 800 pixels across. The browser downloads every byte, then throws most of them away.
- No modern image formats. AVIF and WebP produce far smaller files than JPEG or PNG at the same visual quality. If the site serves nothing but JPEG and PNG, there is easy weight to lose before anyone touches code.
- Render blocking CSS and JavaScript. Stylesheets and scripts in the document head stop the browser painting until they are fetched and parsed. Page builders tend to load one large stylesheet covering every feature the theme has ever offered, on every page.
- Too many plugins. Each adds its own stylesheet and script to every page whether or not the page uses the feature. A contact form loading on a blog post, a slider loading on the contact page, and analytics firing three times through different integrations are all normal findings.
- No caching. Without page caching, every visit rebuilds the page from the database. Without browser caching headers, returning visitors re-download assets that have not changed. Without a CDN, someone in Mentor and someone in Denver pull every asset from the same origin server.
- Shared hosting. The cheapest tiers put hundreds of sites on one machine, and a slow time to first byte caps everything downstream. If the server takes 1.2 seconds to send the first byte, a 2.5 second LCP is close to impossible however good the front end is.
- Third party scripts and tag managers. Chat widgets, heat maps, review carousels, remarketing pixels and social embeds all run code you did not write on a schedule you do not control. Tag containers accumulate tags nobody has audited in three years.
- Web fonts. Four weights and two styles loaded when the design uses two of them, nothing self-hosted so every font is a separate connection to another domain, and the display behavior left unset so text flashes or stays invisible while the font arrives.
A worked example, with the arithmetic.
Take a hero image on a Cleveland contractor site: a 3.8 MB JPEG exported at 4,000 pixels wide, at the top of the homepage. On a 10 Mbps mobile connection, 3.8 MB is about 30.4 megabits, so the transfer alone takes roughly three seconds before the browser can finish painting it. Because it is the largest element in the viewport, that transfer time is the LCP.
Resize the same image to 1,600 pixels wide, which is all a desktop hero needs, and export it as AVIF. Files in that range commonly land around 150 to 250 KB. Call it 180 KB, about 1.44 megabits, or roughly 0.14 seconds on the same connection. Add a smaller variant for phones through a srcset, preload it, and the page that spent three seconds waiting now spends a fraction of one. Nothing about the design changed.
Multiply that across twenty project photos on a portfolio page and it becomes clear why image handling is the first thing worth auditing on almost any site, and why building mobile first is a performance decision rather than a style preference.
The fix list, in order.
- Fix the server response first. Measure time to first byte. If it sits consistently over about 800 milliseconds, move hosting before optimizing anything else, because every other improvement stacks on top of that delay.
- Turn on page caching and a CDN. On WordPress that is usually one well-configured caching plugin plus a CDN in front. Largest improvement available for the least work.
- Resize, compress and convert every image. Serve at the dimensions used, in AVIF or WebP, with width and height set so nothing shifts.
- Preload the hero image and lazy load everything below the fold. The LCP element should never be lazy loaded, and everything the visitor has not scrolled to yet should be.
- Audit the plugin list. Deactivate what is unused and replace anything that loads assets site-wide for a feature used on one page. A plugin being free to install does not make it free to run.
- Cut and defer JavaScript. Defer what is not needed for first paint, remove duplicated libraries, and take the tag manager apart tag by tag. Most sites carry at least one script for a tool nobody uses any more.
- Trim the CSS. Drop stylesheets for features the page does not use and inline the little that is needed to paint the top of it.
- Fix the fonts. Self-host, subset to the characters you need, load only the weights the design uses, and set the display behavior so text stays readable while loading.
- Reserve space for anything that arrives late. Embeds, review widgets and banners need dimensions declared in advance.
- Re-measure in the field, then set a schedule. Check the Search Console report monthly. Performance decays quietly as content and tags accumulate, so treat it as maintenance, not a project with an end date.
When speed is a symptom of the build.
Sometimes the honest answer is that the site cannot get fast. A page builder that ships a hundred kilobytes of CSS to render a two column layout, or a template stack three vendors deep, will resist every fix and undo half of them at the next update. At that point a redesign that starts from performance is cheaper than another round of patching.
Our builds are hand-coded rather than assembled from a page builder, which is most of the reason they load quickly, whether the project is a small business site, a WordPress build or a custom development project. Packages start at $2,000 for a one day build and run to $12,000 for fully custom work.
What to do next.
Run your homepage, your busiest service page and your contact page through PageSpeed Insights and write down the three field metrics for each on mobile. If any sit in the poor band, work down the fix list above in order rather than starting with whatever the tool listed first. If you would rather someone else read the report, send us the domain and we will tell you what is slowing it down.

