Table of contents
Many AEO practitioners focus entirely on structured data and content while overlooking a foundational factor: page speed. AI search does not just read content — it also evaluates whether a web page is trustworthy based on technical quality signals.
What Are Core Web Vitals?
Google measures user experience quality through 3 metrics:
| Metric | Measures | Good | Needs Improvement | Poor |
|---|---|---|---|---|
| LCP (Largest Contentful Paint) | Time to load the largest element in viewport | Under 2.5s | 2.5s–4s | Over 4s |
| INP (Interaction to Next Paint) | Latency when user interacts | Under 200ms | 200–500ms | Over 500ms |
| CLS (Cumulative Layout Shift) | Amount of layout shift | Under 0.1 | 0.1–0.25 | Over 0.25 |
INP replaced FID as of March 2024. If you are still tracking FID — switch to INP.
The Connection Between CWV and AEO
Mechanism 1: Trust signal
Google builds a "Page Quality Score" based on many signals, including CWV. Pages with good CWV → users stay longer → Google believes the page is useful → AI Overviews prioritizes citing it.
Mechanism 2: Crawl budget
Googlebot allocates crawl time to each domain. Slow pages → Googlebot waits longer → fewer pages crawled in the same time → AI knows less about your new content.
Mechanism 3: Content accessibility
If LCP exceeds 4 seconds, some important content (such as tables, FAQs, schema JSON-LD) may not have finished rendering when Googlebot takes a snapshot. AI may read the page without seeing the most important content.
CWV Benchmarks by Industry (Vietnam 2026)
| Industry | Avg LCP | % Achieving Good | AEO Opportunity |
|---|---|---|---|
| News / Media | 1.8–2.2s | 65% | Medium (many competitors also perform well) |
| E-commerce | 2.8–3.5s | 35% | High (many slow shops) |
| B2B / SaaS | 2.0–2.8s | 55% | Medium |
| Healthcare | 2.5–3.8s | 40% | High |
| Real estate | 3.0–4.5s | 25% | Very high (image-heavy pages) |
| Restaurant / Local | 2.2–3.0s | 50% | Medium |
If you are in an industry with a low rate of Good — this is a significant competitive opportunity.
Why LCP Is Slow and How to Fix It
LCP is affected by these factors (in order of impact):
1. Slow Time to First Byte (TTFB)
Slow server response delays everything. Target TTFB: under 600ms.
Fix:
- Enable caching for static pages (Next.js:
revalidate, ISR) - Use CDN (Vercel Edge Network is automatic with Next.js)
- Optimize database queries if using dynamic rendering
2. Hero image not prioritized
// Wrong — Next.js lazy loads by default
<Image src="/hero.jpg" width={1200} height={600} alt="Hero" />
// Correct — hero image must have priority
<Image src="/hero.jpg" width={1200} height={600} alt="Hero" priority />
3. Render-blocking resources
<!-- Wrong — Google Fonts blocks rendering -->
<link href="https://fonts.googleapis.com/css2?family=..." rel="stylesheet">
<!-- Correct — preconnect + async load -->
<link rel="preconnect" href="https://fonts.googleapis.com">
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
<link rel="stylesheet" href="..." media="print" onload="this.media='all'">
4. Unoptimized images
- Use WebP or AVIF instead of PNG/JPG
- Next.js Image component auto-converts if configured correctly
- Compress images before uploading: target under 200KB for hero images
CLS: What Causes Layout Shifts
CLS of 0 is ideal but nearly impossible for pages with ads. Target: under 0.1.
Images without dimensions:
// Causes CLS — no dimensions
<img src="/product.jpg" />
// Fix — declare width and height
<img src="/product.jpg" width="400" height="300" />
// Or use Next.js Image (handles CLS automatically)
<Image src="/product.jpg" width={400} height={300} alt="..." />
Font loading CLS:
/* Avoid FOUT (Flash of Unstyled Text) causing CLS */
@font-face {
font-family: 'MyFont';
src: url('/fonts/myfont.woff2') format('woff2');
font-display: optional;
}
INP: Slow Interaction Response
INP is typically affected by heavy JavaScript running on the main thread:
| Cause | Solution |
|---|---|
| Long tasks on main thread | Code splitting, Web Workers for heavy computation |
| Slow event handlers | Debounce inputs, optimize state updates |
| Third-party scripts | Load async, defer, or use Partytown |
| Unnecessary React re-renders | Use useMemo, useCallback, React.memo correctly |
CWV and AEO: Technical Checklist
- LCP under 2.5 seconds on mobile (measured with PageSpeed Insights)
- INP under 200ms
- CLS under 0.1
- TTFB under 600ms (Server/Edge response time)
- Hero/above-fold images use
priorityin Next.js Image - All images declare
widthandheight - No render-blocking resources in
<head> - Google Search Console — 0 URLs in the "Poor" bucket
- WebP or AVIF for large images
- Lazy load for below-fold images, no lazy load for above-fold
Reality Check: How Good Is "Good Enough" for AEO?
| CWV Status | AEO Impact |
|---|---|
| All Good | CWV removed as a risk — AI evaluates content normally |
| 1–2 metrics Needs Improvement | Little direct impact, but needs monitoring |
| Any metric Poor | Risk — may be deprioritized in AI source selection |
| LCP over 4s | Red flag — many AI systems filter out this page |
The practical takeaway: CWV is a necessary but not sufficient condition for AEO. Good speed with poor content — still not cited. But good content with poor speed — may never be read thoroughly enough by AI to be cited.
Investing in CWV is investing in the foundation. Do it right once, and everything built on top benefits.
Frequently asked questions
How do Core Web Vitals affect AEO?
3 main mechanisms: (1) Filtering threshold — Google AI Overviews filters sources with poor CWV before even considering content. If LCP exceeds 4 seconds, the page may be excluded from the citation source pool even if the content is good. (2) Trust signal — slow speed = poor experience = Google trusts the page less as a reliable source. (3) Crawl priority — Googlebot prioritizes crawling fast pages, slow pages get crawled less often, so AI knows less about your new content.
What Core Web Vitals thresholds are needed for good AEO?
The goal is Good for all 3 metrics: LCP under 2.5 seconds (time to load the largest element), INP under 200ms (interaction latency), CLS under 0.1 (layout shift). For AEO, the practical targets are: LCP under 3 seconds is safe, under 2.5 seconds is good. INP and CLS are generally easier to achieve if there is no heavy JavaScript or ads causing layout shift.
LCP, INP, CLS — which metric matters most for AEO?
LCP matters most for AEO. The reason: LCP measures the time users see the main content — if it is slow, users leave immediately, Google records a high bounce rate, and the trust signal decreases. CLS is second most important because layout shifts obscure content, cause users to misclick, and create a poor experience. INP matters for SEO but has less direct impact on AEO since AI does not interact with the page like a user does.
Can a page with heavy JavaScript achieve good CWV?
Yes — but it requires proactive optimization. Next.js App Router helps a lot: Server Components reduce JS bundle, Streaming SSR improves LCP, Image component auto-optimizes. Also needed: lazy load components not immediately required, code splitting for heavy widgets, dynamic import for charts and editors. The framework does not solve everything automatically — you need to measure and optimize specifically.
Where is the most accurate place to measure Core Web Vitals?
Field data (real user data) matters more than lab data. Most accurate sources: (1) Google Search Console — Core Web Vitals section, real CrUX data from Chrome users; (2) PageSpeed Insights — combines lab data (Lighthouse) and field data (CrUX) for a specific URL; (3) Chrome DevTools Lighthouse — lab only, useful for debugging but does not reflect real data. Lab data and field data typically differ by 20–50%.
AEO Saigon
An Answer Engine Optimization agency in Ho Chi Minh City — helping business websites get cited by AI. About AEO Saigon →
Want your website to be cited by AI like this?
Free Audit