Website Load Time Fixes: The 5 We Ship on Real Sites

Google's web.dev guidance says the largest element on a page should appear within 2.5 seconds of the page starting to load, and on a plumber's homepage that element is usually one oversized photo. Our earlier post on why slow load time costs customers covered the problem. This sequel covers the website load time fixes we actually ship, in the order we ship them, and why that order saves money.

Which Website Load Time Fixes Come First?

We measure before we touch anything. Google's Core Web Vitals thresholds call a page good when Largest Contentful Paint (LCP) is 2.5 seconds or less, Interaction to Next Paint (INP) is 200 milliseconds or less, and Cumulative Layout Shift (CLS) is 0.1 or less, judged at the 75th percentile of page loads.

Those three numbers organize the work. Fixes 1, 4 and 5 below mostly move LCP, fix 2 moves CLS, and fix 3 helps both LCP and INP. Each one costs far less than a rebuild, which is why they come first.

We start with the free 15-minute audit or a full website analysis, run on a phone over mobile data, because that is where your customer is standing when the water heater fails. Our website audit checklist walks through the same steps if you want to try them yourself.

Fix 1: Resize and Re-Encode the Hero Image

The biggest object on most trades homepages is the hero photo of the truck, the crew or the finished kitchen. It usually goes from a camera straight into the page, and CSS squeezes it into place, so a phone downloads far more pixels than it can show.

Here is what we do to it:

• Export it at the largest size it is actually displayed, and serve smaller versions to smaller screens with responsive image markup.
• Convert it to WebP or AVIF. Google's web.dev image format guide says these formats generally compress better than older ones and can ship with a JPEG or PNG fallback.
• Set its fetch priority to high. The LCP optimization guide says it is a good idea to set the fetchpriority attribute to high on an image element you think will be the page's LCP element.
• Never lazy-load it. The same guide says lazy-loading the LCP image always adds unnecessary delay and hurts LCP.

One more trap: page builders often set the hero as a CSS background, which the browser discovers late. The guide says an LCP resource referenced only from external files should be preloaded with high fetch priority. We use a real image element where the theme allows it and add the preload where it does not.

The guide also splits LCP into four parts: about 40% time to first byte, under 10% resource load delay, about 40% resource load duration, and under 10% element render delay. The hero fix attacks the two middle parts.

Fix 2: Reserve Space So the Page Stops Jumping

You have seen it: you reach for Call Now, a banner loads above it, and your thumb lands on something else. That is layout shift, and CLS scores it. Google's layout shift guide names the usual causes: images without dimensions, late-loading ads and embeds, web fonts, and animations.

The fixes are small and specific:

• Add width and height attributes to every image and video, or reserve the space with CSS aspect-ratio.
• Give embeds, review widgets and banners a minimum height so the content below does not move when they arrive.
• Pick a fallback font close to your web font, and use font-display optional where a late font swap would shift text.
• Animate with transform, not with top, left or box-sizing.

The target is a CLS of 0.1 or less for at least 75% of page visits. A sticky call bar or cookie notice is the first place we look on a trades site, because both load after the main content and can push everything down.

Fix 3: Cut or Delay Third-Party Scripts

Chat widgets, review badges, call tracking, ad pixels, scheduling tools and map embeds each load code from someone else's server. Ten small scripts add up to a slow page, and you rarely notice because each was installed on a different day.

We list every script in the browser's network panel and ask one question per line: who uses this? Leftovers from an old agency or an abandoned tool get deleted. This is routine work inside our web design and development projects.

Scripts you keep get loaded properly. Google's third-party JavaScript guide explains that async runs a script as soon as it downloads, while defer waits until HTML parsing finishes, and that a preconnect hint to a critical third-party origin can save 100 to 500 ms.

The same guide reports that Telegraph deferred all its scripts, including ads and analytics, and improved ad loading time by an average of four seconds. That is a publisher with far more scripts than your site has, so treat it as proof the method works, not as a forecast for your page.

We keep call tracking, because it tells you which marketing produces phone calls. Map and video embeds become click-to-load placeholders, so the heavy code arrives only when a customer asks for it.

Fix 4: Speed Up the Server Before Touching Code

Go back to the LCP split above: about 40% of the budget is time to first byte, according to web.dev. If your server takes too long to answer, no image trick can win that time back.

Server delay usually comes from three places:

• No page caching, so the server builds each page from the database on every visit instead of handing over a ready-made one.
• No content delivery network, so images and files travel from far away instead of from a location near your Los Angeles customers.
• A hosting plan too small for your traffic, plus heavy plugins that slow every request.

Run PageSpeed Insights before and after, and compare the server response figure. If it does not move, the plan or the platform is the problem. Speed work sits next to our on-page SEO service because both start with a clean, fast page structure.

Fix 5: Lazy-Load Only What Sits Below the Fold

Lazy loading tells the browser to wait on an image until the customer scrolls near it. It is perfect for a gallery of finished jobs and wrong for anything on screen at the start.

Web.dev's guide to browser-level lazy loading says not to lazy-load images likely to be in the viewport when the page loads, especially LCP images. It also explains that browsers start loading a lazy image once it is within a set distance of the viewport: 1250 pixels on a 4G connection and 2500 pixels on 3G or slower.

The same guide reports that on 4G, 97.5% of lazy-loaded images were fully loaded within 10 ms of becoming visible. That is why photos below the first screen are safe candidates.

Our rule is simple: the first screen loads eagerly, everything below it waits. The same rule applies to embedded videos and the service area map at the bottom of the page.

When Website Load Time Fixes Are Not Enough

Sometimes all five are done and the phone test still fails. Then the weight is built into the site: a bloated theme, a page builder that outputs heavy markup, or years of plugins stacked on each other. Patching that is slow work with a poor payoff.

Change one thing at a time and retest after each, so you know which fix worked. Our guide to what a contractor website costs shows what a rebuild involves.

If a rebuild is the answer, the Growth website package is $1,499 one-time and a typical launch takes 3 weeks. It includes custom design, mobile responsive layouts, on-page SEO, Google Analytics and call tracking setup, and 2 rounds of QA testing.