18 Checks · Code Examples · Free

User Experience SEO Checklist

The direct answer

User experience is one of the few things a search engine says out loud that it uses. This checklist covers the thirteen checks that matter, from the three Core Web Vitals and what each one measures, to the mobile experience signals, to the changes in behaviour that matter even where no signal exists.

Core Web Vitals, mobile usability, and page speed are confirmed ranking factors. Good UX increases engagement, reduces bounce rates, and improves conversions. These 18 checks cover every aspect of page experience with implementation code.

Why User Experience Matters

Google Page Experience update made Core Web Vitals official ranking factors. Pages that load fast, respond quickly to interactions, and maintain visual stability rank higher. Poor UX increases bounce rates and reduces conversions, creating a negative feedback loop.

In 2026, UX also affects AI search visibility. AI agents that render pages for screenshots or parse HTML expect fast, stable content. Poor Core Web Vitals correlate with poor user experience across all surfaces including AI-generated answers.

<2.5s LCP Target
<200ms INP Target
<0.1 CLS Target
Person on computer
Person on computer

CWV Metrics Summary

Metric Measures Good
LCP Loading speed Under 2.5s
INP Interactivity Under 200ms
CLS Visual stability Under 0.1
TTFB Server response Under 200ms

The 18 Checks

Every check ranked by impact. Start at the top and work down.

# Check Category Impact Difficulty
1Achieve LCP under 2.5 secondsCWVCriticalHard
2Achieve INP under 200msCWVCriticalHard
3Achieve CLS under 0.1CWVCriticalMedium
4Pass mobile-friendly testMobileCriticalMedium
5Eliminate render-blocking resourcesSpeedHighHard
6Optimize images for webSpeedHighEasy
7Use responsive imagesMobileHighEasy
8Set proper viewport meta tagMobileHighEasy
9Avoid intrusive interstitialsUXHighEasy
10Use readable font sizes (16px+)ReadabilityMediumEasy
11Maintain adequate tap target sizesMobileMediumEasy
12Minimize main thread workSpeedMediumHard
13Use efficient cache policiesSpeedMediumMedium
14Enable text compressionSpeedMediumEasy
15Avoid excessive DOM sizePerformanceMediumHard
16Use CSS containmentPerformanceLowMedium
17Prioritize visible contentSpeedLowMedium
18Monitor UX metrics in GSCMonitoringLowEasy

Deep Dive: Core Web Vitals Optimization

Implementation guides with code examples for LCP, INP, and CLS.

1 Achieve LCP Under 2.5 Seconds

Largest Contentful Paint measures when the largest content element in the viewport becomes visible. It is usually a hero image, large heading, or video poster. Identify the LCP element using Lighthouse, then preload it and eliminate anything that blocks rendering.

<!-- Preload the LCP image with high priority -->
<link rel="preload" as="image" href="/images/hero.webp" fetchpriority="high">

<!-- Use fetchpriority on the img tag itself -->
<img src="/images/hero.webp" fetchpriority="high" alt="Hero" width="1200" height="600">

<!-- Preload critical CSS -->
<link rel="preload" as="style" href="/css/critical.css"
      onload="this.onload=null;this.rel='stylesheet'">

<!-- Defer non-critical JavaScript -->
<script defer src="/js/analytics.js"></script>

Monitor LCP in the field using the CrUX report in Google Search Console. Lab tools show potential issues; field data shows real user impact. Google uses the 75th percentile of real-user measurements.

2 Achieve INP Under 200ms

Interaction to Next Paint measures the latency of all interactions throughout the page lifecycle. Long JavaScript tasks (over 50ms) block the main thread and make the page feel unresponsive. Break them up by yielding to the main thread.

// Modern approach: scheduler.yield() (Chrome 115+)
async function processItems(items) {
  for (const item of items) {
    heavyProcess(item);
    await scheduler.yield();  // yield without timeout overhead
  }
}

// Fallback: yield via setTimeout
async function processItemsWithFallback(items) {
  for (const item of items) {
    heavyProcess(item);
    if ('scheduler' in window && 'yield' in scheduler) {
      await scheduler.yield();
    } else {
      await new Promise(r => setTimeout(r, 0));
    }
  }
}

