ChatGPT answers, unedited

For a mobile-first site, the goal isn't just "does it work on a phone?"—it's whether real users on mobile networks and devices can complete tasks quickly and reliably. I would organize audits into six categories.

1. Performance (highest priority)

Mobile users are much more sensitive to delays.

Run:

• Lighthouse (Mobile profile)
• PageSpeed Insights (field + lab data)
• WebPageTest using:
  • Moto G Power or similar
  • Slow 4G
  • Cold cache
• Chrome DevTools Performance panel

Look for:

• Largest Contentful Paint (LCP)
• Interaction to Next Paint (INP)
• Cumulative Layout Shift (CLS)
• Time to First Byte (TTFB)
• Long JavaScript tasks
• Excessive main-thread blocking
• Image sizes
• Font loading
• Third-party scripts

Good targets:

• LCP < 2.5 s
• INP < 200 ms
• CLS < 0.1

2. Responsive design audit

Check:

• 320 px width
• 360 px
• 375 px
• 390 px
• 414 px
• tablets

Inspect:

• horizontal scrolling
• overflowing buttons
• clipped text
• navigation menus
• sticky headers
• modals
• keyboard interactions
• landscape mode

Chrome DevTools Device Mode is excellent for quickly testing multiple viewport sizes.

3. Touch usability

Common mobile-specific problems include:

• tap targets under 48×48 px
• links too close together
• hover-only interactions
• hidden menus
• tiny form controls
• accidental double taps
• sticky elements blocking content

Test with your thumb, not just a mouse.

4. Mobile forms

These often cause the most friction.

Check:

• correct keyboard types (email, tel, number)
• autocomplete
• password managers
• one-handed usability
• labels remain visible
• validation messages
• autofill support

Chrome DevTools can emulate mobile keyboards and touch input, but testing on actual phones is worthwhile.

5. Accessibility

Mobile accessibility differs from desktop.

Audit:

• touch target size
• zoom up to 200%
• screen reader navigation
• focus order
• color contrast
• visible focus indicators
• orientation changes

Tools:

• axe DevTools
• Lighthouse Accessibility audit
• WAVE
• VoiceOver (iPhone)
• TalkBack (Android)

6. Network conditions

Many mobile users aren't on fast Wi-Fi.

Test under:

• Slow 4G
• Fast 3G
• packet loss
• high latency

Look for:

• lazy loading behavior
• loading skeletons
• offline messaging
• retries
• API timeouts

WebPageTest excels at simulating realistic network conditions.

7. JavaScript audit

On mobile CPUs, JavaScript execution can be a major bottleneck.

Inspect:

• bundle size
• unused JavaScript
• hydration cost
• long tasks
• expensive React renders (if applicable)
• code splitting

Use:

• Lighthouse
• Chrome Performance panel
• Coverage tab
• React DevTools Profiler (for React apps)

8. Image audit

Verify:

• AVIF/WebP usage
• responsive srcset
• lazy loading
• proper dimensions
• compression
• no oversized hero images

Chrome DevTools' Network panel makes it easy to spot oversized downloads.

9. Mobile SEO

Although Google primarily uses mobile-first indexing, it's still important to verify:

• mobile viewport configuration
• canonical tags
• structured data
• robots directives
• crawl errors
• Core Web Vitals
• indexability

Use:

• Google Search Console
• Rich Results Test
• Screaming Frog SEO Spider

10. Device testing

Emulators are useful but won't catch everything.

Test on:

• iPhone Safari
• Chrome on Android
• Samsung Internet
• older Android devices
• low-memory phones

Cloud device labs:

• BrowserStack
• LambdaTest
• Firebase Test Lab

Mobile-specific issues many audits miss

Some problems rarely appear in desktop-focused checks but significantly affect mobile users:

• Fixed headers hiding content
• iOS viewport height (100vh) issues
• Safe area/notch handling
• Overscroll and scroll locking
• Virtual keyboard covering inputs
• Momentum scrolling problems
• Orientation changes
• Pull-to-refresh conflicts
• Sticky footers overlapping buttons
• Touch delays and gesture conflicts

Recommended audit workflow

For each major release, a practical sequence is:

1. PageSpeed Insights to review real-user Core Web Vitals.
2. Lighthouse (Mobile) for performance, accessibility, SEO, and best practices.
3. Chrome DevTools (Device Mode + Performance + Network throttling) to diagnose issues.
4. WebPageTest for realistic mobile network and device performance analysis.
5. axe DevTools for accessibility validation.
6. BrowserStack (or equivalent) to verify behavior on real iOS and Android devices.
7. Google Search Console to monitor mobile usability, indexing, and Core Web Vitals over time.

This combination provides broad coverage of performance, usability, accessibility, SEO, and device compatibility while surfacing issues that disproportionately impact mobile users.

For a mobile-first site, the goal isn't just "does it work on a phone?"—it's whether real users on mobile networks and devices can complete tasks quickly and reliably. I would organize audits into six categories.

1. Performance (highest priority)

Mobile users are much more sensitive to delays.

Run:

• Lighthouse (Mobile profile)
• PageSpeed Insights (field + lab data)
• WebPageTest using:
  • Moto G Power or similar
  • Slow 4G
  • Cold cache
• Chrome DevTools Performance panel

Look for:

• Largest Contentful Paint (LCP)
• Interaction to Next Paint (INP)
• Cumulative Layout Shift (CLS)
• Time to First Byte (TTFB)
• Long JavaScript tasks
• Excessive main-thread blocking
• Image sizes
• Font loading
• Third-party scripts

Good targets:

• LCP < 2.5 s
• INP < 200 ms
• CLS < 0.1

2. Responsive design audit

Check:

• 320 px width
• 360 px
• 375 px
• 390 px
• 414 px
• tablets

Inspect:

• horizontal scrolling
• overflowing buttons
• clipped text
• navigation menus
• sticky headers
• modals
• keyboard interactions
• landscape mode

Chrome DevTools Device Mode is excellent for quickly testing multiple viewport sizes.

3. Touch usability

Common mobile-specific problems include:

• tap targets under 48×48 px
• links too close together
• hover-only interactions
• hidden menus
• tiny form controls
• accidental double taps
• sticky elements blocking content

Test with your thumb, not just a mouse.

4. Mobile forms

These often cause the most friction.

Check:

• correct keyboard types (email, tel, number)
• autocomplete
• password managers
• one-handed usability
• labels remain visible
• validation messages
• autofill support

Chrome DevTools can emulate mobile keyboards and touch input, but testing on actual phones is worthwhile.

5. Accessibility

Mobile accessibility differs from desktop.

Audit:

• touch target size
• zoom up to 200%
• screen reader navigation
• focus order
• color contrast
• visible focus indicators
• orientation changes

Tools:

• axe DevTools
• Lighthouse Accessibility audit
• WAVE
• VoiceOver (iPhone)
• TalkBack (Android)

6. Network conditions

Many mobile users aren't on fast Wi-Fi.

Test under:

• Slow 4G
• Fast 3G
• packet loss
• high latency

Look for:

• lazy loading behavior
• loading skeletons
• offline messaging
• retries
• API timeouts

WebPageTest excels at simulating realistic network conditions.

7. JavaScript audit

On mobile CPUs, JavaScript execution can be a major bottleneck.

Inspect:

• bundle size
• unused JavaScript
• hydration cost
• long tasks
• expensive React renders (if applicable)
• code splitting

Use:

• Lighthouse
• Chrome Performance panel
• Coverage tab
• React DevTools Profiler (for React apps)

8. Image audit

Verify:

• AVIF/WebP usage
• responsive srcset
• lazy loading
• proper dimensions
• compression
• no oversized hero images

Chrome DevTools' Network panel makes it easy to spot oversized downloads.

9. Mobile SEO

Although Google primarily uses mobile-first indexing, it's still important to verify:

• mobile viewport configuration
• canonical tags
• structured data
• robots directives
• crawl errors
• Core Web Vitals
• indexability

Use:

• Google Search Console
• Rich Results Test
• Screaming Frog SEO Spider

10. Device testing

Emulators are useful but won't catch everything.

Test on:

• iPhone Safari
• Chrome on Android
• Samsung Internet
• older Android devices
• low-memory phones

Cloud device labs:

• BrowserStack
• LambdaTest
• Firebase Test Lab

Mobile-specific issues many audits miss

Some problems rarely appear in desktop-focused checks but significantly affect mobile users:

• Fixed headers hiding content
• iOS viewport height (100vh) issues
• Safe area/notch handling
• Overscroll and scroll locking
• Virtual keyboard covering inputs
• Momentum scrolling problems
• Orientation changes
• Pull-to-refresh conflicts
• Sticky footers overlapping buttons
• Touch delays and gesture conflicts

Recommended audit workflow

For each major release, a practical sequence is:

1. PageSpeed Insights to review real-user Core Web Vitals.
2. Lighthouse (Mobile) for performance, accessibility, SEO, and best practices.
3. Chrome DevTools (Device Mode + Performance + Network throttling) to diagnose issues.
4. WebPageTest for realistic mobile network and device performance analysis.
5. axe DevTools for accessibility validation.
6. BrowserStack (or equivalent) to verify behavior on real iOS and Android devices.
7. Google Search Console to monitor mobile usability, indexing, and Core Web Vitals over time.

This combination provides broad coverage of performance, usability, accessibility, SEO, and device compatibility while surfacing issues that disproportionately impact mobile users.

For a mobile-first site, the goal isn't just "does it work on a phone?"—it's whether real users on mobile networks and devices can complete tasks quickly and reliably. I would organize audits into six categories.

