Performance Checklist for AI SEO

Key Takeaways

This checklist covers every performance optimization that affects AI SEO — from critical fixes to advanced fine-tuning
Start with the three highest-impact changes: server-side rendering, CDN with HTML caching, and LCP image optimization
Target Core Web Vitals thresholds in field data: LCP <2.5s, CLS <0.1, INP <200ms — plus TTFB under 600ms for AI crawlers
Performance improvements take 1-3 months to fully affect AI visibility through improved crawling and Google ranking signals
You do not need to implement everything — focus on Critical and High priority items first, then iterate

See where you stand right now. Check your AI Score for free — includes performance, crawler access, and AI visibility analysis.

Performance Targets Summary
Critical: Server and Rendering
Critical: Images and LCP
High: Caching and CDN
High: JavaScript and CSS
Medium: Fonts and Layout Stability
Medium: Mobile Optimization
Nice to Have: Advanced Optimizations
Monitoring and Maintenance
FAQ

Performance Targets Summary

Before diving into the checklist, here are the target numbers you are working toward:

| Metric | Target | Priority for AI SEO | |---|---|---| | LCP (Largest Contentful Paint) | Under 2.5s (ideal: under 1.5s) | Critical — determines AI crawler content access | | CLS (Cumulative Layout Shift) | Under 0.1 | High — affects Google rankings | | INP (Interaction to Next Paint) | Under 200ms | High — affects Google rankings | | TTFB (Time to First Byte) | Under 600ms (ideal: under 200ms) | Critical — directly impacts AI crawler efficiency | | FCP (First Contentful Paint) | Under 1.8s (ideal: under 0.4s) | High — sites with FCP <0.4s get 3x more AI citations | | Total JavaScript | Under 200KB compressed (initial load) | High — JS blocks rendering and hurts CWV | | Total page weight | Under 1.5MB | Medium — affects transfer time |

These targets apply to the 75th percentile of real users in CrUX data (field data), which is what Google uses for ranking signals.

Critical: Server and Rendering

These items have the highest impact on AI crawler performance. Address them first.

Server-Side Rendering

[ ] Enable SSR or SSG for all content pages — AI crawlers do not reliably execute JavaScript; all text content must be present in the initial HTML response
[ ] Test with JavaScript disabled — Open your pages in Chrome with JS disabled (Settings > Content > JavaScript > Block) and verify all text content is visible
[ ] Use Astro, Next.js (SSR/SSG), or Nuxt for new projects — these frameworks provide SSR by default with optimal AI crawler support
[ ] Implement ISR (Incremental Static Regeneration) for content that updates periodically — combines the speed of static with the freshness of dynamic

Server Response Time

[ ] Target TTFB under 600ms — Test with WebPageTest from Virginia (US East) to simulate AI crawler location
[ ] Enable full-page caching — Varnish, Nginx FastCGI cache, or Redis full-page cache to eliminate application processing on repeat requests
[ ] Use Redis or Memcached for object caching — Cache database queries and computed values
[ ] Upgrade PHP to 8.x (if applicable) — JIT compilation provides significant performance improvements
[ ] Enable OPcache (PHP) — Store compiled bytecode in memory to eliminate recompilation on every request
[ ] Support HTTP/2 or HTTP/3 — Enable multiplexing and header compression for faster transfers

Critical: Images and LCP

Images are the #1 cause of poor LCP. These optimizations typically produce the largest measurable improvements.

Image Format and Compression

[ ] Convert hero images to AVIF with WebP fallback — Use <picture> element with multiple sources
[ ] Hero images under 100KB — Compress to quality 60-70 (AVIF) or 75-80 (WebP)
[ ] Content images under 50KB — Compress appropriately for the content type
[ ] Thumbnails under 20KB — Aggressive compression is acceptable for small display sizes
[ ] Remove EXIF data from all images — Strips unnecessary metadata that adds file size

LCP Image Optimization

[ ] Preload the LCP image — Add <link rel="preload" as="image"> in the document <head>
[ ] Add fetchpriority="high" to the LCP image element
[ ] Never lazy-load the LCP image — Only use loading="lazy" on below-the-fold images
[ ] Set explicit width and height on the LCP image to prevent CLS

