TL;DR
Core Web Vitals (LCP, INP, CLS) are Google's page experience ranking signals. For React/Next.js sites: use next/image for LCP, code-split for INP, and next/font + reserved space for CLS. Targets: LCP < 2.5s, INP < 200ms, CLS < 0.1. Byron Johnson optimizes CWV at $60/hr — page speed services.
What Are Core Web Vitals?
Google measures three metrics that reflect real user experience:
| Metric | What it measures | Good target |
|---|---|---|
| LCP (Largest Contentful Paint) | How fast main content loads | < 2.5 seconds |
| INP (Interaction to Next Paint) | How fast the page responds to clicks/taps | < 200 milliseconds |
| CLS (Cumulative Layout Shift) | How much the layout jumps while loading | < 0.1 |
All three must pass for a "Good" Core Web Vitals assessment. Failing metrics can lower your Google rankings — even if your content is excellent.
How to Fix LCP on React & Next.js
LCP measures when the largest visible element (usually a hero image, heading, or video) finishes rendering.
Use next/image with priority
import Image from 'next/image';
<Image
src="/hero.jpg"
alt="Hero image"
width={1200}
height={630}
priority
sizes="(max-width: 768px) 100vw, 1200px"
/>
The priority prop preloads above-the-fold images. Without it, Next.js lazy-loads by default — killing LCP.
Use modern image formats
Configure next.config.mjs for AVIF and WebP:
images: {
formats: ['image/avif', 'image/webp'],
}
AVIF is typically 30–50% smaller than JPEG at equivalent quality.
Eliminate render-blocking resources
- Use
next/fontinstead of Google Fontstags - Defer non-critical scripts with Next.js
- Server-render above-the-fold content (default in App Router)
Target: LCP under 2.5 seconds
Most React/Next.js sites with poor LCP have one culprit: an unoptimized hero image loaded without priority. Fix that first.
How to Fix INP on React & Next.js
INP measures responsiveness — how long between a user click and the browser painting the result.
Code-split heavy components
import dynamic from 'next/dynamic';
const HeavyChart = dynamic(() => import('./HeavyChart'), {
loading: () => <p>Loading chart...</p>,
});
Don't load charts, maps, or rich editors on initial page load.
Reduce JavaScript execution time
- Audit bundle size with
@next/bundle-analyzer - Remove unused dependencies (each npm package adds parse/compile time)
- Avoid large client components when server components suffice
Optimize event handlers
Debounced search inputs, optimistic UI updates, and startTransition for non-urgent state updates all improve INP.
Target: INP under 200 milliseconds
INP failures on React sites usually come from too much JavaScript executing on the main thread during interactions.
How to Fix CLS on React & Next.js
CLS measures visual stability — elements shifting after the page appears to have loaded.
Use next/font (zero layout shift)
import { Inter } from 'next/font/google';
const inter = Inter({ subsets: ['latin'], display: 'swap' });
next/font self-hosts fonts and reserves space — eliminating the flash-of-unstyled-text that causes CLS.
Always set image dimensions
Every needs width and height (or fill with a sized container). Never load images without reserved space.
Avoid injecting content above existing content
- Don't load banners or cookie notices that push content down after paint
- Reserve space for ads, embeds, and dynamic widgets with min-height containers
- Load skeleton placeholders for async content
Target: CLS under 0.1
Most CLS issues on React sites come from fonts loading late or images without dimensions.
Measuring Before and After
Use these tools to benchmark:
- Google PageSpeed Insights — lab data + field data (CrUX) if available
- Chrome DevTools Lighthouse — local testing during development
- Google Search Console → Core Web Vitals report — real user data from Google
- Web Vitals Chrome extension — live metrics while browsing
Always measure before making changes. Optimize the metric that's failing worst first.
When to Hire a Core Web Vitals Expert
DIY optimization works for simple fixes (image priority, font loading). Hire an expert when:
- PageSpeed score is below 50 despite basic fixes
- You're on a complex React SPA with heavy client-side rendering
- LCP is above 4 seconds and you can't identify the bottleneck
- INP fails on mobile but passes on desktop
- You need guaranteed results for a business-critical site
Byron Johnson performs deep-level CWV optimization — not plugin installs, but hands-on code work. Most React/Next.js sites improve meaningfully in 4–8 hours ($240–$480).
Page speed optimization services · Contact for an audit
Core Web Vitals Checklist for React/Next.js
- [ ] Hero/above-fold images use
next/imagewithpriority - [ ] Images served as AVIF/WebP via Next.js image optimizer
- [ ] Fonts loaded via
next/font(not externaltags) - [ ] Heavy components dynamically imported
- [ ] Bundle analyzed — no unnecessary large dependencies
- [ ] All images have explicit width/height or sized containers
- [ ] Third-party scripts deferred with
next/script - [ ] Server Components used where client interactivity isn't needed
- [ ] Measured with PageSpeed Insights — all three metrics green
Bottom Line
Core Web Vitals are not optional for sites that depend on Google traffic. The fixes are well-known and implementable — the challenge is knowing which metric is failing and applying the right technique.
For React and Next.js specifically, 80% of CWV improvements come from: optimized images, self-hosted fonts, and reduced client-side JavaScript.
Need help? Get a speed audit or explore Next.js development services.
Ready to work together?
Whether you need a new build, project rescue, or performance optimization — let's talk about your project.