1. Performance (highest priority)

Mobile users are much more sensitive to delays.

Run:

• Lighthouse (Mobile profile)
• PageSpeed Insights (field + lab data)
• WebPageTest using: - Moto G Power or similar
• Slow 4G
• Cold cache
• Chrome DevTools Performance panel

Look for:

• Largest Contentful Paint (LCP)
• Interaction to Next Paint (INP)
• Cumulative Layout Shift (CLS)
• Time to First Byte (TTFB)
• Long JavaScript tasks
• Excessive main-thread blocking
• Image sizes
• Font loading
• Third-party scripts

Good targets:

• LCP < 2.5 s
• INP < 200 ms
• CLS < 0.1

2. Responsive design audit

Check:

• 320 px width
• 360 px
• 375 px
• 390 px
• 414 px
• tablets

Inspect:

• horizontal scrolling
• overflowing buttons
• clipped text
• navigation menus
• sticky headers
• modals
• keyboard interactions
• landscape mode

Chrome DevTools Device Mode is excellent for quickly testing multiple viewport sizes.

3. Touch usability

Common mobile-specific problems include:

• tap targets under 48×48 px
• links too close together
• hover-only interactions
• hidden menus
• tiny form controls
• accidental double taps
• sticky elements blocking content

Test with your thumb, not just a mouse.

4. Mobile forms

These often cause the most friction.

Check:

• correct keyboard types (email, tel, number)
• autocomplete
• password managers
• one-handed usability
• labels remain visible
• validation messages
• autofill support

Chrome DevTools can emulate mobile keyboards and touch input, but testing on actual phones is worthwhile.

5. Accessibility

Mobile accessibility differs from desktop.

Audit:

• touch target size
• zoom up to 200%
• screen reader navigation
• focus order
• color contrast
• visible focus indicators
• orientation changes

Tools:

• axe DevTools
• Lighthouse Accessibility audit
• WAVE
• VoiceOver (iPhone)
• TalkBack (Android)

6. Network conditions

Many mobile users aren't on fast Wi-Fi.

Test under:

• Slow 4G
• Fast 3G
• packet loss
• high latency

Look for:

• lazy loading behavior
• loading skeletons
• offline messaging
• retries
• API timeouts

WebPageTest excels at simulating realistic network conditions.

7. JavaScript audit

On mobile CPUs, JavaScript execution can be a major bottleneck.

Inspect:

• bundle size
• unused JavaScript
• hydration cost
• long tasks
• expensive React renders (if applicable)
• code splitting

Use:

• Lighthouse
• Chrome Performance panel
• Coverage tab
• React DevTools Profiler (for React apps)

8. Image audit

Verify:

• AVIF/WebP usage
• responsive srcset
• lazy loading
• proper dimensions
• compression
• no oversized hero images

Chrome DevTools' Network panel makes it easy to spot oversized downloads.

9. Mobile SEO

Although Google primarily uses mobile-first indexing, it's still important to verify:

• mobile viewport configuration
• canonical tags
• structured data
• robots directives
• crawl errors
• Core Web Vitals
• indexability

Use:

• Google Search Console
• Rich Results Test
• Screaming Frog SEO Spider

10. Device testing

Emulators are useful but won't catch everything.

Test on:

• iPhone Safari
• Chrome on Android
• Samsung Internet
• older Android devices
• low-memory phones

Cloud device labs:

• BrowserStack
• LambdaTest
• Firebase Test Lab

Mobile-specific issues many audits miss

Some problems rarely appear in desktop-focused checks but significantly affect mobile users:

• Fixed headers hiding content
• iOS viewport height (100vh) issues
• Safe area/notch handling
• Overscroll and scroll locking
• Virtual keyboard covering inputs
• Momentum scrolling problems
• Orientation changes
• Pull-to-refresh conflicts
• Sticky footers overlapping buttons
• Touch delays and gesture conflicts

Recommended audit workflow

For each major release, a practical sequence is:

1. PageSpeed Insights to review real-user Core Web Vitals.
2. Lighthouse (Mobile) for performance, accessibility, SEO, and best practices.
3. Chrome DevTools (Device Mode + Performance + Network throttling) to diagnose issues.
4. WebPageTest for realistic mobile network and device performance analysis.
5. axe DevTools for accessibility validation.
6. BrowserStack (or equivalent) to verify behavior on real iOS and Android devices.
7. Google Search Console to monitor mobile usability, indexing, and Core Web Vitals over time.

This combination provides broad coverage of performance, usability, accessibility, SEO, and device compatibility while surfacing issues that disproportionately impact mobile users.

For a mobile-first site, the goal isn't just "does it work on a phone?"—it's whether real users on mobile networks and devices can complete tasks quickly and reliably. I would organize audits into six categories.

1. Performance (highest priority)

Mobile users are much more sensitive to delays.

Run:

• Lighthouse (Mobile profile)
• PageSpeed Insights (field + lab data)
• WebPageTest using:
  • Moto G Power or similar
  • Slow 4G
  • Cold cache
• Chrome DevTools Performance panel

Look for:

• Largest Contentful Paint (LCP)
• Interaction to Next Paint (INP)
• Cumulative Layout Shift (CLS)
• Time to First Byte (TTFB)
• Long JavaScript tasks
• Excessive main-thread blocking
• Image sizes
• Font loading
• Third-party scripts

Good targets:

• LCP < 2.5 s
• INP < 200 ms
• CLS < 0.1

2. Responsive design audit

Check:

• 320 px width
• 360 px
• 375 px
• 390 px
• 414 px
• tablets

Inspect:

• horizontal scrolling
• overflowing buttons
• clipped text
• navigation menus
• sticky headers
• modals
• keyboard interactions
• landscape mode

Chrome DevTools Device Mode is excellent for quickly testing multiple viewport sizes.

3. Touch usability

Common mobile-specific problems include:

• tap targets under 48×48 px
• links too close together
• hover-only interactions
• hidden menus
• tiny form controls
• accidental double taps
• sticky elements blocking content

Test with your thumb, not just a mouse.

4. Mobile forms

These often cause the most friction.

Check:

• correct keyboard types (email, tel, number)
• autocomplete
• password managers
• one-handed usability
• labels remain visible
• validation messages
• autofill support

Chrome DevTools can emulate mobile keyboards and touch input, but testing on actual phones is worthwhile.

5. Accessibility

Mobile accessibility differs from desktop.

Audit:

• touch target size
• zoom up to 200%
• screen reader navigation
• focus order
• color contrast
• visible focus indicators
• orientation changes

Tools:

• axe DevTools
• Lighthouse Accessibility audit
• WAVE
• VoiceOver (iPhone)
• TalkBack (Android)

6. Network conditions

Many mobile users aren't on fast Wi-Fi.

Test under:

• Slow 4G
• Fast 3G
• packet loss
• high latency

Look for:

• lazy loading behavior
• loading skeletons
• offline messaging
• retries
• API timeouts

WebPageTest excels at simulating realistic network conditions.

7. JavaScript audit

On mobile CPUs, JavaScript execution can be a major bottleneck.

Inspect:

• bundle size
• unused JavaScript
• hydration cost
• long tasks
• expensive React renders (if applicable)
• code splitting

Use:

• Lighthouse
• Chrome Performance panel
• Coverage tab
• React DevTools Profiler (for React apps)

8. Image audit

Verify:

• AVIF/WebP usage
• responsive srcset
• lazy loading
• proper dimensions
• compression
• no oversized hero images

Chrome DevTools' Network panel makes it easy to spot oversized downloads.

9. Mobile SEO

Although Google primarily uses mobile-first indexing, it's still important to verify:

• mobile viewport configuration
• canonical tags
• structured data
• robots directives
• crawl errors
• Core Web Vitals
• indexability

Use:

• Google Search Console
• Rich Results Test
• Screaming Frog SEO Spider

10. Device testing

Emulators are useful but won't catch everything.

Test on:

• iPhone Safari
• Chrome on Android
• Samsung Internet
• older Android devices
• low-memory phones

Cloud device labs:

• BrowserStack
• LambdaTest
• Firebase Test Lab

Mobile-specific issues many audits miss

Some problems rarely appear in desktop-focused checks but significantly affect mobile users:

• Fixed headers hiding content
• iOS viewport height (100vh) issues
• Safe area/notch handling
• Overscroll and scroll locking
• Virtual keyboard covering inputs
• Momentum scrolling problems
• Orientation changes
• Pull-to-refresh conflicts
• Sticky footers overlapping buttons
• Touch delays and gesture conflicts

Recommended audit workflow

For each major release, a practical sequence is:

1. PageSpeed Insights to review real-user Core Web Vitals.
2. Lighthouse (Mobile) for performance, accessibility, SEO, and best practices.
3. Chrome DevTools (Device Mode + Performance + Network throttling) to diagnose issues.
4. WebPageTest for realistic mobile network and device performance analysis.
5. axe DevTools for accessibility validation.
6. BrowserStack (or equivalent) to verify behavior on real iOS and Android devices.
7. Google Search Console to monitor mobile usability, indexing, and Core Web Vitals over time.

This combination provides broad coverage of performance, usability, accessibility, SEO, and device compatibility while surfacing issues that disproportionately impact mobile users.

For a mobile-first site, the goal isn't just "does it work on a phone?"—it's whether real users on mobile networks and devices can complete tasks quickly and reliably. I would organize audits into six categories.

1. Performance (highest priority)

Mobile users are much more sensitive to delays.

Run:

• Lighthouse (Mobile profile)
• PageSpeed Insights (field + lab data)
• WebPageTest using:
  • Moto G Power or similar
  • Slow 4G
  • Cold cache
• Chrome DevTools Performance panel

Look for:

• Largest Contentful Paint (LCP)
• Interaction to Next Paint (INP)
• Cumulative Layout Shift (CLS)
• Time to First Byte (TTFB)
• Long JavaScript tasks
• Excessive main-thread blocking
• Image sizes
• Font loading
• Third-party scripts

Good targets:

• LCP < 2.5 s
• INP < 200 ms
• CLS < 0.1

2. Responsive design audit

Check:

• 320 px width
• 360 px
• 375 px
• 390 px
• 414 px
• tablets

Inspect:

• horizontal scrolling
• overflowing buttons
• clipped text
• navigation menus
• sticky headers
• modals
• keyboard interactions
• landscape mode

Chrome DevTools Device Mode is excellent for quickly testing multiple viewport sizes.

3. Touch usability

Common mobile-specific problems include:

• tap targets under 48×48 px
• links too close together
• hover-only interactions
• hidden menus
• tiny form controls
• accidental double taps
• sticky elements blocking content

Test with your thumb, not just a mouse.

4. Mobile forms

These often cause the most friction.

Check:

• correct keyboard types (email, tel, number)
• autocomplete
• password managers
• one-handed usability
• labels remain visible
• validation messages
• autofill support

Chrome DevTools can emulate mobile keyboards and touch input, but testing on actual phones is worthwhile.

5. Accessibility

Mobile accessibility differs from desktop.

Audit:

• touch target size
• zoom up to 200%
• screen reader navigation
• focus order
• color contrast
• visible focus indicators
• orientation changes

Tools:

• axe DevTools
• Lighthouse Accessibility audit
• WAVE
• VoiceOver (iPhone)
• TalkBack (Android)

6. Network conditions

Many mobile users aren't on fast Wi-Fi.

Test under:

• Slow 4G
• Fast 3G
• packet loss
• high latency

Look for:

• lazy loading behavior
• loading skeletons
• offline messaging
• retries
• API timeouts

WebPageTest excels at simulating realistic network conditions.

7. JavaScript audit

On mobile CPUs, JavaScript execution can be a major bottleneck.

Inspect:

• bundle size
• unused JavaScript
• hydration cost
• long tasks
• expensive React renders (if applicable)
• code splitting

Use:

• Lighthouse
• Chrome Performance panel
• Coverage tab
• React DevTools Profiler (for React apps)

8. Image audit

Verify:

• AVIF/WebP usage
• responsive srcset
• lazy loading
• proper dimensions
• compression
• no oversized hero images

Chrome DevTools' Network panel makes it easy to spot oversized downloads.

9. Mobile SEO

Although Google primarily uses mobile-first indexing, it's still important to verify:

• mobile viewport configuration
• canonical tags
• structured data
• robots directives
• crawl errors
• Core Web Vitals
• indexability

Use:

• Google Search Console
• Rich Results Test
• Screaming Frog SEO Spider

10. Device testing

Emulators are useful but won't catch everything.

Test on:

• iPhone Safari
• Chrome on Android
• Samsung Internet
• older Android devices
• low-memory phones

Cloud device labs:

• BrowserStack
• LambdaTest
• Firebase Test Lab

Mobile-specific issues many audits miss

Some problems rarely appear in desktop-focused checks but significantly affect mobile users:

• Fixed headers hiding content
• iOS viewport height (100vh) issues
• Safe area/notch handling
• Overscroll and scroll locking
• Virtual keyboard covering inputs
• Momentum scrolling problems
• Orientation changes
• Pull-to-refresh conflicts
• Sticky footers overlapping buttons
• Touch delays and gesture conflicts

Recommended audit workflow

For each major release, a practical sequence is:

1. PageSpeed Insights to review real-user Core Web Vitals.
2. Lighthouse (Mobile) for performance, accessibility, SEO, and best practices.
3. Chrome DevTools (Device Mode + Performance + Network throttling) to diagnose issues.
4. WebPageTest for realistic mobile network and device performance analysis.
5. axe DevTools for accessibility validation.
6. BrowserStack (or equivalent) to verify behavior on real iOS and Android devices.
7. Google Search Console to monitor mobile usability, indexing, and Core Web Vitals over time.

This combination provides broad coverage of performance, usability, accessibility, SEO, and device compatibility while surfacing issues that disproportionately impact mobile users.

For a mobile-first site, I’d audit in five areas: performance, responsive layout, usability, accessibility, and mobile SEO.

1. Performance / Core Web Vitals

Check:

• LCP — slow hero images, fonts, server response
• INP — sluggish taps, menus, forms, JS-heavy interactions
• CLS — layout shifts from images, ads, embeds, fonts
• Mobile page weight and request count
• JavaScript execution time
• Image sizing/compression and lazy loading
• Third-party scripts
• Caching/CDN behavior
• Slow 3G/4G behavior

Tools:

• Google PageSpeed Insights — excellent first pass; separates mobile and desktop and uses real-user CrUX data where available.
• Chrome DevTools Lighthouse — useful for repeatable lab audits.
• Chrome DevTools Performance panel — particularly useful for diagnosing INP/long tasks.

2. Responsive/layout problems

Specifically test:

• Horizontal scrolling/overflow
• Content clipped at narrow widths
• Buttons and controls that are too small
• Sticky headers covering content
• Menus/modals that don't fit the viewport
• Fixed-position elements obscuring CTAs
• Incorrect viewport configuration
• Images/video overflowing containers
• Tables and complex components on small screens
• Orientation changes

Tools:

• Chrome DevTools Device Mode — test many viewport sizes and mobile conditions.
• BrowserStack — useful for testing on actual device/browser combinations rather than just simulated screens.

3. Mobile UX

Test actual workflows, not just individual pages:

• Search
• Navigation
• Login/signup
• Checkout
• Forms
• Filtering/sorting
• Account actions
• Error recovery

Look for:

• Excessive scrolling
• Tiny tap targets
• Keyboard covering fields/buttons
• Autofill problems
• Poor focus behavior
• Accidental taps
• Slow feedback after tapping
• Important content buried below intrusive UI
• Popups/interstitials that are difficult to dismiss

4. Accessibility

Run:

• Keyboard/focus checks
• Screen-reader checks
• Color contrast
• Form labels/errors
• Heading structure
• Accessible names for buttons/icons
• Touch target sizing
• Zoom/reflow testing

Tools:

• WAVE
• axe DevTools
• Chrome DevTools' built-in accessibility tooling

Automated checks won't catch everything, so manually test representative mobile flows too.

5. Mobile SEO

Check:

• Mobile-friendly rendering
• Responsive content parity between mobile/desktop
• Title/meta descriptions
• Canonical URLs
• Structured data
• Robots directives
• Internal linking
• Image alt text
• Indexability
• JavaScript-rendered content

Tools:

• Google Search Console — especially Performance, Page Indexing, and Core Web Vitals.
• Google's Rich Results Test — structured-data validation.

A practical audit stack

If you want the highest signal with the least tooling, I'd use:

One important distinction: Lighthouse/PageSpeed can tell you that something is slow or problematic, but DevTools is often what tells you why. For a mobile-first site, I'd run both a lab test on throttled mobile conditions and examine your real-user CrUX/RUM data—otherwise you can optimize a synthetic scenario while missing what actual mobile users experience.

For a mobile-first site, I’d run the audit in five layers: responsive UI, mobile performance, interaction/touch, accessibility, and real-device/browser behavior.

1. Responsive/layout checks

Look specifically for:

• Horizontal scrolling or content clipped at narrow widths
• Breakpoints that fail around 320–430px widths
• Navigation, modals, tables, and forms overflowing
• Text becoming too small or requiring zoom
• Images/video not scaling correctly
• Fixed/sticky elements covering content or CTAs
• Elements that are technically visible but unusable because of tiny tap targets
• Portrait and landscape behavior
• Keyboard/input behavior on mobile
• 100vh/safe-area issues on phones with browser UI or notches
• Content/functionality missing from the mobile version

Tool: Chrome DevTools Device Mode is the first tool I'd use. It lets you test mobile viewports, orientations, touch behavior, CPU/network throttling, etc. But remember that emulation isn't equivalent to an actual phone; Chrome recommends real-device testing when behavior matters. developer.chrome.comdeveloper.chrome.com

2. Mobile performance

Prioritize the Core Web Vitals:

These thresholds are evaluated at the 75th percentile and should be segmented by mobile vs. desktop. web.dev

Also audit:

• JavaScript execution/main-thread blocking
• Image dimensions, compression and responsive images
• Render-blocking CSS/JS
• Font loading
• Third-party scripts
• Excessive DOM size
• Long tasks
• Memory usage
• Caching
• Network request count and payload size

Tools:

• PageSpeed Insights — particularly useful because you get both lab diagnostics and real-user/field data.
• Lighthouse — excellent for repeatable lab audits and CI.
• Chrome DevTools Performance — investigate why something is slow.
• WebPageTest — excellent when you want to specify device/network conditions. web.dev specifically recommends it for Web Vitals under particular device and network conditions. web.dev

3. Test under bad mobile conditions

Don't just resize Chrome.

Run important flows with:

• Slow/fast 3G or constrained 4G
• CPU throttling
• Empty cache
• Cold page load
• Slow API responses
• Offline/intermittent connectivity where applicable

Chrome DevTools can independently throttle CPU and network and provides presets approximating mid- and low-tier mobile devices. developer.chrome.comdeveloper.chrome.com