All Images

[ ] Add width and height attributes to every <img> element — Prevents layout shifts
[ ] Use responsive images with srcset — Serve appropriate sizes for mobile (400px), tablet (800px), desktop (1200px), and retina (1600px)
[ ] Add loading="lazy" to all below-the-fold images
[ ] Write descriptive alt text for every image — AI crawlers parse alt attributes for content understanding

High: Caching and CDN

CDN Configuration

[ ] Deploy a CDN (Cloudflare, Vercel, CloudFront) with edge nodes in US East (Virginia) and US West — where AI crawler data centers are located
[ ] Cache HTML pages at the CDN edge — Not just static assets; set s-maxage for HTML responses
[ ] Use stale-while-revalidate — Cache-Control: public, max-age=0, s-maxage=3600, stale-while-revalidate=86400
[ ] Enable Brotli compression on the CDN
[ ] Enable HTTP/3 (QUIC) if your CDN supports it
[ ] Warm cache after deployments — Script that requests key pages to pre-populate CDN cache

Cache Headers

[ ] Set immutable cache headers for hashed assets — Cache-Control: public, max-age=31536000, immutable for CSS/JS/images with content hashes in filenames
[ ] Avoid Vary: User-Agent — This creates separate cache entries per User-Agent, effectively disabling caching
[ ] Strip marketing parameters from cache keys — utm_source, utm_medium, fbclid should not create separate cache entries

Bot Protection

[ ] Whitelist AI search crawlers in CDN bot protection — OAI-SearchBot, ChatGPT-User, PerplexityBot, ClaudeBot
[ ] Never serve CAPTCHAs to AI crawlers — Bots cannot solve them
[ ] Set higher rate limits for AI bots — They may request 50-100 pages in rapid succession during a crawl session

High: JavaScript and CSS

JavaScript

[ ] Keep initial JS bundle under 200KB compressed
[ ] Implement route-based code splitting — Load only the JS needed for the current page
[ ] Enable tree shaking in your bundler (Webpack 5, Vite, Rollup)
[ ] Audit third-party scripts — Remove unused scripts; defer or lazy-load non-critical ones
[ ] Use the facade pattern for heavy embeds (YouTube, social media, chat widgets)
[ ] Add defer or async to all non-critical script tags
[ ] Avoid document.write() — It blocks rendering and is penalized by Chrome

CSS

[ ] Inline critical CSS — Extract above-the-fold CSS and inline in the <head>
[ ] Defer non-critical CSS — Load remaining CSS asynchronously
[ ] Remove unused CSS — Use PurgeCSS or similar tools to strip unused styles (typical savings: 80-95%)
[ ] Minimize CSS specificity — Overly specific selectors increase parse time

Medium: Fonts and Layout Stability

Web Fonts

[ ] Use font-display: swap for all web fonts — Prevents invisible text (FOIT) that delays LCP
[ ] Preload critical fonts — <link rel="preload" as="font" href="/font.woff2" crossorigin>
[ ] Self-host fonts instead of loading from Google Fonts CDN — Eliminates extra DNS lookups
[ ] Subset fonts to include only needed characters (Latin, numbers, common symbols)
[ ] Use WOFF2 format — The most efficient web font format
[ ] Match fallback font metrics with size-adjust, ascent-override, descent-override to minimize CLS during font swap

Layout Stability (CLS)

[ ] Reserve space for ads with CSS min-height or aspect-ratio on containers
[ ] Use position: fixed for cookie banners — Overlay rather than push content
[ ] Use CSS transforms for animations — Not layout-triggering properties like top, left, width
[ ] Add contain: layout to independent page sections to prevent shift propagation

Medium: Mobile Optimization

[ ] Serve identical content on mobile and desktop — No hidden content, no "Read More" truncation, no collapsed-by-default accordions
[ ] Include all schema markup on mobile — Googlebot mobile-first indexing uses the mobile version
[ ] Include all internal links on mobile — Hidden navigation links are invisible to mobile-first crawling
[ ] Verify viewport meta tag — <meta name="viewport" content="width=device-width, initial-scale=1">
[ ] Ensure 48x48px minimum touch targets with 8px spacing
[ ] Test with Lighthouse mobile mode — Simulates a mid-tier mobile device
[ ] Serve smaller images to mobile via responsive srcset — 400-800px wide instead of 1200-1600px

