What a Technical SEO Audit Actually Checks (And What You Can Fix Today)
A technical SEO audit isn't a black box. It checks specific, measurable things — and most of the highest-impact fixes take less than a day.
seo • Updated • 6 min read
Core Web Vitals: The Practical Fixes That Actually Move the Needle
Most Core Web Vitals advice tells you what the metrics are. This post tells you how to fix them — with the specific changes that produce the biggest improvements for the least effort.
Google uses three Core Web Vitals as ranking signals: Largest Contentful Paint (LCP), Interaction to Next Paint (INP), and Cumulative Layout Shift (CLS). Together, they measure how fast your page loads, how quickly it responds to interaction, and how visually stable it is during loading.
Most guides explain what these metrics are. This post explains how to fix them — ranked by impact per hour of effort, based on what we've measured across the sites we manage.
The metrics in 30 seconds
LCP (Largest Contentful Paint): How long until the biggest visible element renders. Target: under 2.5 seconds. This is usually a hero image, a heading, or a large text block.
INP (Interaction to Next Paint): How long the page takes to respond when a user clicks, taps, or types. Target: under 200 milliseconds. This replaced FID (First Input Delay) in 2024.
CLS (Cumulative Layout Shift): How much the page layout moves around during loading. Target: under 0.1. This is the metric that catches ads, images, and fonts shifting content after the page appears to be loaded.
Highest-impact LCP fixes
1. Optimize the hero image. This single fix produces the largest LCP improvement on most sites. Convert images to WebP format (30-50% smaller than JPEG at equivalent quality). Resize to the actual display dimensions — a 4000px image displayed at 800px wastes bandwidth. Add width and height attributes to prevent layout recalculation. Use loading="eager" and fetchpriority="high" on the LCP image so the browser prioritizes it.
Typical impact: 500ms-2s improvement. Time to implement: 30 minutes. Image optimization extends well beyond performance — alt text, file naming, and schema for images are a separate set of SEO signals that deserve their own pass.
2. Preconnect to critical origins. If your page loads fonts from Google Fonts or Bunny Fonts, images from a CDN, or analytics from a third-party domain, add <link rel="preconnect"> tags for those origins. This eliminates the DNS lookup and TLS handshake delay before the browser can fetch those resources.
<link rel="preconnect" href="https://fonts.bunny.net" crossorigin />Typical impact: 100-300ms improvement. Time to implement: 5 minutes.
3. Inline critical CSS. The CSS needed to render above-the-fold content should be inlined in the <head>, not loaded from an external stylesheet that blocks rendering. Most build tools (Vite, webpack) can extract critical CSS automatically. SvelteKit and Next.js handle this in their SSR pipeline.
Typical impact: 200-500ms improvement. Time to implement: 1-3 hours depending on build tooling.
4. Remove render-blocking scripts. Every <script> tag in the <head> without async or defer blocks rendering. Analytics scripts, chat widgets, A/B testing tools, and social media embeds are common offenders. Move them to the end of <body> or add defer. If they're not needed for the initial render, they shouldn't block it.
Typical impact: 300ms-1s improvement. Time to implement: 30 minutes to audit and defer.
Highest-impact INP fixes
1. Defer non-critical JavaScript. JavaScript that runs during page load competes with user interactions for the main thread. If a user clicks a button while a heavy script is executing, the browser can't respond until the script finishes. Use defer or async on scripts, and use dynamic import() for heavy modules that aren't needed immediately.
2. Break up long tasks. Any JavaScript task that runs longer than 50ms blocks the main thread and degrades INP. Use requestAnimationFrame or setTimeout(fn, 0) to yield back to the browser between processing steps. This lets the browser handle user interactions between chunks of work.
3. Minimize DOM size. Pages with 1,500+ DOM elements suffer from slower style recalculation, longer layout computation, and heavier garbage collection — all of which increase INP. Template-based sites are common offenders: a WordPress theme might generate 200 DOM elements for a simple page layout. Audit with Lighthouse and remove unnecessary wrapper divs.
Highest-impact CLS fixes
1. Set explicit dimensions on images and embeds. Without width and height attributes, the browser doesn't know how much space an image needs until it loads. The content below it jumps when the image arrives. Always declare dimensions. CSS aspect-ratio is an alternative for responsive images.
2. Reserve space for dynamic content. Ads, cookie banners, notification bars, and lazy-loaded embeds cause layout shifts when they appear. Reserve their space in the layout using min-height on the container element, even before the content loads.
3. Use font-display: swap with size-adjusted fallbacks. Web font loading causes a brief flash where text renders in the fallback font, then shifts when the web font arrives. Using font-display: swap with size-adjust, ascent-override, and descent-override on the fallback font minimizes the visible shift.
4. Avoid injecting content above existing content. Any element that appears above already-rendered content pushes everything down. Notification bars should appear at the top before page content renders, or use position: fixed so they overlay without shifting.
How to measure
Google Search Console > Core Web Vitals report. Shows field data (real user measurements) aggregated across your site. This is the data Google actually uses for ranking. Lab data from Lighthouse is useful for debugging but doesn't directly affect rankings.
PageSpeed Insights (pagespeed.web.dev). Combines field data with lab analysis. The lab section identifies specific elements and scripts causing problems.
Chrome DevTools > Performance panel. Record a page load and inspect the timeline. Every red flag is a long task. Every layout shift is visible in the experience section. This is where you identify the specific code responsible for poor metrics.
Web Vitals Chrome extension. Shows real-time LCP, INP, and CLS as you browse your site. Useful for quick spot-checking after making changes.
The budget-appropriate approach
Zero budget: Run PageSpeed Insights on your five most important pages. Fix the hero images (WebP conversion, proper sizing, fetchpriority). Add preconnect tags. Defer analytics scripts. Time: one afternoon. Impact: measurable within a week.
Small budget ($200-500): Everything above, plus: CDN setup (many CDN providers offer free tiers), CSS optimization, font loading strategy, and a full Lighthouse audit of your top 20 pages. Time: 2-3 days. Impact: most sites move from "Poor" or "Needs Improvement" to "Good" on all three metrics.
Investment budget: Everything above, plus: server-side rendering or static generation, image CDN with automatic format conversion, critical CSS extraction, lazy loading strategy for below-fold content, and ongoing monitoring. This is the level where Core Web Vitals become a sustained competitive advantage rather than a one-time fix.
Related reading
- Search Console Goes Deeper Than Rankings
- What a Technical SEO Audit Actually Checks (And What You Can Fix Today)
- E-E-A-T Is Not a Checklist
- The Problem with Generic Tech Recommendations
- If the Recommendation Came Before the Questions, It's Not Advisory
Frequently asked questions about core web vitals practical fixes
Do Core Web Vitals actually affect search rankings?
Yes. Google has used page experience signals (including Core Web Vitals) as ranking factors since 2021. The impact is moderate — content relevance and authority still matter more — but for pages competing for the same keywords with similar content quality, Core Web Vitals are a tiebreaker. In competitive niches, the tiebreaker matters.
What's the single most impactful Core Web Vitals fix?
Hero image optimization. Converting the largest image on your page to WebP, sizing it to display dimensions, and adding fetchpriority="high" typically produces the largest LCP improvement per minute of effort. It's the first thing we do on any performance audit.
How long do Core Web Vitals improvements take to affect rankings?
Google's field data for Core Web Vitals is collected over a rolling 28-day window. After making improvements, allow 4-6 weeks for the field data to reflect the changes and for any ranking impact to become visible.
Do I need to hit "Good" on all three metrics to benefit?
Each metric is evaluated independently. Improving from "Poor" to "Needs Improvement" on LCP produces ranking benefit even if CLS is still "Poor." That said, the goal should be "Good" on all three — under 2.5s LCP, under 200ms INP, under 0.1 CLS.
How We Test What Works: A/B Testing SEO Across Platforms and Budgets
We manage many websites across different industries, platforms, and budgets. That gives us something most agencies don't have: a testing lab with real traffic and real data.
Three Layers of Analytics: How We Track What Actually Matters
Client-side analytics miss 20-40% of your data. We run three layers — client, server, and behavioral — because no single layer tells the complete story.
Work With Us
Need help building this into your operations?
Kief Studio builds, protects, automates, and supports full-stack systems for businesses up to $50M ARR.
Newsletter
New writing, straight to your inbox.
Strategy, psychology, AI adoption, and the patterns that actually compound. No spam, easy to leave.
Subscribe