// Debounce event handlers to reduce main thread pressure
function debounce(fn, delay = 150) {
  let timer;
  return function(...args) {
    clearTimeout(timer);
    timer = setTimeout(() => fn.apply(this, args), delay);
  };
}

window.addEventListener('resize', debounce(() => {
  // handle resize
}, 150));

3 Achieve CLS Under 0.1

Cumulative Layout Shift measures how much visible content shifts during page load. The main culprits: images without dimensions, dynamically injected content, web fonts causing FOUT, and ads that resize after loading.

<!-- Always set explicit width and height -->
<img src="/image.webp" width="800" height="450" alt="" loading="lazy">

<!-- For responsive images, CSS handles the rest -->
img, video, iframe {
  max-width: 100%;
  height: auto;
}

<!-- Reserve space for embeds -->
<div style="position: relative; padding-bottom: 56.25%; height: 0;">
  <iframe src="https://www.youtube.com/embed/..."
          style="position: absolute; top: 0; left: 0;
                 width: 100%; height: 100%;"></iframe>
</div>

<!-- Reserve space for ads -->
<div style="min-height: 250px; width: 100%;">
  <div id="ad-slot"></div>
</div>

Eliminate Render-Blocking Resources

The single highest-impact fix for LCP on most sites.

Render-blocking resources are CSS stylesheets and JavaScript files in the HTML head that prevent the browser from painting any content until they are fully downloaded, parsed, and executed. Every render-blocking resource adds latency to LCP.

The fix has three parts:

1. Inline critical CSS. Extract the minimum CSS needed to render above-the-fold content and place it directly in a <style> tag in the HTML head. Tools like Critical (npm package) automate this.

2. Load non-critical CSS asynchronously. Use rel=preload with an onload handler to load the full stylesheet after the page has painted. Add a noscript fallback.

3. Defer non-critical JavaScript. Add the defer or async attribute to script tags. Deferred scripts execute after HTML parsing; async scripts execute as soon as they download. Use defer for scripts that depend on DOM order.

<!-- Inline critical CSS directly in the HTML head -->
<style>
  /* Critical above-the-fold styles only */
  body { font-family: sans-serif; margin: 0; }
  .hero { display: flex; min-height: 60vh; }
  .nav { position: sticky; top: 0; }
</style>

<!-- Load non-critical CSS asynchronously -->
<link rel="preload" as="style" href="/css/full.css"
      onload="this.onload=null;this.rel='stylesheet'">
<noscript><link rel="stylesheet" href="/css/full.css"></noscript>

<!-- Defer non-critical JavaScript -->
<script defer src="/js/main.js"></script>
<script defer src="/js/analytics.js"></script>

<!-- Use async for independent scripts (analytics, tags) -->
<script async src="https://www.googletagmanager.com/gtag/js?id=G-XXXXX"></script>

Script Loading Behavior

Attribute Behavior
No attribute Blocks HTML parsing
async Downloads in parallel, executes immediately
defer Downloads in parallel, executes after HTML parsed
type="module" Deferred by default

CSS Containment Implementation

Tell the browser which parts of the page are independent to skip unnecessary recalculations.

CSS containment (the contain property) tells the browser that an element's subtree is independent from the rest of the page. This lets the browser skip layout and paint recalculations for that element when changes happen elsewhere, improving rendering performance by 20-50% on complex pages.

The four containment types:

layout. Internal layout does not affect elements outside. The element becomes a containing block for positioned descendants.

paint. Nothing inside paints outside the element bounds. Clipping is applied automatically.

size. The element can be laid out without examining its children. Use when you know the size in advance.

content. Combines layout and paint (but not size). The safest default for most components.

/* Apply containment to independent components */
.card {
  contain: layout paint;
}

/* For list items where you know the height */
.list-item {
  contain: layout paint size;
  height: 80px;
}

/* For complex widgets with frequent DOM mutations */
.widget {
  contain: content;
}

/* Strict containment for static, sized elements */
.sidebar {
  contain: layout paint size;
  width: 300px;
}

/* Contain inline styles for dynamic content */
.comment {
  contain: layout paint;
  content-visibility: auto;
  contain-intrinsic-size: 0 200px;
}