This often exposes problems that a desktop audit completely misses—especially JS-heavy interactions, delayed rendering, and taps that do nothing while the main thread is busy.

4. Mobile interaction/accessibility

Audit the actual thumb-driven experience:

• Tap targets large enough and sufficiently separated
• No hover-only functionality
• Menus can be opened/closed with touch
• Back buttons behave predictably
• Forms use appropriate mobile input types
• Numeric/email/date fields invoke the right keyboard
• Focus isn't lost when virtual keyboards appear
• Error messages are visible without awkward scrolling
• Focus indicators remain usable
• Screen readers work with mobile navigation and dialogs
• Orientation changes don't break the flow
• Zoom isn't disabled unnecessarily

Run Lighthouse accessibility, but supplement it with manual keyboard/screen-reader and real-device testing.

5. Real-device/browser testing

I'd explicitly test your highest-value journeys on:

• iOS Safari
• Android Chrome
• At least one lower-end Android device
• Your site's most common mobile OS/browser combinations from analytics

Pay particular attention to:

Login → search → product/content page → primary conversion/action → checkout/form

Real devices matter because desktop emulation cannot reproduce all mobile browser, OS, CPU, API, and touch behavior. developer.chrome.comdeveloper.chrome.com

My practical audit stack

If you're managing the site rather than doing a one-off QA exercise, I'd use:

1. PageSpeed Insights — baseline mobile CWV/field data
2. Lighthouse CI — catch regressions on every release
3. Chrome DevTools Device Mode — responsive and interaction debugging
4. DevTools Performance + Network — investigate slow mobile experiences
5. WebPageTest — controlled device/network performance tests
6. Real iPhone + Android testing — final compatibility check

One important distinction: don't treat Lighthouse's mobile score as your mobile audit. It is a lab test. Your real-user mobile CWV data tells you what your actual audience experiences, while DevTools/WebPageTest help you reproduce and diagnose it. web.devweb.dev

If you tell me your stack (e.g. Next.js, React, WordPress, Shopify, etc.), I can narrow this into a release-gate checklist with specific Lighthouse/DevTools checks and thresholds.

For a mobile-first site, I’d audit performance, responsive behavior, usability, accessibility, and search separately. The biggest mistake is relying on a single “mobile score.”

1. Core mobile audit checks

2. Tools I’d use

Google Lighthouse
Run it specifically against mobile emulation. It highlights performance, accessibility, SEO, and best-practice issues. Pay particular attention to LCP, INP, CLS, render-blocking resources, image sizing, and unused JavaScript.

Google PageSpeed Insights
Useful because it combines lab testing with real-user Chrome data (CrUX). Look at the mobile results rather than just the overall score.

Google Search Console
Use it for search-side problems, particularly Core Web Vitals and indexing issues. Compare mobile URLs/templates where possible.

Chrome DevTools
Probably your most useful day-to-day tool. Device emulation lets you test viewport sizes, throttled networks/CPU, touch behavior, layout shifts, and responsive breakpoints. The Performance, Network, and Rendering panels are particularly valuable.

WebPageTest
Good for going beyond a single Lighthouse run. Test actual mobile connection profiles and inspect waterfalls, filmstrips, and repeat views.

BrowserStack / Sauce Labs
Use these when you need real-device/browser coverage—especially iOS Safari, which can expose problems Chrome emulation won't.

axe DevTools
Good automated accessibility coverage. Pair it with actual screen-reader and keyboard testing because automated tools won't catch everything.

3. Mobile-specific checks I'd prioritize

If you're managing an existing site, I'd start with these:

1. Test 320–375px widths — find overflow and cramped layouts.
2. Throttle to a realistic mobile connection — identify pages that are technically responsive but painfully slow.
3. Measure Core Web Vitals on mobile — especially LCP and INP.
4. Inspect JavaScript execution — excessive JS can make a page feel slow even when network transfer is reasonable.
5. Check mobile image payloads — compare displayed dimensions against downloaded dimensions.
6. Test forms with the virtual keyboard open.
7. Check every fixed/sticky element — cookie banners, bottom navs, chat widgets, etc. often obstruct content on phones.
8. Test iOS Safari separately.
9. Check touch targets and spacing.
10. Verify mobile contains the same important content and structured data as desktop.

A practical audit stack

If you want a relatively lean setup:

Lighthouse + PageSpeed Insights + Chrome DevTools + Search Console + real-device testing

That gives you a strong combination of synthetic testing, real-user data, responsive debugging, SEO, and actual device behavior without needing a huge toolchain.

If you tell me whether your site is e-commerce, SaaS, publishing/content, or something else, I can narrow this into the highest-value mobile checks for that type of site.

For a mobile-first site, I’d audit in five areas: performance, rendering/responsiveness, UX/accessibility, SEO, and real-device behavior.

1. Performance

Check:

• Core Web Vitals: LCP, INP, CLS
• Time to first byte and server response
• JavaScript execution/main-thread blocking
• Image sizes, formats, and responsive images
• Font loading and layout shifts
• Third-party scripts
• Mobile network behavior (especially 4G/throttled connections)
• Total page weight and request count

Tools

• Google PageSpeed Insights — quickest overall mobile performance audit.
• Google Lighthouse — performance, accessibility, SEO, and best-practice checks.
• Google Chrome DevTools — CPU/network throttling, device emulation, performance traces.
• WebPageTest — particularly useful for testing different mobile devices, networks, and locations.

2. Responsive/rendering problems

Test at least:

• 320–375px widths
• 390–430px widths
• Tablet widths
• Portrait and landscape
• Zoom/text scaling
• Long localized strings
• Dynamic content and error states
• Fixed/sticky headers and bottom navigation
• Modals, dropdowns, tables and horizontal scrolling

Look specifically for content clipped off-screen, accidental horizontal scrolling, tiny tap targets, overlapping elements, and controls that become unusable when the viewport changes.

Chrome DevTools' device emulation is good for initial coverage, but don't treat it as equivalent to testing on physical phones.

3. Mobile UX + accessibility

Audit:

• Tap target size and spacing
• Keyboard/focus behavior
• Screen-reader navigation
• Form fields and validation
• Input types (tel, email, number, etc.)
• Autofill
• Contrast
• Text resizing
• Orientation changes
• Reduced-motion preferences
• Touch gestures and swipe interactions

Tools

• Lighthouse accessibility
• axe / axe DevTools
• Chrome DevTools
• VoiceOver on iOS
• TalkBack on Android

Automated tools won't catch many mobile usability problems, so manual device testing matters here.

4. Mobile SEO

Check:

• Mobile-friendly rendering
• Same important content and structured data between mobile/desktop
• Correct viewport configuration
• No blocked CSS/JS/resources needed for rendering
• Canonical URLs
• Internal linking/navigation
• Mobile Core Web Vitals
• Structured data
• Intrusive interstitials
• Image indexing/alt text

Use Google Search Console alongside Lighthouse/PageSpeed to find issues that aren't apparent from a single page test.

5. Real-device testing

This is where mobile-specific bugs often emerge. Test a representative matrix such as:

For a larger site, BrowserStack or Sauce Labs can provide device/browser coverage without maintaining a physical-device lab.

My recommended audit stack

If you want an efficient workflow rather than dozens of tools:

Every release:
Lighthouse + PageSpeed Insights + automated axe checks

Weekly/periodically:
Search Console + WebPageTest + real-device regression tests

For debugging a specific mobile problem:
Chrome DevTools → device emulation → network/CPU throttling → Performance trace → physical-device verification

Most important: don't optimize solely for Lighthouse's mobile score. A site can score well while still having bad touch UX, awkward forms, broken Safari behavior, or poor performance on an actual mid-range Android phone.

For a mobile-first site, I’d audit in roughly this order:

The mobile-specific checks I wouldn't skip

1. Test on an actual phone, not just desktop DevTools emulation. Pay particular attention to Safari on iOS.
2. Throttle the network and CPU in DevTools. A site that feels instant on your desktop can become painfully slow on a mid-range phone.
3. Check LCP specifically on mobile—large hero images, fonts, consent banners, and client-rendered content are frequent culprits.
4. Investigate INP for menus, filters, search, checkout, and other interactions. Mobile CPU constraints make excessive JavaScript especially visible.
5. Look for horizontal scrolling at every breakpoint.
6. Check tap targets and sticky/fixed elements at the bottom and top of the viewport.
7. Test with text zoom/accessibility settings enabled.
8. Compare mobile and desktop content—don't accidentally hide important headings, links, product information, or structured data on mobile.
9. Test portrait → landscape → portrait and small-screen widths.
10. Use field data, not Lighthouse alone. Lab tests tell you what can happen; CrUX/Search Console can reveal what actual mobile visitors experience.

A particularly useful workflow

Search Console → PageSpeed Insights → DevTools → real devices → field monitoring

That combination catches both technical problems and problems that only appear under real mobile conditions.

If you tell me your stack (e.g. Next.js, WordPress, Shopify, plain React), I can also give you a prioritized mobile audit checklist with specific thresholds and DevTools steps.

For a mobile-first site, I’d audit beyond “does it fit on a phone?” and focus on performance, usability, accessibility, rendering, SEO, and mobile behavior under real conditions.

1. Core mobile performance audits

Check:

• Core Web Vitals
  • LCP (Largest Contentful Paint): Is the main content visible quickly?
  • INP (Interaction to Next Paint): Do taps and gestures respond quickly?
  • CLS (Cumulative Layout Shift): Does the page jump while loading?
