Why does page speed affect SEO?
Google cares about page speed for two reasons:
- User experience: Slow pages frustrate users. Studies show that 53% of mobile users abandon a page that takes longer than 3 seconds to load. Google's job is to recommend good results, and a page that users abandon instantly is not a good result.
- Direct ranking signal: Since the Page Experience update (2021-2022), Core Web Vitals are an explicit ranking signal. Pages with "Good" scores get a slight ranking boost; pages with "Poor" scores get a slight ranking penalty.
It's worth noting: speed is one of many ranking signals and isn't as powerful as content quality or backlinks. But when two pages are close in quality, speed can be the tiebreaker. And speed directly impacts conversion rates — even a 1-second improvement can lift conversions by 7%.
Core Web Vitals: the three metrics that matter
Google measures page experience using three Core Web Vitals:
1. Largest Contentful Paint (LCP)
Measures how long it takes for the largest visible element (usually a hero image or headline) to appear. This is the user's perception of "when did the page show me something useful?"
- Good: under 2.5 seconds
- Needs improvement: 2.5–4 seconds
- Poor: over 4 seconds
2. Interaction to Next Paint (INP)
Replaced First Input Delay (FID) in 2024. Measures the page's responsiveness to user interactions (clicks, taps, keyboard input).
- Good: under 200ms
- Needs improvement: 200–500ms
- Poor: over 500ms
3. Cumulative Layout Shift (CLS)
Measures unexpected visual movement — when elements jump around as the page loads (images pushing text down, ads appearing unexpectedly).
- Good: under 0.1
- Needs improvement: 0.1–0.25
- Poor: over 0.25
Other speed metrics you'll see in tools
Beyond Core Web Vitals, you'll see these metrics in speed tools:
First Contentful Paint (FCP): When the first text or image appears. Users perceive FCP as "it's starting to load." Good: under 1.8s.
Time to First Byte (TTFB): How long before the server starts sending data. Affected by server performance and hosting. Good: under 800ms.
Page Load Time: Total time until the page is fully loaded (all resources). Less user-centric than LCP, but useful for understanding overall performance.
DOM Content Loaded: When the HTML is fully parsed (but external resources might still be loading).
Total Transfer Size: Total size of all resources (HTML, CSS, JS, images, fonts). Larger = slower, especially on mobile connections.
The biggest causes of slow pages
Understanding the causes helps you prioritize fixes:
1. Unoptimized images — The most common cause. A 4MB hero image takes seconds to download. Compress images, use WebP format, and set appropriate dimensions.
2. Too much JavaScript — JavaScript blocks the browser from rendering the page. Large JS bundles (especially unneeded third-party scripts) delay interactive time significantly.
3. No caching — Every visit downloads everything fresh. Proper cache headers make repeat visits near-instant.
4. Slow server / hosting — Cheap shared hosting can have TTFB of 2+ seconds before any content arrives. Consider upgrading to SSD hosting, a CDN, or a faster plan.
5. Render-blocking CSS and JS — Scripts and stylesheets loaded in the <head> block rendering until they're downloaded and parsed.
6. Too many HTTP requests — Every image, font, script, and stylesheet is a separate request. Hundreds of small requests add up.
Quick wins to make your site faster
You don't need to be a developer to implement these:
Compress and resize images: Use tools like Squoosh (squoosh.app) — free, browser-based. Aim for under 200KB per image. Convert to WebP where supported.
Enable lazy loading: Add loading="lazy" to all images below the fold. Zero code complexity, immediate benefit.
Use a CDN: Services like Cloudflare (free tier available) cache your site on servers worldwide, delivering content from the nearest location to each visitor.
Minimize third-party scripts: Every third-party tag (analytics, chat widgets, ad scripts) adds load time. Audit your tag manager — remove anything you don't actively use.
Optimize Google Fonts: Instead of loading 5 font weights, load only the weights you use. Or switch to a system font stack entirely.
Defer non-critical JS: Add defer or async to non-critical script tags so they don't block page rendering.
How to measure your page speed
Several free tools measure page speed:
Google PageSpeed Insights (pagespeed.web.dev): Uses real-world Chrome user data + lab tests. The most authoritative source for Core Web Vitals.
Google Search Console: Shows Core Web Vitals data aggregated across your entire site, using real user data.
Chrome DevTools (Lighthouse): Press F12, go to "Lighthouse," run an audit. Detailed lab measurements with specific recommendations.
GTmetrix: Waterfall chart shows which resources are slow. Great for diagnosing specific bottlenecks.
One important note: speed varies by connection type and device. Always test on both desktop and mobile — mobile results are almost always worse, and Google primarily uses mobile speed for ranking.
Hawk Eye does this instantly
Hawk Eye's Speed module reads the browser's Navigation Timing API and Paint Timing API — the same data source used by Chrome DevTools and Lighthouse — to give you real measurements from your actual visit: Page Load Time, DOM Content Loaded, First Paint, First Contentful Paint, DOM Interactive, total resources loaded, and total transfer size. Color-coded indicators (green/amber/red) make it instant to spot problems.
Add Hawk Eye to Chrome — FreeKey Takeaways
- Core Web Vitals (LCP, INP, CLS) are official Google ranking signals since 2021.
- LCP should be under 2.5 seconds — the hero image is usually the culprit when it's slow.
- Unoptimized images are the #1 cause of slow pages — compress to WebP and aim under 200KB.
- Test speed with Google PageSpeed Insights, not just Chrome DevTools, to see real-world user data.
- Mobile speed matters more — Google uses mobile performance for ranking.