content-visibility: auto is a related property that defers rendering of off-screen content entirely. Combined with contain-intrinsic-size, it tells the browser how much space to reserve for content it has not yet rendered. This dramatically improves initial load performance for long pages.

Containment Types

contain: layout Internal layout isolated
contain: paint Nothing paints outside bounds
contain: size Children not needed for sizing
contain: content layout + paint (recommended)
content-visibility: auto Skip off-screen rendering

Mobile & Responsive Design

Mobile-first indexing means your mobile experience is your primary ranking experience.

4 Pass Mobile-Friendly Test

Google uses mobile-first indexing. Your mobile version is the primary version for ranking. Use the viewport meta tag, responsive images, readable font sizes, and adequate tap targets.

<!-- Required viewport meta tag (must be in every page) -->
<meta name="viewport" content="width=device-width, initial-scale=1">

<!-- Mobile-first CSS approach -->
/* Base styles for mobile (smallest screens) */
.container {
  padding: 0 16px;
  width: 100%;
}

/* Tablet and up */
@media (min-width: 768px) {
  .container {
    padding: 0 24px;
    max-width: 720px;
    margin: 0 auto;
  }
}

/* Desktop and up */
@media (min-width: 1024px) {
  .container {
    max-width: 960px;
  }
}

/* Large desktop */
@media (min-width: 1200px) {
  .container {
    max-width: 1140px;
  }
}

8 Set Proper Viewport Meta Tag

Without the viewport meta tag, mobile browsers render pages at desktop width (typically 980px) and then scale down, making text unreadable. This is a hard requirement for mobile-first indexing.

<!-- Correct viewport configuration -->
<meta name="viewport" content="width=device-width, initial-scale=1">

<!-- Do NOT use these (they break mobile UX): -->
<!-- <meta name="viewport" content="width=320"> -->
<!-- <meta name="viewport" content="initial-scale=1, maximum-scale=1, user-scalable=no"> -->

<!-- Responsive images scale with viewport -->
<img src="/image.webp"
     srcset="/image-400.webp 400w,
             /image-800.webp 800w,
             /image-1200.webp 1200w"
     sizes="(max-width: 600px) 100vw, (max-width: 1024px) 50vw, 33vw"
     width="1200" height="600"
     loading="lazy"
     alt="Description">

10 Use Readable Font Sizes (16px+)

Google recommends a base font size of at least 16px for body text on mobile. Smaller text forces users to pinch-to-zoom, which is a negative mobile UX signal. Use relative units (rem) for scalable typography.

/* Set base font size on html element */
html {
  font-size: 16px;  /* 1rem = 16px */
}

/* Use rem for all typography */
body {
  font-size: 1rem;        /* 16px */
  line-height: 1.6;
}

h1 { font-size: 2rem; }   /* 32px */
h2 { font-size: 1.5rem; } /* 24px */
h3 { font-size: 1.25rem; }/* 20px */
p  { font-size: 1rem; }   /* 16px */

/* Confirm minimum tap target size: 48x48px */
button, a, input, select {
  min-height: 48px;
  min-width: 48px;
}

11 Maintain Adequate Tap Target Sizes

Google recommends tap targets of at least 48x48px with at least 8px of spacing between targets. Small, tightly packed tap targets cause mis-taps on mobile, which is a negative UX signal.

/* Minimum tap target size */
button, a.button.nav-link {
  min-height: 48px;
  min-width: 48px;
  padding: 12px 24px;
  display: inline-flex;
  align-items: center;
  justify-content: center;
}

/* Spacing between adjacent tap targets */
.nav-link + .nav-link {
  margin-left: 8px;
}

/* For inline links in text, confirm enough padding */
.content a {
  padding: 4px 0;
  display: inline;
}

Font Loading Optimization

Custom fonts cause CLS and delay text rendering. Here is how to load them without penalties.

Custom web fonts cause CLS in two ways: FOIT (Flash of Invisible Text) where text is hidden until the font loads, and FOUT (Flash of Unstyled Text) where text swaps from fallback to custom font causing layout shift. The goal is to show text immediately and minimize the shift when the custom font arrives.

@font-face {
  font-family: 'CustomFont';
  src: url('/fonts/custom-font.woff2') format('woff2');
  font-display: swap;  /* Show fallback immediately */
  font-weight: 400;
}

