The cost of waiting
Research from Google shows that as page load time increases from 1 to 3 seconds, the probability of a user bouncing increases by 32%. From 1 to 5 seconds, that number jumps to 90%. Users don't wait for slow sites. They leave, they don't come back, and they cost you whatever conversion was waiting on the other side of that load.
Speed isn't a feature. It's the baseline expectation. And on the modern web, where users are conditioned by instant-loading native apps and sub-second social feeds, even small delays feel enormous.
Where the weight lives
Images
Images are typically the heaviest assets on a web page. An unoptimized JPEG hero image can weigh 2-5 MB. The same image in WebP or AVIF format, properly sized for the viewport, might weigh 100-200 KB. That single optimization can cut page weight by 90%.
Use the <picture> element or srcset to serve different sizes at different breakpoints. Set explicit width and height attributes to prevent layout shifts. Lazy-load images below the fold with loading="lazy", but eagerly load the hero image that defines your LCP.
JavaScript
Third-party scripts are the silent killers of page speed. Analytics, chat widgets, A/B testing tools, ad networks, social embeds. Each one adds network requests, parsing time, and main-thread work. Audit every script on your page and ask: is this providing enough value to justify the performance cost?
For your own JavaScript, use code splitting to load only what the current page needs. Defer non-critical scripts. Avoid render-blocking JavaScript in the <head> unless it's genuinely needed for above-the-fold content.
CSS
Large CSS files block rendering. The browser won't paint anything until it has parsed all the CSS. Extract critical CSS for above-the-fold content and inline it. Load the remaining CSS asynchronously. Remove unused CSS with tools like PurgeCSS or Tailwind's built-in tree-shaking.
Web fonts
Custom fonts add visual polish but come with a performance cost. Each font weight and style is a separate file. Use font-display: swap to show text immediately with a fallback font while the custom font loads. Subset fonts to include only the characters you actually use. And limit yourself to two or three font files. Diminishing returns set in quickly.
Server-side speed
Client-side optimizations matter, but they can't compensate for a slow server. Time to First Byte (TTFB), which measures how long the server takes to respond, sets the floor for every other metric. A TTFB over 600ms makes it nearly impossible to achieve a good LCP.
Server-side caching, CDN distribution, efficient database queries, and proper hosting infrastructure all contribute to fast TTFB. If your pages are dynamically generated, consider static caching or incremental static regeneration for content that doesn't change on every request.
Measuring and monitoring
Performance degrades over time. New features, additional scripts, larger images. Each addition chips away at your speed budget. Regular monitoring catches regressions before they compound.
Google's PageSpeed Insights provides both lab data (synthetic testing) and field data (real user metrics). eiSEO combines performance signals with SEO and accessibility analysis, giving you a unified view of site health rather than siloed metrics.
Speed is a commitment
Fast pages don't happen by accident and they don't stay fast without attention. Performance is a continuous commitment, a practice like tending a field. The harvest comes in faster, the yields are better, and the people you're growing it for actually stick around to enjoy it.