Nice to Have: Advanced Optimizations

These provide incremental improvements after the fundamentals are solid:

[ ] Implement Early Hints (103) — CDN sends preload hints before full response is ready
[ ] Use resource hints strategically — <link rel="preconnect"> for critical third-party origins, <link rel="dns-prefetch"> for secondary origins
[ ] Enable service workers for repeat visit performance and offline support
[ ] Implement fetchpriority on critical resources beyond the LCP image
[ ] Use CSS content-visibility: auto for below-the-fold content sections — Defers rendering of non-visible content
[ ] Implement virtual scrolling for long lists (product listings, search results)
[ ] Configure TLS 1.3 with 0-RTT resumption for faster repeat connections
[ ] Use OCSP stapling for faster TLS handshakes
[ ] Implement <link rel="modulepreload"> for critical JavaScript modules

Monitoring and Maintenance

Performance is not a one-time project. Set up ongoing monitoring to prevent regressions:

Every Deployment

[ ] Run Lighthouse CI — Fail builds that regress CWV below thresholds
[ ] Check bundle size — Alert if JS exceeds 200KB or total page exceeds 1.5MB
[ ] Warm CDN cache — Script to pre-populate cache after deployment

Weekly

[ ] Review server logs for AI crawler activity — Check visit frequency, response times, and error rates
[ ] Monitor AI crawler response times — Ensure TTFB stays under 600ms for bot requests
[ ] Check for new blocked crawlers — Verify WAF/CDN is not blocking AI bots

Monthly

[ ] Check PageSpeed Insights — Review CrUX field data for LCP, CLS, and INP trends
[ ] Review Search Console CWV report — Identify pages moving from "Good" to "Needs Improvement"
[ ] Check AI visibility score — Monitor whether performance changes correlate with AI citation changes

Quarterly

[ ] Run WebPageTest deep dive — Full waterfall analysis from US East (Virginia)
[ ] Benchmark against competitors — Compare CWV and AI visibility scores
[ ] Audit third-party scripts — Check for new scripts added by marketing or analytics teams
[ ] Review and update this checklist — Performance best practices evolve; stay current

For the complete AI SEO implementation plan beyond performance, see our AI SEO Checklist for 2026.

Frequently Asked Questions

What performance metrics matter most for AI SEO?

LCP (under 2.5s), CLS (under 0.1), INP (under 200ms), and TTFB (under 600ms). LCP and TTFB have the most direct impact on AI crawlers. CLS and INP affect AI visibility indirectly through Google rankings. See Core Web Vitals and AI SEO for the full breakdown.

How much does performance actually affect AI visibility?

Significantly. Sites with FCP under 0.4 seconds are cited by ChatGPT 3x more often than slow sites. Performance affects AI crawl efficiency directly (slow sites get fewer pages crawled) and indirectly through Google ranking signals that determine AI source pools.

What should I optimize first for the biggest AI SEO impact?

Three changes in order: (1) Enable server-side rendering so AI crawlers can see your content. (2) Add a CDN with HTML caching to reduce TTFB. (3) Optimize your LCP image with preloading, modern formats, and explicit dimensions.

How long does it take for performance improvements to affect AI visibility?

AI crawler improvements (faster TTFB) can show effects within 1-2 weeks. Core Web Vitals improvements take longer — CrUX has a 28-day rolling window, and Google ranking adjustments may take 4-8 weeks. Expect 1-3 months for the full impact.

Do I need to implement everything on this checklist?

No. Start with Critical priority items, then High. Medium and Nice to Have items provide incremental improvements. Focus on passing all three Core Web Vitals in field data before pursuing advanced optimizations. Use the AI SEO Checklist for 2026 for the broader implementation plan.

Start checking off this list

Get your free AI Score in 60 seconds — see which performance items need attention and how they affect your AI visibility.

Check My Website

Trusted by 2,400+ websites -- No credit card required