/* Preload the font for earlier discovery */
<link rel="preload" as="font" href="/fonts/custom-font.woff2"
      type="font/woff2" crossorigin>

/* Use size-adjust to match fallback metrics to custom font */
@font-face {
  font-family: 'CustomFont-Fallback';
  src: local('Arial');
  size-adjust: 104%;
  ascent-override: 90%;
  descent-override: 22%;
  line-gap-override: 0%;
}

body {
  font-family: 'CustomFont', 'CustomFont-Fallback', sans-serif;
}

Best practices: Only load the font weights and styles you actually use. Subset fonts to include only the character sets you need. Use woff2 format exclusively, it has the best compression. Self-host fonts instead of loading from Google Fonts to eliminate the extra DNS lookup and connection.

Font Display Options

swap Show fallback, swap when loaded (recommended)
optional Browser decides if font is used at all
fallback Short invisible period, then fallback
block Hide text until font loads (bad for UX)
auto Browser default (usually block)

Minimize Main Thread Work

Heavy JavaScript blocks the main thread and degrades INP and TBT.

12 Minimize Main Thread Work

The browser main thread handles all JavaScript execution, layout, paint, and compositing. When a long task occupies the main thread for more than 50ms, the page becomes unresponsive to user input. Use Chrome DevTools Performance tab to identify long tasks.

// Break up long tasks using scheduler.yield()
async function processLargeDataset(items) {
  const results = [];
  for (let i = 0; i < items.length; i++) {
    results.push(expensiveOperation(items[i]));

    // Yield every 50 items to keep the main thread free
    if (i % 50 === 0) {
      if ('scheduler' in window && 'yield' in scheduler) {
        await scheduler.yield();
      } else {
        await new Promise(r => setTimeout(r, 0));
      }
    }
  }
  return results;
}

// Use Web Workers for CPU-intensive work
// worker.js
self.addEventListener('message', (e) => {
  const result = heavyComputation(e.data);
  self.postMessage(result);
});

// main.js
const worker = new Worker('/js/worker.js');
worker.postMessage(data);
worker.addEventListener('message', (e) => {
  updateUI(e.data);
});

// Use requestIdleCallback for non-critical work
function scheduleNonCriticalWork(task) {
  if ('requestIdleCallback' in window) {
    requestIdleCallback(task, { timeout: 2000 });
  } else {
    setTimeout(task, 1);
  }
}

15 Avoid Excessive DOM Size

Google flags pages with more than 1,500 DOM nodes. Large DOM trees increase memory usage, style recalculation time, and layout complexity. Use pagination, virtual scrolling, or lazy rendering to keep the DOM lean.

<!-- Use content-visibility for off-screen content -->
<div style="content-visibility: auto; contain-intrinsic-size: 0 500px;">
  <!-- Off-screen content deferred until scrolled into view -->
</div>

<!-- Virtual list pattern for long lists -->
// Only render visible items + buffer
function renderVisibleItems(items, container, itemHeight) {
  const scrollTop = container.scrollTop;
  const viewportHeight = container.clientHeight;
  const startIndex = Math.floor(scrollTop / itemHeight) - 5;
  const endIndex = Math.ceil((scrollTop + viewportHeight) / itemHeight) + 5;

  // Only create DOM nodes for visible range
  return items.slice(
    Math.max(0, startIndex),
    Math.min(items.length, endIndex)
  );
}

13 Use Efficient Cache Policies

Proper caching reduces server load and improves repeat-visit performance. Set long cache durations for static assets (images, fonts, CSS, JS) and use cache-busting via file hashes for updates.

# Nginx cache configuration

# Images and fonts: cache for 1 year (immutable)
location ~* \.(webp|avif|jpg|png|woff2)$ {
  expires 1y;
  add_header Cache-Control "public, immutable";
}

# CSS and JS with hash in filename: cache for 1 year
location ~* \.(css|js)$ {
  expires 1y;
  add_header Cache-Control "public, immutable";
}

# HTML: short cache or no cache
location ~* \.html$ {
  expires 0;
  add_header Cache-Control "no-cache";
}