• JavaScript execution time
• Heavy images and videos
• Render-blocking resources
• Excessive third-party scripts
• Slow API/network calls
• Poor caching strategies

Tools:

• Google PageSpeed Insights
  • Strong starting point; includes mobile Lighthouse audits and Core Web Vitals.
• Chrome DevTools Lighthouse
  • Run throttled mobile simulations and inspect specific failures.
• WebPageTest
  • Useful for real device/network testing, waterfalls, and filmstrips.

2. Responsive layout and viewport checks

Check:

• Does every page have a correct viewport declaration?
• Are layouts usable at:
  • 320px width phones
  • large phones
  • tablets
  • landscape mode
• Are buttons large enough to tap?
• Are sticky headers/footers blocking content?
• Are modals, dropdowns, and forms usable on touch screens?
• Do images and tables overflow?

Tools:

• Chrome DevTools Device Mode
  • Test many screen sizes and simulate mobile conditions.
• BrowserStack
  • Test on real phones and operating systems.
• Sauce Labs
  • Useful for larger device/browser coverage.

3. Mobile usability and interaction audits

Check:

• Tap targets are large enough
• Forms work with mobile keyboards
• Autofill works correctly
• Inputs use appropriate types:
  • email
  • tel
  • number
• No hover-only interactions
• Back button behavior works correctly
• Scroll performance is smooth
• Gestures do not conflict with browser behavior

Tools:

• Lighthouse accessibility + best-practice audits
• Manual testing on:
  • iOS Safari
  • Android Chrome
  • low-end devices
  • slow networks

4. Mobile SEO audits

Check:

• Mobile page content matches desktop content where applicable
• Mobile pages are indexable
• Structured data works
• Internal links are usable
• Fonts are readable without zooming
• Intrusive interstitials are avoided
• Images have proper dimensions and alt text

Tools:

• Google Search Console
  • Check mobile indexing, page experience, and search issues.
• Google Rich Results Test
  • Validate structured data.
• Screaming Frog SEO Spider
  • Crawl mobile configurations, metadata, links, and technical issues.

5. Accessibility audits (especially important on mobile)

Check:

• Text contrast
• Screen-reader navigation
• Focus states
• Form labels
• Error messages
• Dynamic content announcements
• Touch target sizing
• Zoom support

Tools:

• axe DevTools
• WAVE Web Accessibility Evaluation Tool
• Lighthouse accessibility audits

6. Network and device-condition testing

Mobile users often have:

• slower CPUs
• inconsistent networks
• limited battery
• older browsers

Check:

• Performance on:
  • 3G/4G throttling
  • low-memory devices
  • older Android phones
• Offline/error states
• Retry behavior
• Loading indicators

Tools:

• Chrome DevTools Network throttling
• WebPageTest mobile profiles
• Real-device testing platforms

7. Progressive Web App (if applicable)

If your site behaves like an app, check:

Check:

• Installability
• Service worker correctness
• Offline handling
• App manifest
• Push notifications
• Cache strategy

Tools:

• Lighthouse PWA audit
• Chrome DevTools Application panel

8. Analytics and real-user monitoring

Synthetic tests miss real-world issues.

Track:

• Mobile Core Web Vitals
• Device/browser breakdown
• JavaScript errors
• Slow sessions
• Conversion drop-offs
• Rage clicks
• Form abandonment

Tools:

• Google Analytics
• Google Search Console
• Datadog Real User Monitoring
• New Relic Browser Monitoring

A practical mobile audit stack

For most teams, I’d run:

1. Lighthouse mobile audit → baseline issues
2. PageSpeed Insights → Core Web Vitals priorities
3. Search Console → Google mobile indexing problems
4. axe/WAVE → accessibility problems
5. Chrome DevTools device testing → layout and interaction bugs
6. WebPageTest → deep performance analysis
7. Real-user monitoring → confirm what actual users experience

For a production mobile-first site, repeat these after major releases, template changes, framework upgrades, and third-party script additions.

For a mobile-first site, I’d audit in five layers: rendering/layout, performance, interaction, accessibility, and SEO/indexability.

1. Responsive layout

Check at least:

• Common phone widths in portrait and landscape
• No horizontal scrolling
• Correct <meta name="viewport">
• Text remains readable without pinch-zoom
• Images/video fit their containers
• Navigation, menus, modals, tables, and forms work at narrow widths
• Fixed/sticky elements don't cover content
• Touch targets aren't cramped or overlapping
• Keyboard/virtual keyboard doesn't obscure important controls

Chrome DevTools Device Mode is particularly useful here: it can emulate viewport sizes, touch, orientation, CPU, and network conditions. But use real phones for final verification because emulation doesn't reproduce every mobile-browser behavior. developer.chrome.com

2. Mobile performance

Audit:

• LCP — target ≤2.5s
• INP — target ≤200ms
• CLS — target ≤0.1
• JavaScript execution and long tasks
• Image dimensions, formats, compression, and lazy loading
• Render-blocking CSS/JS
• Third-party scripts
• Font loading
• Cache/CDN behavior
• Excessive DOM size
• Network request count and payload size

The important distinction is field vs. lab data: Lighthouse is excellent for diagnosing problems, but your real users' Core Web Vitals should be measured from field data, ideally segmented by mobile vs. desktop. web.dev

3. Mobile interaction

Actually perform common journeys on a phone:

• Open/close navigation
• Search and autocomplete
• Sign-in/sign-up
• Checkout/payment
• Forms and validation
• Select/date controls
• Carousels and swipe gestures
• Infinite scroll
• Sticky headers/footers
• Copy/paste and autofill
• Orientation changes

Look especially for tap targets that are too small, accidental taps, delayed responses, scroll-jank, and UI that breaks when the virtual keyboard appears.

4. Accessibility

Run:

• Automated WCAG checks
• Keyboard navigation
• Screen-reader testing
• Zoom/text enlargement
• Focus visibility/order
• Color contrast
• Form labels and error messages
• Proper semantic HTML
• Touch targets and spacing

Responsive design and accessibility overlap significantly; for example, a properly responsive layout should continue working when users substantially enlarge content. web.dev

5. Mobile SEO

Check:

• Mobile-rendered HTML contains the important content
• Title/meta/structured data are correct
• Canonical and robots directives are correct
• Links are crawlable
• Images have appropriate alt text
• No mobile-only content that's missing from the primary version
• No intrusive interstitials
• Page speed/Core Web Vitals
• JavaScript rendering doesn't hide important content

Google Search Console is useful for finding pages Google considers problematic for mobile usability, while its Core Web Vitals reporting helps identify groups of affected URLs. support.google.com

Tools I'd put in the stack

Lighthouse documentation covers the automated audit categories, while Chrome DevTools provides the deeper debugging tools.

A practical cadence: run Lighthouse + automated accessibility on every meaningful release, test a representative set of real mobile journeys on both iOS and Android, and continuously monitor field Core Web Vitals. For a mobile-first site, don't treat the Lighthouse mobile score as the final verdict—it is a diagnostic simulation, not a substitute for real-user data. web.dev

For a mobile-first site audit, focus less on “does it look okay on a phone?” and more on whether the site is fast, usable, accessible, crawlable, and conversion-friendly under mobile constraints (small screens, touch input, variable networks, and mobile search behavior).

1. Mobile performance audits

Checks to run

• Core Web Vitals
  • LCP (Largest Contentful Paint): Is the main content loading quickly?
  • INP (Interaction to Next Paint): Are taps and interactions responsive?
  • CLS (Cumulative Layout Shift): Does content jump while loading?
• Mobile page weight:
  • Total JavaScript size
  • Unused JS/CSS
  • Image sizes and formats
  • Third-party scripts
• Network behavior:
  • Performance on slower connections (4G/3G simulation)
  • Caching and compression
  • Server response time

Tools

• Google PageSpeed Insights — quickest way to check mobile Core Web Vitals and performance opportunities
• Chrome DevTools Lighthouse — detailed audits with mobile throttling
• WebPageTest — advanced waterfall analysis, device and network testing

2. Responsive design and usability audits

Checks to run

• No horizontal scrolling
• Text readable without zooming
• Buttons and links large enough for touch
• Navigation works with one hand
• Forms are easy to complete on mobile
• Popups/interstitials do not block content
• Important actions are visible without excessive scrolling
• Sticky elements do not cover content

Tools

• Chrome DevTools Device Mode — test multiple screen sizes
• BrowserStack — real-device testing across phones and browsers
• Responsively App — view multiple device layouts simultaneously

3. Mobile SEO audits

Checks to run

• Mobile page rendering matches desktop content
• Google can crawl and render important elements
• Metadata works on mobile:
  • Title tags
  • Meta descriptions
  • Structured data
• Internal links are usable
• Mobile pages do not hide important content
• Canonicals and redirects are correct
• Page experience signals are healthy

Tools

• Google Search Console — indexing, mobile usability, Core Web Vitals
• Google Rich Results Test — structured data validation
• Screaming Frog SEO Spider — crawl issues, metadata, redirects, mobile rendering checks

4. Accessibility audits (especially important on mobile)

Checks to run

• Touch targets meet accessibility size guidelines
• Color contrast works on small screens
• Screen readers can navigate menus/forms
• Labels exist for inputs
• Focus states work with keyboard/accessibility tools
• Dynamic content changes are announced properly

Tools

• axe DevTools — automated accessibility testing
• WAVE Web Accessibility Evaluation Tool — visual accessibility checks
• Lighthouse accessibility audit — good baseline checks

5. Mobile conversion and UX audits

Checks to run

