A mobile SEO checklist is a set of checks that confirm the mobile version of a site can be crawled, rendered and indexed by search engines and used on a phone, in that order. Since Google finished the move to mobile-first indexing, the mobile version is the one in the index, and whatever Googlebot Smartphone fetches at your URL is the document Google ranks, on desktop too.
That changes what “mobile-friendly” means for an audit. Most lists on this query still read like a 2016 mobile-friendly test, and the mobile optimization advice they carry is real: responsive layout, viewport tag, font size, page speed. Those items are on this list too, lower down. Before them comes a question none of those lists ask: does the page Googlebot Smartphone receives contain everything you think it does? A site can pass every layout check and still hand Google 60% of its content, and nothing in Lighthouse will say so. For most sites mobile users are the larger share of organic traffic, which the Device split in Search Console shows for yours, so a gap here costs more than the same gap on desktop would. If you only have time for four sections, do parity, crawlability, indexability and rendering.
The mobile SEO checklist
Twenty rows. The first fourteen decide whether Google has the page at all; the rest decide how it competes once it does. Each section below takes one group, and the numbering runs through.
| Check | Where to look | Passes when |
|---|---|---|
| 1. Body text matches desktop, per template | URL Inspection → View crawled page → HTML, against a desktop crawl | Word count on main is within a few percent; the diff is chrome, not content |
| 2. Headings are the same elements | Rendered mobile HTML | H1–H3 match by tag, not only by text |
| 3. Internal links in content and navigation | a[href] counts, main and nav separately | Second-level navigation and “related” links are in the HTML without a tap |
| 4. Images, metadata, canonical, robots, JSON-LD identical | Rendered mobile HTML | Same src and alt, same JSON-LD blocks, no mobile-only noindex |
5. robots.txt doesn’t block CSS, JS, fonts, images | robots.txt; URL Inspection → Page resources | No stylesheet or script listed as blocked |
| 6. Googlebot Smartphone gets the real page | curl -A "<Smartphone UA>" against the CDN hostname | 200 with the same HTML a phone gets; no challenge page, no 403 |
| 7. Google crawls as smartphone | Crawl stats → By Googlebot type; server logs | Smartphone line dominates |
| 8. HTML under 15 MB | Response size in the crawl | Under the limit, base64 images included |
9. No mobile-only noindex or X-Robots-Tag | Rendered HTML; response headers | URL Inspection says “Indexing allowed: Yes” |
| 10. Canonical self-referencing, or paired on m-dot | URL Inspection | Google-selected canonical equals user-declared |
| 11. No soft 404 on mobile templates | Pages report | Empty states return 404 or 410, or carry real content |
| 12. Content doesn’t depend on tap, scroll or storage | URL Inspection live test → rendered HTML, screenshot | Every block visible on a phone is in the rendered HTML |
| 13. Lazy loading works without scrolling | Rendered HTML; page source | Native loading="lazy" or IntersectionObserver; no scroll listeners |
| 14. Scripts fingerprinted | Build output | Filename changes when the file does |
| 15. Viewport tag | <head> | width=device-width, initial-scale=1; no user-scalable=no |
| 16. Configuration annotated | Response headers; <head> | Responsive; or Vary: User-Agent on dynamic serving; or alternate/canonical pairs on m-dot |
| 17. Core Web Vitals on phones | Search Console → Core Web Vitals; PageSpeed Insights field section | LCP ≤ 2.5 s, INP ≤ 200 ms, CLS ≤ 0.1 at p75, phone |
| 18. Images sized for the mobile viewport | LCP element in DevTools; srcset / sizes | Mobile source in srcset; width/height set; LCP image not lazy |
| 19. Tap targets, body text, interstitials | Lighthouse → Accessibility; page experience guidance | Targets ≥ 24 px, body ≥ 16 px, nothing covers the content on entry from search |
| 20. Structured data present and truthful on mobile | Rich Results Test, smartphone | Same JSON-LD as desktop; markup matches what the page shows |
Mobile-first indexing: what “mobile version” means to the crawler
Google announced the transition complete on 31 October 2023. The last exception ended on 5 July 2024, when the small set of sites still crawled with desktop Googlebot was moved to the smartphone crawler, and Google said at that point that a site whose content is not accessible on a mobile device would no longer be indexable. The mobile HTML is the indexed HTML. Titles, headings, internal links and structured data are read from it, including for desktop searches. Desktop Googlebot still makes a small share of requests, which Google describes as occasional verification crawling; the split is in Search Console under Settings → Crawl stats → By Googlebot type.
“Mobile version” here means what the smartphone crawler receives, and a person on a phone sees something else more often than designers expect. The crawler fetches with a US IP address by default, sends no Accept-Language header, holds no cookies from a previous request, and renders each URL from a clean state. A geo-redirect, a language gate or a consent wall that decides what to show based on any of those will decide it for Google too. Content that is in the DOM but collapsed in an accordion counts. Content that loads only after a tap does not.
THE DATES OLD CHECKLISTS MISS
1 Dec 2023 — Mobile Usability report, Mobile-Friendly Test and its API retired. The test URL now redirects to Lighthouse documentation.
12 Mar 2024 — INP replaces FID as the responsiveness Core Web Vital.
May 2024 — Lighthouse 12 moves viewport and font-size out of the SEO category, replaces tap-targets with target-size.
5 Jul 2024 — last desktop-crawled sites moved to Googlebot Smartphone.
Oct 2025 — Lighthouse 13 removes the legacy audit IDs and the font-size audit entirely.
1. Content parity: the check most of the list is about
The rule behind the first four rows of the mobile SEO checklist is simple to state: the mobile page must carry the same primary content, headings, links, images, video, metadata, robots directives and structured data as the desktop page. Google’s own guidance says the mobile version needs to be as complete as the desktop version. I read that with one qualification from my own audits: a footer link or two missing on mobile has never cost a site anything I could measure, while a missing H2 block or a menu level has, so the diff below weights the main content over the chrome. What makes parity hard is that it breaks per template. The homepage is fine, the category page dropped its filter links, the article page trimmed the FAQ, and a site-wide check averages the three into a pass.
Which mechanism did the hiding matters more than which block is missing. Content hidden with CSS is in the HTML and is indexed: Elementor’s elementor-hidden-mobile, Dawn’s small-hide class on Shopify, any display: none inside a media query. Content removed by a template condition is not in the HTML: a Liquid {% if %} on a section, a WordPress block with a device rule that resolves server-side, a React component that only mounts above a breakpoint. In the page builder the two settings sit next to each other and look the same.
| “Hide on mobile” done as | In the crawled HTML? | Indexed? |
|---|---|---|
CSS class or media query (display: none) | Yes | Yes |
Template condition (Liquid {% if %}, PHP, server-side device rule) | No | No |
| Component mounted only above a breakpoint (React, Vue) | No (renderer runs at mobile width) | No |
CSS text-overflow: ellipsis | Full text | Full text |
Liquid truncatewords, PHP substr | Truncated text | Truncated text |
The tool for this is URL Inspection → View crawled page → HTML, compared against a crawl run with the Googlebot Smartphone user agent and JavaScript rendering on. Compare counts first, then read the diffs where the counts move, per template type.
Body text: word count of the rendered mobile HTML against the desktop crawl, on main rather than the whole page, because navigation and footer noise hides the gap. Headings: mobile redesigns often keep the visual hierarchy and lose the tags, an H2 becoming a styled div, so check that H1–H3 are the same elements and not just the same text. Internal links: a[href] inside the main content and inside the navigation, counted separately. The three usual casualties are the footer, “related” blocks and the second level of navigation, and if the hamburger menu is built on tap, the links may not exist in the crawled HTML at all. Images: same src, same alt. Metadata and directives: title, description, robots meta, canonical, hreflang; a mobile-only noindex left over from staging is the one I find most often. Title tags and meta descriptions are the same tags on both devices, but Google cuts them by pixel width and the cut falls in a different place in mobile search results, so the keyword the page targets goes at the front of both.
2. Mobile crawlability: blocked resources and the user agent
A robots.txt that disallows /assets/, /static/, a theme folder or an image CDN path stops Googlebot from loading CSS, JS and images. The HTML arrives, the render is broken, and Google’s understanding of the page is whatever survives. That is the second of the two ways mobile crawlability fails (the first is the crawler not reaching the page at all), and it is the one I find more often, because nothing in Search Console says “blocked stylesheet” in so many words.
The checks: fetch robots.txt and ask, for every disallowed path, whether a stylesheet, script, font or image lives there. Confirm the mobile user agent isn’t filtered: Googlebot Smartphone identifies with an Android Chrome string plus the Googlebot/2.1 token (the string still names a Nexus 5X on Android 6.0.1, a phone from 2015, because Google froze it for compatibility and only updates the Chrome version inside it), and bot-management rules and CDN firewalls sometimes treat it differently from the desktop one, and a JavaScript challenge page returns 200 with no content, which is worse than a 403. Test with curl -A "<the string>" -I against the public hostname and with URL Inspection’s live test. HTML under 15 MB, since Googlebot stops reading past that point and inlined base64 images on mobile templates can push the file there. And the server logs, filtered by the smartphone string and verified against Google’s published ranges: if desktop Googlebot still dominates two years after the cutover, something on your side is serving it a different site. The full crawl layer, with crawl budget, redirect chains and the log reading, is Step 2 of the technical SEO audit.
3. Mobile indexability: noindex, canonical, soft 404
A page can be crawlable and still not make the index, or make it under a URL you didn’t choose. Most mobile indexability failures are a mobile template quietly violating one of Google’s three requirements: Googlebot not blocked, a 200 status, indexable content.
A noindex on the mobile template only, in the HTML or as an X-Robots-Tag header that a CDN edge rule adds to a path pattern and nobody sees in the source. A canonical pointing at a desktop URL from a mobile URL, which is correct only in a separate-URL setup and there only when paired with rel="alternate" on the desktop side. A mobile template that shows “no results” or an empty state with a 200 status, classified as soft 404 and dropped; category pages with mobile-only filtering are the usual source, and the classification runs on the rendered page, so a JavaScript “nothing found” message triggers it too. Faulty redirects: every mobile request sent to the homepage, chains through an old m-dot, loops between mobile and desktop URLs.
URL Inspection confirms three fields: “Crawled as: Googlebot smartphone”, “Indexing allowed: Yes”, and a Google-selected canonical that matches the user-declared one. When they disagree, four Pages report statuses are where it surfaces first.
| Pages report status | What it usually means on the mobile template |
|---|---|
Duplicate, Google chose different canonical than user | The mobile HTML duplicates another URL closely enough that Google overruled your canonical |
Duplicate without user-selected canonical | Canonical tag missing from the mobile template, or stripped by a plugin |
Soft 404 | Empty state or “no results” rendered at 200 on mobile |
Crawled – currently not indexed | Google fetched the mobile page and found too little in it; check the parity diff before anything else |
4. Mobile rendering: what the crawler never does
Nothing in this section is specific to phones, except that the renderer runs at mobile width and the mobile template is the one it runs on. Googlebot renders with an evergreen Chromium, so JavaScript by itself is fine. Content that depends on a user event isn’t, because the crawler doesn’t produce user events: it doesn’t scroll, tap, type or swipe, it doesn’t keep cookies, localStorage or sessionStorage between page loads, it declines permission prompts, it doesn’t run service workers, and it doesn’t index anything that lives only behind a #fragment. A page that reads a preference from storage before deciding what to show will show Google the default. Accordions and tabs toggled with CSS render; content fetched on tap (“load reviews”, “show specs”) doesn’t. Native loading="lazy" and IntersectionObserver render, because the renderer uses a tall viewport; lazy loading tied to scroll events never fires. Infinite scroll needs paginated URLs beneath it. The full table of what renders and what doesn’t, with the Screaming Frog filters that diff raw against rendered HTML per template, is Step 3 of the technical audit.
For one URL: open URL Inspection, run the live test, read the rendered HTML and the screenshot, and open “Page resources” under More info, where every stylesheet or script listed with “Other error” or “Blocked by robots.txt” is a resource the renderer went without. And since the renderer caches scripts and ignores your cache headers, ship changed files under fingerprinted names. If a block of content is on the page when you open it on a phone and absent from the rendered HTML, it isn’t indexed, whatever the design says.
5. Viewport, and the three mobile configurations
The viewport tag is one line, <meta name="viewport" content="width=device-width, initial-scale=1">, and the difference between a page rendering at a phone’s width and rendering at 980 CSS pixels shrunk to fit. (980 is a number from 2007: the original iPhone’s Safari picked it as the fallback width for pages that knew nothing about phones, and every mobile browser since has kept it.) The trouble comes from what people add to it: maximum-scale=1 and user-scalable=no block pinch-zoom, fail the meta-viewport accessibility audit, and have been ignored by iOS Safari since iOS 10, so they cost a failed audit and gain nothing. Lighthouse 12 moved the viewport audit out of the SEO category in May 2024, on the grounds that it is no longer a search priority; the tag still decides whether the page is readable.
| Configuration | How it works | What must hold |
|---|---|---|
| Responsive design | One URL, one HTML, CSS media queries | Viewport tag; no blocked CSS |
| Dynamic serving | One URL, different HTML by user agent | Vary: User-Agent header; both versions crawlable; parity |
| Separate URLs (m-dot) | Two URLs, two HTML documents | <link rel="alternate" media="only screen and (max-width: 640px)" href="…"> on desktop; rel="canonical" to desktop on mobile; matching hreflang pairs; 1:1 mapping |
Responsive is Google’s recommendation because it removes the parity problem by construction: there is one document. Tablets get the same responsive layout at their own width, and Google keeps no separate tablet index. Dynamic serving and m-dot sites can be indexed correctly, but every parity check has to be run twice, and the annotation pairs have to be right on every URL.
Dynamic serving has one failure that is specific to it. CDNs cache by URL, and most of them either strip Vary: User-Agent or normalize the user agent into a handful of buckets before the cache key. If Googlebot Smartphone lands in the desktop bucket, it is served the desktop HTML from cache, and every parity check you run from a phone passes while the index holds the wrong document. A curl with the Googlebot Smartphone string against the CDN hostname, not the origin, shows which bucket the crawler lands in. If you are building new, there is no case for an m-dot in 2026. If you already have one, leaving it is a migration: each mobile URL 301’d to its exact responsive counterpart from a table, one row per URL, because the paths on older m-dots rarely matched, and the old host redirecting for at least a year, Google’s stated minimum for a site move.
6. Mobile page speed and Core Web Vitals
Same page, same code, and the phone build of CrUX is red while desktop is green. That is the usual shape, because a mid-range Android on a cell connection has a fraction of the CPU and a multiple of the latency, and it is why mobile page speed gets its own section of the mobile SEO checklist. The thresholds themselves are unchanged: LCP at or under 2.5 seconds, INP at or under 200 milliseconds, CLS at or under 0.1, at the 75th percentile of real Chrome sessions over a rolling 28-day window. INP replaced FID on 12 March 2024, and any list that still names FID predates that. In the June 2026 CrUX dataset, 67.7% of origins had good LCP across all form factors, down over the spring, and Google’s own release notes put the regression mostly on Android.
Two things about the field data change what to fix. CrUX is Chrome-only, and on iOS there is no Chrome that counts, so the “mobile” numbers Google grades you on are Android Chrome whatever your analytics say about device share; a site with 70% iOS traffic is being judged on the other 30%, which are cheaper and slower phones than the iPhones in your reports. And Search Console’s Core Web Vitals report assigns status to a group of similar URLs by the worst metric in the group, so a slow header script or a third-party widget on one template turns hundreds of URLs red at once; fixes on individual pages don’t move the status, the template does. The lab profile in PageSpeed Insights and Lighthouse (a Moto G Power at 4× CPU slowdown, 150 ms round trip, 1.6 Mbps) is for finding causes; field data is the verdict.
The general fixes for load time help on any device: compressing images, minifying CSS and JavaScript, caching, a CDN. The mobile-specific causes, by metric. LCP: a hero image lazy-loaded or served at desktop size to a 390 px viewport, or a blocking web font when the LCP element is a heading. INP: third-party scripts (consent managers, chat, tag containers) and “delay JS until interaction” plugins that make the first tap pay for every script. CLS: images without width/height, ad slots and consent banners injected without reserved space, font swaps, all worse on a phone because the layout stacks vertically and a shift near the top pushes everything. The per-template reading, the first fix for each metric and the connection between server speed and crawl rate are Step 7 of the technical audit.
7. Mobile images and video
srcset and sizes on content images, with a source close to the mobile rendered width; the wrong sizes value makes the browser pick the largest candidate, which is why srcset alone often changes nothing. The target is the rendered width times the device pixel ratio, so a 390-pixel viewport at 3× needs a source around 1,170 pixels, not 390, and a 2,000-pixel desktop hero served to that viewport is still the single most common mobile LCP failure. Explicit width and height, or CSS aspect-ratio, on every image. WebP or AVIF with a fallback; AVIF has been in Safari since 16.4, so the <picture> fallback is for edge cases, not for Googlebot. loading="lazy" below the fold and never on the LCP image. Same images on mobile and desktop, same alt, since Google Images indexes from the mobile version.
Video: a poster image, the embed in the rendered HTML, and VideoObject markup with name, thumbnailUrl and uploadDate at minimum. Google’s video indexing now requires the video to be the main content of the page to count as a video page; a clip embedded halfway down an article gets a “video isn’t the main content” note in the Video pages report instead of a video result.
8. Mobile UX: tap targets, text, interstitials, overflow
Google folds mobile usability into “page experience” alongside Core Web Vitals, HTTPS and interstitials, and the user experience on mobile devices matters past the ranking: a page that is hard to use on a phone loses the visit and the conversion wherever it ranks. The items below are the ones with a measurable definition or a documented Google position.
Tap target size
The accessibility minimum, from WCAG 2.2 Success Criterion 2.5.8, is 24 by 24 CSS pixels; Google’s Material guidance puts the comfortable target at 48 by 48 dp. Lighthouse 12 replaced its old SEO tap-targets audit with a target-size audit under Accessibility, which checks the 24-pixel minimum, not the 48-pixel comfort level. The elements that fail in practice are inline text links stacked in footers, icon buttons without padding, and pagination controls. Padding fixes it; a larger icon changes nothing if the hit area stays the same.
Font size and readability
16 CSS pixels for body text is the working baseline, and on iOS there is a second reason for it: Safari auto-zooms the page when a form field with a font size under 16 pixels receives focus, which is the “page jumps when I tap the search box” complaint. Lighthouse 13, released in October 2025, removed the font-size audit entirely, and Google’s explanation was that it isn’t a current search signal. It still decides whether people read the page.
Interstitials and pop-ups
Google’s page experience guidance lists intrusive interstitials as a negative signal: full-screen overlays on entry from search, pop-ups that cover the main content, and standalone interstitials the user has to dismiss. Documented exceptions: legal notices such as cookie and age gates, login walls for gated content, and banners that use a reasonable amount of screen. The signal applies to the transition from a search result to the page, so an exit-intent pop-up on the second page of a session is outside it. A sticky CTA that covers a third of a phone screen is inside it, however it’s labeled in the design file.
Navigation, forms and overflow
Horizontal scrolling on a mobile page is a layout bug, usually a fixed-width table, an image without max-width: 100%, or an element with a negative margin. overflow-x: hidden on body hides the symptom and leaves the cause; the quick check is document.documentElement.scrollWidth > window.innerWidth in the console, then walk the DOM to the element that’s wider than the viewport. Forms: type="email", type="tel", inputmode="numeric", autocomplete and enterkeyhint, so the right keyboard and the right return key appear. Navigation links exist in the HTML whether or not the menu is open.
9. Mobile structured data
JSON-LD injected through Google Tag Manager is rendered and does work. It also inherits every risk in the rendering section and disappears the day someone pauses the container, which is a more common way to lose structured data on mobile than any markup error. The other way is a mobile template that drops or trims the block, or loads it inside a component that never renders for the crawler. Google’s position is that markup present on desktop has to be present on mobile, for the same reason as everything above: same JSON-LD blocks, in the initial HTML or the rendered DOM, not inside a lazy-loaded block.
Rich Results Test defaults to the smartphone crawler; run it as smartphone, then compare with a desktop run if in doubt. Prices, availability and ratings in the markup must match what the mobile page shows: mobile templates that hide the rating widget while keeping AggregateRating in the markup are what the “Structured data issue” manual action is for. Merchant listing eligibility needs Offer with price, priceCurrency and availability on the mobile product page, not only in the feed.
10. Mobile local search
An embedded Maps iframe is routinely the heaviest third party on a location page, and the hours and address are the sections most often hidden on small screens. Those two facts are most of mobile local SEO, since most local searches happen on a phone and most are decided in the map pack rather than the organic listing. The items: a Google Business Profile that is complete and matches the site’s NAP, LocalBusiness schema on the location pages on mobile, click-to-call links (tel:), and the map below the fold with loading="lazy". Location pages have to survive the parity check. Voice search queries on a phone resolve to the same local pack and the same pages, so there is no separate voice item; the hours, the address and the tel: link are the voice optimization.
How to test mobile SEO
Each tool in a mobile SEO checklist answers one question, and the usual mistake is asking Lighthouse whether a page is indexed.
| Question | Tool |
|---|---|
| What did Googlebot Smartphone fetch and render? | Search Console → URL Inspection → live test, rendered HTML, screenshot, Page resources |
| Is the page indexed, under which canonical? | URL Inspection, Pages report |
| Do real users pass Core Web Vitals on mobile? | Search Console → Core Web Vitals report; PageSpeed Insights (field section); CrUX History API; BigQuery chrome-ux-report filtered to form_factor = 'phone' |
| Why is a metric slow? | Lighthouse 13 insights; Chrome DevTools → Performance panel with mobile emulation and 4× CPU throttling |
| Is the structured data valid on mobile? | Rich Results Test (smartphone) |
| Does parity hold across templates? | A crawler with Googlebot Smartphone UA and rendering, diffed against desktop |
| Is Google crawling the mobile version? | Server logs filtered by the smartphone user agent; Crawl stats → By Googlebot type |
| Does the CDN serve Googlebot the right HTML? | curl -A "<Googlebot Smartphone UA>" -I https://… against the public hostname |
| Does it work on an actual phone? | An actual phone, on cellular, not office Wi-Fi |
Lighthouse 13 (October 2025) removed the legacy audit IDs, so any dashboard or CI check keyed to render-blocking-resources or offscreen-images needs re-mapping before its numbers mean anything.
When mobile is the cause of a ranking drop
Before blaming the mobile version for a drop, and before running the whole mobile SEO checklist on it, rule out the things that aren’t it: a page younger than a couple of months, a competitor with a much stronger link profile, or a SERP whose format changed; the order for that is the rankings loss audit. Then the device split in Search Console: Performance → Compare, last 28 days against the previous 28, with Device as the dimension. If mobile clicks fell while desktop held, something touched the mobile document, and three places explain most of it. The parity diff per template after a redesign: the new theme hid a block with a template condition instead of CSS, or hydrated a menu that used to be static HTML. The Pages report, where a rising Soft 404 or “Duplicate, Google chose different canonical” count is the same story from the index side. And the Core Web Vitals report turning red for a group, which is a shared template element: a script, a widget, an unsized hero, or a “delay JavaScript” optimization that shipped turned on.
Mobile SEO on WordPress and Shopify
The same mobile SEO failures keep turning up under the same names. On WordPress, page builders differ on what “hide on mobile” means: Elementor and Divi hide with CSS classes, so the block stays in the HTML, while some block-visibility plugins remove it server-side, so check the rendered HTML, not the setting. Core has skipped loading="lazy" on the first content image since 5.9 and added fetchpriority="high" to the likely LCP image since 6.3, so a lazy-loaded hero on a modern WordPress site is usually a theme or an image plugin overriding core. WP Rocket’s “Delay JavaScript execution” and “Remove Unused CSS”, and their equivalents in Perfmatters and LiteSpeed Cache, are the toggles to test individually against the rendered HTML and against field INP.
On Shopify, Liquid sections hidden on mobile through theme settings are removed from the HTML and fail parity, while Dawn’s small-hide and medium-hide classes are CSS and pass. Apps inject scripts through {{ content_for_header }}, which a theme can’t edit, and through app embeds, which can be switched off per app in the theme editor; the app embed list is where INP work on Shopify starts. Product JSON-LD comes from the theme, so a theme change can drop Offer and AggregateRating without anyone noticing until the rich results go.
If there is an 80/20 in this mobile SEO checklist, it is four sections: parity, blocked resources, indexability, rendering. They decide what Google has to work with; page speed and UX only decide how that document competes once it exists. Most sites I look at have a passing Lighthouse score and a mobile template that is missing something. The score was the easy part.
There is no mobile version of the index. There is the index, and it was built from the mobile page.
Mobile SEO checklist FAQ
What replaced Google’s Mobile-Friendly Test?
Nothing, one-for-one. Google retired it with the Search Console Mobile Usability report and the test API on 1 December 2023 and now points to Lighthouse. Lighthouse checks implementation details in the lab; PageSpeed Insights adds CrUX field data; URL Inspection shows the rendered mobile page for a property you own. Third-party “mobile-friendly checkers” are usually a wrapper around one of those three. AMP, for what it’s worth, hasn’t been required for Top Stories since June 2021, and a paired AMP setup is checked like any other pair: canonical one way, rel="amphtml" the other, content matching.
Does mobile SEO affect desktop rankings?
Rankings can still differ between devices; the document doesn’t. A heading that exists only on desktop is missing for both.
Can I work through a mobile SEO checklist without a developer?
The checks, yes. URL Inspection, the Pages report, the Core Web Vitals report, Rich Results Test and a rendered crawl are all readable without code. Most of the fixes are template work: the parity gaps, the lazy-loading changes, the INP sources. Expect the audit to be yours and the ticket to be a developer’s, and expect the ticket to take longer than the audit did.
Two things I’m not sure about. Whether Google still runs any desktop fetches for parity comparison after the 2024 cutover, and how long a fixed parity gap takes to reflect in rankings versus in the index. I have seen both take a week and both take a quarter.
One expectation, with its basis: Lighthouse has already moved the viewport, font-size and tap-target audits out of SEO and into accessibility, and dropped one of them. If that continues, by 2027 “mobile SEO” as a separate discipline will mean one thing, which is whether the smartphone crawler gets the whole document. If you’d rather have that checked on your site than check it yourself, that is our technical SEO audit.