# Enable Brotli compression
brotli on;
brotli_comp_level 6;
brotli_types text/html text/css application/javascript
             image/svg+xml application/json;

14 Enable Text Compression

Brotli compression reduces text-based asset sizes by 15-25% more than Gzip. Enable it at the server or CDN level for HTML, CSS, JavaScript, SVG, and JSON.

# Nginx: Enable Brotli (requires ngx_brotli module)
brotli on;
brotli_comp_level 6;
brotli_types text/html text/css application/javascript
             image/svg+xml application/json text/xml;

# Fallback: Enable Gzip
gzip on;
gzip_comp_level 6;
gzip_min_length 256;
gzip_types text/html text/css application/javascript
           image/svg+xml application/json text/xml;

# Cloudflare: Brotli is enabled by default
# Go to Speed > Optimization > Content Optimization
# Confirm "Brotli" is set to "On"

User Experience Tools

Free tools for measuring, monitoring, and debugging page experience.

Google PageSpeed Insights

Lab and field data for any URL. Shows LCP, INP, CLS with detailed improvement suggestions and CrUX field data.

Free

Lighthouse

Open-source automated tool for auditing performance, accessibility, SEO, and best practices. Built into Chrome DevTools.

Free

Chrome DevTools Performance

Record and analyze runtime performance. Identify long tasks, render-blocking resources, layout shifts, and main thread bottlenecks.

Free

WebPageTest

Detailed waterfall charts, filmstrip view, and multi-location testing. Advanced debugging for render-blocking and load order issues.

Free

GTmetrix

Performance monitoring with Lighthouse-powered audits, historical tracking, and alerts for CWV regressions.

Free

CrUX Dashboard

Chrome User Experience Report dashboard. Real-user performance data from millions of Chrome users. Track CWV trends over time.

Free

Common UX Mistakes

Bad practices that wreck page experience and Core Web Vitals.

Bad Practice vs Best Practice

No viewport meta tag ✓ width=device-width, initial-scale=1
All CSS/JS loaded synchronously in head ✗ Critical CSS inlined, rest deferred
Images without width/height ✓ Explicit dimensions on all media
Font-display: block (hidden text) ✗ font-display: swap with size-adjust fallback
Intrusive popups on mobile ✓ Non-intrusive banners or delayed triggers
No CSS containment on components ✗ contain: layout paint on independent elements
Font size below 16px on mobile ✓ 16px base with rem-based scaling
Need Better Rankings

Let's Optimize Pages That Rank and Convert

Got pages stuck on page two? Traffic that won't convert? Let's fix it with a personalized on-page SEO audit.

Get a Free SEO Audit

Frequently Asked Questions

Common questions about user experience and page experience for SEO.

How does user experience affect SEO?

Through the page experience signals, which are Core Web Vitals and a set of mobile and interstitial checks, and through the behaviour that follows from them. Google has said the signals are a tiebreaker rather than a primary factor, which is true. What is not in dispute is that a slow page loses the visitor before it earns anything from them.

What are the Core Web Vitals?

LCP, which measures how long the largest content element takes to appear, INP, which measures how quickly the page responds to a tap, and CLS, which measures whether the layout shifts while it loads. Google evaluates them at the 75th percentile of real visits, so the median visitor is not the one who matters.

Should UX and SEO be handled by the same person?

The work overlaps heavily and the ordering does not. UX establishes what the page should do, and SEO establishes how a machine reads it. Most of the wins sit in the overlap: a faster page, a clearer structure, and a form that works on a phone. A team that splits them without a shared definition of the page tends to optimise two different pages.

Do intrusive interstitials affect rankings?

Yes, they are one of the named page experience signals, and they matter on mobile. A full-screen popup on a narrow screen hides the content the searcher came for. The fix is a smaller prompt, a delay before it appears, and a way to close it without hunting.

What are the best UX SEO practices for a small business site?

Fast on mobile, readable at any width, a clear path to the phone number and the form, and a page that says what the business does without making the reader scroll to find out. Almost every small business site loses more to the first impression than to anything on its checklist.

AA

Amir Ali

Founder of Clienvora, a content marketing agency that combines SEO and copywriting to drive rankings, traffic, and revenue. This checklist is maintained and updated regularly.