• Time to first meaningful action
• Tap errors and rage clicks
• Form abandonment
• Checkout friction
• Search usability
• Login/account flows
• Error handling on mobile keyboards
• App-like behaviors (if applicable)

Tools

• Microsoft Clarity — session recordings, heatmaps, rage clicks
• Hotjar — UX recordings and feedback tools
• Google Analytics — mobile funnel and behavior analysis

6. Mobile security and technical checks

Checks to run

• HTTPS everywhere
• Secure cookies
• Mixed-content issues
• Excessive permissions
• Third-party script risks
• Mobile-specific redirects
• PWA/security headers if applicable

Tools

• Mozilla Observatory — security header checks
• SSL Labs SSL Server Test — TLS/HTTPS configuration

Recommended audit workflow

1. Baseline performance
   • Run PageSpeed Insights on top mobile landing pages
   • Record Core Web Vitals

2. Technical crawl
   • Crawl site with Screaming Frog
   • Check mobile rendering, redirects, metadata, indexability

3. Real device testing
   • Test key journeys on:
     • iPhone Safari
     • Android Chrome
     • Slow mobile network

4. UX behavior review
   • Use Clarity/Hotjar recordings
   • Look for:
     • repeated taps
     • form exits
     • dead ends

5. Accessibility pass
   • Run axe + Lighthouse
   • Manually test navigation and forms

A practical “mobile-first health scorecard” usually includes:

• Core Web Vitals ✅
• Mobile usability ✅
• Crawl/indexing ✅
• Accessibility ✅
• Conversion friction ✅
• Real-device behavior ✅

For a production site, I’d prioritize PageSpeed Insights + Search Console + Screaming Frog + real-device testing first; those four usually uncover the highest-impact mobile issues.

For a mobile-first site, I’d audit in five layers: usability, performance, layout, accessibility, and mobile SEO.

Mobile audit checklist

Tools I'd use

• Chrome DevTools — device emulation, responsive breakpoints, network throttling, CPU throttling, touch simulation and performance profiling.
• Google PageSpeed Insights — quick mobile performance assessment and Core Web Vitals, including field data where available.
• Lighthouse — automated performance, accessibility, SEO and best-practice audits.
• WebPageTest — particularly useful for testing real mobile locations, connection profiles and repeat loads.
• Google Search Console — mobile indexing/search issues and Core Web Vitals from Google's field data.
• W3C Web Accessibility Initiative — accessibility guidance and testing resources.
• BrowserStack — useful when you need to test the actual site across many iOS/Android devices and browsers rather than relying only on emulation.

The mobile-specific checks I'd prioritize

If you have limited audit time, start with these:

1. Real-device critical journeys — homepage → navigation → search → product/content → form/checkout.
2. Core Web Vitals on cellular — especially LCP, INP, and CLS.
3. Tap-target usability — make sure important controls are comfortably tappable.
4. Viewport/layout failures — especially horizontal overflow and fixed/sticky UI consuming too much screen space.
5. Slow-device behavior — throttle CPU as well as network; a site can have good download performance but still feel sluggish because of JavaScript.
6. Mobile Safari specifically — don't assume Chrome's emulation catches iOS Safari behavior.
7. Forms — test keyboards, autofill, input types, validation, zooming, and error recovery.
8. Accessibility at small viewport sizes — zoom, dynamic text, focus, screen readers, contrast.
9. Mobile SEO rendering — verify Google sees the same essential content and structured data on the mobile version.
10. Real-user telemetry — compare performance/error rates by device, browser, connection, and viewport rather than relying exclusively on lab tests.

Best practical setup: use Lighthouse/PageSpeed for automated baselines, DevTools for diagnosing individual problems, WebPageTest for controlled mobile network/device performance, Search Console for Google's real-world data, and real iOS/Android devices for UX/browser validation.

For a mobile-first site, you’ll want audits that go beyond “does it render on a phone?” and check performance, usability, accessibility, SEO, and real-world mobile constraints (network, CPU, touch, viewport size).

Core mobile audits to run

Tools that highlight mobile-specific problems

1. Google Lighthouse

Best general-purpose mobile audit.

Checks:

• Performance
• Accessibility
• Best practices
• SEO
• PWA features

Run it with a mobile profile because Lighthouse throttles CPU/network to simulate realistic conditions.

Available in:

• Chrome DevTools Lighthouse documentation

2. Chrome DevTools Device Mode

Best for responsive debugging.

Use it to test:

• iPhone/Android viewport sizes
• Touch simulation
• Network throttling
• CPU throttling
• Layout shifts
• Console errors

Look especially for:

• Horizontal scrolling
• Hidden content
• Broken sticky headers
• Incorrect viewport settings

3. Google Search Console

Best for mobile SEO issues.

Look at:

• Mobile usability reports
• Indexing problems
• Core Web Vitals
• Page experience signals

Google Search Console

4. PageSpeed Insights

Best for performance benchmarking.

Highlights:

• Largest Contentful Paint (LCP)
• Interaction to Next Paint (INP)
• Cumulative Layout Shift (CLS)
• Image/script problems
• Mobile performance scores

PageSpeed Insights

5. WebPageTest

Best for deeper performance analysis.

Useful mobile tests:

• Real device testing
• Different network profiles
• Filmstrips
• Waterfall analysis
• JavaScript cost

WebPageTest

6. BrowserStack or similar device farms

Best for real-device coverage.

Test:

• iOS Safari quirks
• Android Chrome differences
• Older phones
• Different screen sizes
• Touch behavior

BrowserStack

7. Accessibility tools

For mobile accessibility:

• axe DevTools — automated accessibility checks
• WAVE Web Accessibility Evaluation Tool — visual accessibility feedback

Check:

• Button labels
• Form errors
• Focus order
• Contrast
• Screen reader navigation

8. SEO crawlers

For large sites:

• Screaming Frog SEO Spider
• Sitebulb

Look for:

• Mobile/desktop content differences
• Missing metadata
• Canonicals
• Broken links
• JavaScript rendering issues

A practical mobile audit workflow

Weekly automated checks

• Lighthouse CI
• Core Web Vitals monitoring
• Search Console monitoring
• Error tracking (JavaScript crashes, failed requests)

Monthly manual checks

Test key flows on:

• Small iPhone
• Large iPhone
• Mid-range Android
• Slow network

Flows:

• Landing page → signup
• Search
• Login
• Checkout/conversion path
• Forms
• Navigation

Before major releases

Run:

1. Lighthouse mobile audit
2. PageSpeed Insights comparison
3. Real-device testing
4. Accessibility scan
5. SEO crawl

Mobile-specific issues that commonly get missed

• A large hero image causing poor LCP
• Third-party scripts blocking interaction
• Sticky banners covering buttons
• Tap targets too small
• Input fields triggering the wrong keyboard type
• Cookie banners breaking layouts
• Font loading causing layout shifts
• Animations causing slow scrolling
• Desktop content hidden but still downloaded
• Forms that are painful with mobile keyboards

If you manage a production site, a good baseline is Lighthouse + Search Console + real-device testing + Core Web Vitals monitoring. Those four catch the majority of mobile-specific problems.

For a mobile-first site, I’d audit in these buckets:

The highest-value mobile checks

1. Test on an actual mid-range Android device, not just an emulated flagship.
2. Run Lighthouse with mobile throttling and look at the waterfall, not just the score.
3. Check LCP: particularly hero images, fonts, and server response time.
4. Check INP: menus, filters, search, forms, carousels and other interactions.
5. Look for horizontal overflow at common widths.
6. Verify every important control is comfortably tappable.
7. Test with the keyboard open—especially fixed bottom navigation and forms.
8. Test slow 4G + CPU throttling and a cold cache.
9. Compare mobile vs. desktop HTML/content so important content isn't accidentally omitted.
10. Test accessibility with VoiceOver on iOS and TalkBack on Android, because automated audits won't catch everything.

A practical tool stack

If you want a lean setup, I'd use:

• Lighthouse → broad automated audit
• PageSpeed Insights → lab + real-user Core Web Vitals
• Chrome DevTools → performance, network, layout, CPU/device simulation
• axe DevTools → deeper accessibility checks
• Google Search Console → mobile search/indexing issues
• Real phones → final UX/performance validation

The important distinction is that no single tool catches mobile problems comprehensively. Lighthouse is excellent for finding obvious issues, but real-device testing and RUM are what tell you whether mobile users actually experience them.

For a mobile-first site, you should go beyond checking whether the site is merely "responsive." The goal is to verify usability, performance, accessibility, SEO, and real-device behavior under mobile conditions.

Here's a practical audit checklist, along with tools that are especially good at finding mobile-specific issues.

1. Lighthouse (Start Here)

Run both:

• Mobile Performance
• Mobile Accessibility

It catches:

• render-blocking resources
• oversized images
• layout shifts
• tap target spacing
• viewport issues
• font sizing
• unused JavaScript
• caching problems

Run it using:

• Chrome DevTools
• PageSpeed Insights
• Lighthouse CLI

2. Chrome DevTools

Probably the single most valuable tool.

Useful panels:

• Device Toolbar
• Performance
• Network throttling
• CPU throttling
• Coverage
• Rendering
• Performance Insights

Specifically test:

• 4G throttling
• Slow CPU
• touch emulation
• orientation changes
• viewport resize
• dark mode
• reduced motion

Also enable:

• Paint flashing
• Layout Shift Regions
• FPS meter

These expose mobile rendering problems that desktop users never notice.

3. PageSpeed Insights

Unlike Lighthouse alone, this includes:

• real Chrome User Experience Report (CrUX) data
• Core Web Vitals from actual users
• mobile-specific metrics

Important metrics:

• LCP
• INP
• CLS

Sometimes lab tests look good while real mobile users experience poor performance.

4. BrowserStack or Sauce Labs

Desktop emulation isn't enough.

Test on:

• iPhone Safari
• Pixel Chrome
• Samsung Internet

Common issues found only on devices:

• fixed-position bugs
• viewport height issues
• keyboard resizing
• address bar expansion
• Safari scrolling quirks
• touch delay
• notch/safe-area problems

5. WebPageTest

Excellent for mobile performance.

Configure:

• Android phone
• 4G
• real Chrome
• repeat view

It provides:

• waterfall charts
• filmstrips
• CPU breakdown
• long tasks
• Largest Contentful Paint timing

6. Accessibility Tools

axe DevTools

Looks for:

• touch targets
• labels
• ARIA issues
• focus problems

WAVE

Good visual accessibility review.

Lighthouse Accessibility

Quick automated pass.

7. Responsive Layout Testing

Useful tools:

• Responsively App
• Polypane
• Chrome Device Mode

Check for:

• horizontal scrolling
• clipped buttons
• overflow
• images exceeding the viewport
• fixed headers hiding content
• modals that don't fit
• keyboard overlap

8. Google Search Console

The mobile-related reports can reveal issues such as:

• pages that aren't indexed correctly on mobile
• Core Web Vitals regressions
• crawl problems

While the old "Mobile Usability" report has been retired, Search Console still surfaces indexing and performance issues relevant to mobile-first sites.

9. Touch Experience Audit

Automated tools rarely catch these well.

Manually verify:

• buttons ≥44×44 px
• enough spacing between controls
• swipe gestures
• pull-to-refresh behavior
• long-press interactions
• pinch zoom (unless intentionally disabled)
• one-handed navigation
• thumb reach
• sticky navigation

10. Network Simulation

Test on:

• Slow 3G
• Fast 3G
• 4G
• offline mode

Look for:

• loading skeletons
• timeout handling
• retry logic
• image placeholders
• progressive rendering

11. Mobile UX Checklist

Review:

• font size (minimum ~16 px for body text is a common recommendation)
• line length
• spacing
• safe areas (iPhone notch, dynamic island)
• keyboard interactions
• form autofill
• input types (email, tel, number)
• password managers
• autofill support
• orientation changes
• zoom behavior
• dialogs
• bottom navigation
• fixed footers

12. Performance Metrics to Monitor

Track these over time:

• LCP
• INP
• CLS
• First Contentful Paint (FCP)
• Time to First Byte (TTFB)
• Total Blocking Time (TBT, for lab testing)
• JavaScript execution time
• image bytes
• CSS bytes
• unused JavaScript
• cache hit rate

Recommended Audit Workflow

1. Run Lighthouse (mobile mode) to identify baseline issues.
2. Check PageSpeed Insights to compare lab results with real-user mobile data.
3. Profile key pages in Chrome DevTools using CPU and network throttling.
4. Test on real iOS and Android devices (or a service like BrowserStack) to catch browser-specific issues.
5. Run axe DevTools for accessibility.
6. Use WebPageTest to inspect network waterfalls and rendering under realistic mobile conditions.
7. Manually verify touch interactions, forms, scrolling, orientation changes, and navigation.

This combination gives you coverage across automated checks, real-user performance, browser compatibility, accessibility, and hands-on mobile usability—areas where mobile-specific problems are most likely to surface.

For a mobile-first site, your audit should go beyond “does it load on a phone?” and cover performance, usability, accessibility, SEO, device behavior, and real-user experience. A good audit combines lab tools (controlled tests) and field data (actual users).

1. Mobile performance audit

Checks to run

• Core Web Vitals
  • LCP (Largest Contentful Paint): Is the main content appearing quickly?
  • INP (Interaction to Next Paint): Are taps and interactions responsive?
  • CLS (Cumulative Layout Shift): Does the page jump while loading?
• First load speed on:
  • Slow 4G / throttled networks
  • Low-end devices
  • Cold cache
• JavaScript cost:
  • Large bundles
  • Long main-thread tasks
  • Excessive third-party scripts
• Image efficiency:
  • Oversized images
  • Missing responsive formats
  • Poor compression
• Mobile caching and CDN behavior

Tools

• Google PageSpeed Insights — combines Lighthouse audits with Chrome UX data
• Chrome DevTools Lighthouse — detailed mobile performance diagnostics
• Chrome DevTools Performance panel — identifies JavaScript and rendering bottlenecks
• WebPageTest — useful for device/network simulations

2. Responsive design and layout audit

Checks to run

• Test common viewport sizes:
  • 320px wide phones
  • 375–430px modern phones
  • Tablets in portrait/landscape
• Verify:
  • No horizontal scrolling
  • Buttons are easy to tap
  • Navigation works with one hand
  • Forms fit without zooming
  • Sticky headers don’t block content
  • Modals and popups work on small screens
• Check orientation changes
• Test browser UI differences (Safari vs Chrome)

Tools

• Chrome DevTools Device Mode
• BrowserStack — real device/browser testing
• LambdaTest — cross-browser and device testing

3. Mobile usability audit

Checks to run

• Tap targets:
  • Are buttons large enough?
  • Are links spaced apart?
• Mobile navigation:
  • Can users reach key actions quickly?
  • Is search easy to access?
• Forms:
  • Correct mobile keyboards (email, tel, number)
  • Autofill support
  • Minimal fields
• Content:
  • Important information appears above the fold
  • Font sizes are readable
  • No desktop-only interactions (hover menus, tiny controls)

Tools

• Google Search Console Mobile Usability report
• Microsoft Clarity — session recordings and heatmaps
• Hotjar — behavior analysis and user feedback

4. Mobile SEO audit

Checks to run

• Mobile-first indexing readiness
• Same important content on mobile and desktop
• Structured data present on mobile pages
• Correct viewport configuration
• Crawlability:
  • No blocked mobile resources
  • No incorrect redirects
• Page titles and meta descriptions optimized for smaller screens

Tools

• Google Search Console
• Screaming Frog SEO Spider
• Ahrefs Webmaster Tools

5. Accessibility audit (especially important on mobile)

Checks to run

• Screen reader compatibility
• Sufficient color contrast
• Keyboard/focus behavior (for mobile assistive technologies too)
• Proper labels for form fields
• Accessible touch targets
• Reduced motion support

Tools

• axe DevTools
• WAVE Web Accessibility Evaluation Tool
• Lighthouse accessibility audits

6. Mobile security and reliability checks

Checks to run

• HTTPS everywhere
• No mixed content
• Secure cookie settings
• App-like features:
  • Service worker behavior
  • Offline handling
  • Installability if using a PWA
• Error handling on poor networks

Tools

• Mozilla Observatory
• Chrome DevTools Application panel

7. Analytics and real-user monitoring

Checks to run

• Compare mobile vs desktop:
  • Conversion rate
  • Bounce/engagement
  • Checkout completion
  • Search usage
  • Error rates
• Identify:
  • Slow devices
  • Slow geographic regions
  • Pages with mobile abandonment

Tools

• Google Analytics
• New Relic Browser Monitoring
• Datadog Real User Monitoring

A practical mobile audit workflow

1. Run Lighthouse mobile audit

→ Find obvious performance/accessibility/SEO issues

2. Check Search Console

→ Find Google-detected mobile problems

3. Test real devices

→ iPhone Safari, Android Chrome, low-end Android

4. Review field data

→ PageSpeed Insights + analytics + RUM

5. Watch real sessions

→ Clarity/Hotjar recordings for friction

6. Fix highest-impact issues first
   • Slow LCP
   • Broken navigation
   • Bad forms
   • Layout shifts
   • JavaScript delays

For a mobile-first site, I’d usually prioritize Core Web Vitals + real-device testing + user behavior recordings over purely automated scans, because many mobile problems only appear during actual touch interactions and network conditions.

For a mobile-first site, it's worth separating audits into a few categories: performance, usability, technical SEO, accessibility, and real-device testing. Many desktop-focused tools miss issues that only appear on phones, such as touch target sizing, viewport problems, or mobile CPU limitations.

Here's a practical audit checklist and the tools that are strongest in each area.

1. Performance audits

Focus on mobile results rather than desktop scores.

Important metrics:

• Largest Contentful Paint (LCP)
• Interaction to Next Paint (INP)
• Cumulative Layout Shift (CLS)
• Time to First Byte (TTFB)
• Total Blocking Time (lab metric)

Useful tools:

• Chrome Lighthouse
  • Simulates mid-range Android devices
  • Shows render-blocking resources
  • Highlights unused JavaScript
  • Flags oversized images

• PageSpeed Insights
  • Combines Lighthouse with real Chrome user data
  • Excellent for seeing whether actual mobile visitors experience problems

• WebPageTest
  • Test on real mobile devices
  • Throttle network conditions
  • Filmstrips
  • CPU analysis
  • Waterfall charts

2. Mobile usability

These are often missed by desktop audits.

Check for:

• buttons too close together
• font sizes below 16px
• pinch-zoom disabled
• horizontal scrolling
• fixed headers covering content
• sticky elements overlapping inputs
• viewport configuration
• safe-area support (iPhone notch)
• landscape behavior

Chrome DevTools Device Mode is excellent for quickly spotting these.

3. Responsive layout testing

Test:

• 320 px
• 360 px
• 375 px
• 390 px
• 414 px
• 768 px

Also test:

• portrait
• landscape
• foldable layouts
• tablets

Watch for:

• overflowing grids
• clipped buttons
• broken navigation
• off-screen dialogs

4. Touch interaction audits

Desktop users use a mouse.

Mobile users use fingers.

Look for:

• tap targets ≥44×44 px
• accidental taps
• hover-only navigation
• swipe gestures
• touch delays
• draggable components
• bottom navigation usability

Many accessibility tools also flag undersized touch targets.

5. Accessibility

Mobile accessibility differs slightly.

Audit:

• screen reader labels
• focus order
• color contrast
• dynamic font scaling
• reduced motion
• orientation changes
• zoom to 200%

Axe DevTools is especially helpful because it explains how to fix each issue.

6. Images

Common mobile issues:

• serving desktop images to phones
• missing srcset
• oversized hero images
• AVIF/WebP support
• lazy loading
• image decoding delays

Chrome DevTools identifies large downloads and unused image bytes.

7. JavaScript

Mobile CPUs are much slower.

Audit:

• long tasks
• hydration delays
• unnecessary frameworks
• large bundles
• third-party scripts
• excessive DOM size

The Performance panel in Chrome DevTools makes these issues visible.

8. Network conditions

Don't only test on fast Wi-Fi.

Test:

• Slow 4G
• Fast 3G
• packet loss
• high latency

A site that feels instant on fiber may feel sluggish on a mobile connection.

9. Mobile SEO

Verify:

• viewport meta tag
• canonical URLs
• robots directives
• structured data
• mobile rendering
• internal links
• lazy-loaded content visible to search engines

Google Search Console can reveal mobile indexing and usability issues affecting search visibility.

10. Real devices

Emulators are helpful but don't replace physical testing.

Test on:

• iPhone Safari
• Android Chrome
• Samsung Internet
• Firefox Android (if relevant)

Real devices uncover:

• keyboard overlap
• scrolling quirks
• viewport resizing
• browser UI interactions
• touch latency
• GPU rendering issues

Recommended audit workflow

For a thorough mobile audit:

1. Run Lighthouse in mobile mode.
2. Check PageSpeed Insights for real-user mobile Core Web Vitals.
3. Profile performance in Chrome DevTools on a throttled mobile device.
4. Test key user journeys on at least one real iPhone and one Android device.
5. Run Axe DevTools for accessibility issues.
6. Validate responsiveness across common breakpoints.
7. Use WebPageTest to inspect network waterfalls and rendering.
8. Monitor real-user performance with a RUM solution to catch issues that lab tests miss.

This combination covers both lab-based diagnostics and the real-world conditions that mobile users actually experience.

For a mobile-first site, your audit should go beyond “does it fit on a phone?” and check performance, usability, rendering, accessibility, SEO, and device-specific behavior.

1. Core mobile audit checks

2. Performance tools

Google PageSpeed Insights

Best starting point for:

• Mobile Core Web Vitals
• Performance scoring
• Image/script optimization suggestions
• Field data from real users (when available)

Chrome DevTools Lighthouse

Useful for:

• Simulating mobile devices
• Throttled networks/CPU
• Accessibility and SEO audits
• Progressive Web App checks

WebPageTest

Good for deeper analysis:

• Filmstrips of loading
• Waterfall charts
• Device/network simulations
• JavaScript and rendering bottlenecks

3. Real-device testing tools

BrowserStack

Useful for:

• Testing real iOS and Android devices
• Different browsers and OS versions
• Responsive layouts

Sauce Labs

Useful for:

• Automated mobile browser testing
• Device coverage
• Regression testing

Also test manually on:

• iPhone Safari (often the hardest mobile browser)
• Android Chrome
• Smaller phones
• Large phones
• Landscape mode
• Poor connectivity

4. Mobile UX and usability tools

Microsoft Clarity

Helps identify:

• Rage clicks
• Dead clicks
• Mobile session recordings
• Confusing navigation patterns

Hotjar

Useful for:

• Heatmaps
• User recordings
• Mobile funnel issues
• Form friction

Look specifically for:

• Users repeatedly tapping elements
• Users abandoning forms
• Scroll depth problems
• Unexpected backtracking

5. SEO and mobile crawl checks

Google Search Console

Check:

• Mobile usability issues
• Indexing problems
• Page experience reports
• Search appearance differences

Screaming Frog SEO Spider

Useful for:

• Crawling mobile user-agent views
• Finding missing metadata
• Detecting duplicate content
• Checking structured data

6. Accessibility checks

axe DevTools

Checks:

• Missing labels
• Contrast
• ARIA problems
• Keyboard accessibility

Also test:

• iOS VoiceOver
• Android TalkBack
• Zoom up to 200–400%

7. Image and asset audits

Check:

• Are images served in WebP/AVIF?
• Are responsive images (srcset) used?
• Are below-the-fold images lazy-loaded?
• Are mobile users downloading desktop-sized assets?

Tools:

• Chrome DevTools Network panel
• ImageKit Image Optimization Tool

Suggested audit workflow

1. Run baseline
   • PageSpeed Insights
   • Lighthouse mobile audit

2. Validate real devices
   • iOS Safari
   • Android Chrome
   • Low-end Android device if possible

3. Investigate UX
   • Session recordings
   • Heatmaps
   • Conversion funnels

4. Fix highest-impact issues
   • Large JS bundles
   • Slow images
   • Layout shifts
   • Tap/interaction issues

5. Monitor continuously
   • Search Console
   • Real User Monitoring (RUM)
   • Performance budgets in CI/CD

For a mobile-first production site, I’d prioritize Core Web Vitals + real-device testing + session recordings first; those usually reveal the issues that most affect users.

For a mobile-first site, it's useful to think of audits in layers: performance, usability, accessibility, SEO, and real-device behavior. Many desktop-focused audits won't catch issues that only appear on phones, such as touch target sizing, viewport problems, or mobile network performance.

Here's a practical checklist of what to audit and the tools that are best at finding each type of issue.

Performance audits

Mobile devices are often CPU-constrained, so look beyond page weight.

Prioritize:

• Largest Contentful Paint (LCP)
• Interaction to Next Paint (INP)
• Cumulative Layout Shift (CLS)
• Total JavaScript execution time
• Unused JavaScript and CSS
• Render-blocking resources
• Image formats (WebP/AVIF)
• Lazy loading
• Font loading strategy

Best tools

• PageSpeed Insights (combines lab and field data)
• Chrome DevTools Lighthouse
• Chrome Performance panel for CPU profiling

Mobile usability

These are issues that often only appear on phones.

Check for:

• Viewport meta tag
• Responsive layouts
• Horizontal scrolling
• Touch targets at least ~48×48 CSS pixels
• Text readable without zooming
• Sticky headers not hiding content
• Safe-area support for notched devices
• Landscape orientation
• Virtual keyboard behavior
• Form usability
• Tap delay and accidental taps

Tools

• Chrome DevTools Device Mode
• Real devices (iPhone and Android)
• BrowserStack

Accessibility

Many accessibility problems are amplified on mobile.

Audit:

• Color contrast
• Focus visibility
• Screen reader labels
• Form labels
• Accessible names for buttons
• Heading hierarchy
• Dynamic content announcements
• Zoom to 200%
• Motion reduction preferences

Tools

• axe DevTools
• WAVE
• Lighthouse Accessibility

Responsive layout testing

Test much more than the common breakpoints.

Recommended widths:

• 320 px
• 360 px
• 375 px
• 390 px
• 412 px
• 430 px
• 768 px

Look for:

• Overflow
• Cropped buttons
• Wrapping navigation
• Image scaling
• Fixed-width elements
• Modals exceeding viewport height

Network testing

Simulate realistic mobile conditions.

Test under:

• Slow 4G
• Fast 3G
• High latency
• Offline
• Cache disabled
• Empty browser cache

Watch for:

• Large API payloads
• Waterfall bottlenecks
• Blocking requests
• Third-party scripts delaying rendering

Mobile SEO

Review:

• Mobile-first indexing readiness
• Canonical tags
• Structured data
• Responsive images
• Viewport configuration
• Robots directives
• XML sitemaps

Use:

• Google Search Console
• PageSpeed Insights

PWA (if applicable)

If your site behaves like an app:

• Service worker registration
• Offline fallback
• Installability
• Manifest correctness
• Cache updates
• Background sync (if used)

Lighthouse includes a PWA audit for applicable sites.

Real-device testing

Emulators are helpful, but they don't perfectly reproduce real-world performance or browser behavior.

Test on:

• A recent iPhone
• An older iPhone
• A recent Android flagship
• A lower-end Android device
• Mobile Safari
• Chrome for Android
• Samsung Internet (if relevant to your audience)

User interaction testing

Try common user journeys using only touch.

Examples:

• Sign up
• Log in
• Search
• Filter products
• Complete checkout
• Fill forms
• Upload images
• Share links
• Rotate device mid-flow

Observe:

• Scroll jank
• Input lag
• Keyboard overlap
• Gesture conflicts
• Accidental taps
• Loading indicators

An efficient workflow

If you're running routine audits, a good sequence is:

1. Run PageSpeed Insights to identify Core Web Vitals and performance issues.
2. Use Lighthouse in mobile mode to catch performance, accessibility, SEO, and best-practice problems in one report.
3. Inspect layouts with Chrome DevTools Device Mode across multiple viewport sizes.
4. Validate accessibility with axe DevTools.
5. Test key user flows on at least one physical iPhone and one Android device.
6. Monitor Google Search Console for mobile usability, indexing, and real-user performance trends.

This combination covers both automated checks and the mobile-specific issues that synthetic audits alone often miss.