Shopify Technical SEO Audit: A 90-Minute Framework

The average Shopify store has 47 technical SEO issues that Google can see and a merchant cannot. Most of them are low-impact. Roughly 6 of them are costing the store real revenue every week. The job of an audit is not to list all 47. The job is to find the 6 that matter and fix them this sprint.

This is the 90-minute framework we run on every new D2C client before we touch a line of theme code or write a single brief. It produces a prioritized fix list, a set of measurable baselines, and enough context to know whether the problem is a Shopify platform quirk, a theme decision, an app collision, or a content gap.

TL;DR -> A good Shopify technical SEO audit is 90 minutes of crawling plus 30 minutes of interpretation, not a weeklong engagement that produces a 60-page PDF no one reads. -> The 4 files that do 80 percent of the work: Screaming Frog crawl, GSC Page indexing report, Ahrefs Site Audit health score, and a Core Web Vitals field data export from CrUX. -> Use the AUDIT-9 framework so you find issues in the same order every time and you stop missing the canonical and pagination bugs that quietly eat traffic. -> Fix order is always crawl blockers first, indexation second, template on-page third, internal linking fourth, speed fifth. Schema and copy polish come after, not before.

Before you start: the 15-minute setup

You cannot audit a store without baseline access. Get these in place before the clock starts or you will waste 30 minutes of the 90 trying to log in to things.

Access and tools you need:

-> Google Search Console property verified for the apex domain and all subdomains the store uses (some brands run us.brand.com and eu.brand.com). -> GA4 access at viewer level minimum, so you can pull landing page revenue and bounce by template. -> Screaming Frog SEO Spider installed, licensed, and configured to render JavaScript. Default settings will miss Shopify sections that hydrate client-side. -> Ahrefs or Semrush Site Audit project set up and a full crawl completed before the audit call. These take 20 to 90 minutes to run depending on site size, so queue them the night before. -> PageSpeed Insights and the Chrome UX Report (CrUX) for field Core Web Vitals. Lab data lies. Field data does not. -> Shopify admin with at least the Themes, Online Store, and Settings scopes. You need to see robots.txt.liquid and the theme code. -> A working spreadsheet or Notion database with columns for Issue, Severity, Template, Estimated traffic impact, Effort, Owner. If you skip this step the audit produces opinions, not a plan.

Configuration you do once per store:

-> Screaming Frog: enable JS rendering, set user agent to Googlebot Smartphone, respect robots.txt off (so you see blocked URLs), max URL budget set to 5x your product count plus collection, blog, and policy pages. -> Ahrefs: exclude /cart, /checkouts, /search, and any ?variant= or ?grid_list= parameters from crawl unless you specifically want to see faceted URLs. -> GSC: export Page indexing, Core Web Vitals mobile and desktop, and the top 1,000 queries for the last 28 days. These three files are your baseline.

If any of this is missing, stop and fix it. A technical audit on incomplete data is worse than no audit because it gives everyone a false sense of confidence.

The AUDIT-9 process

We name frameworks so teams remember them and follow the same order every time. AUDIT-9 is how we structure every Shopify technical SEO audit. The letters are not arbitrary. Each one maps to a decision the merchant has to make.

A - Access. Can Google reach and render the important pages? Robots.txt, meta robots, noindex headers, crawl budget, staging environments accidentally indexed.

U - URLs. Are URL structures clean, canonical, and stable? Canonical tags, trailing slashes, /collections/all/products/X vs /products/X, variant URLs, international duplicates.

D - Discovery. Can Google find every page that matters through internal linking, XML sitemaps, and collection structure? Orphan products, broken collection filters, footer links to retired pages.

I - Indexation. Is Google actually indexing those pages, and the right ones? GSC Page indexing report, site: operator sanity check, soft 404s, duplicate without user-selected canonical.

T - Templates. Do the core templates (product, collection, blog, home, policies) have correct title tags, meta descriptions, heading hierarchy, and internal linking by default?

-9 - the nine are the nine page templates every Shopify store has: home, collection, product, article, blog index, search, cart, account, policy. You audit each one against the same checklist. Missing a template is how stores end up with 2,000 perfectly optimized product pages and 400 collection pages that have no H1.

Run AUDIT-9 in order. The letters are dependencies. If Google cannot access a page, there is no point checking its schema. If the URLs are unstable, there is no point fixing internal links. Work top down.

Crawl and index coverage

This is where you spend the most time because this is where most of the money is.

Open Screaming Frog and run the JS-rendered crawl. While it runs, open GSC Page indexing. You are looking for a gap between the two. Screaming Frog shows what Google could crawl. GSC shows what Google chose to index. Anywhere those numbers diverge by more than 10 percent, there is a story.

Common patterns and what they mean:

-> Screaming Frog finds 4,200 URLs. GSC indexes 800. Either Google thinks the other 3,400 are thin, duplicate, or low-quality, or you have an indexation rule blocking them. Check "Crawled - currently not indexed" and "Discovered - currently not indexed" in GSC. -> Screaming Frog finds 800 URLs. GSC indexes 2,100. Shopify is indexing parameter URLs, variant URLs, or tag pages you did not realize existed. Filter the "Indexed" report by URL pattern. -> Huge "Duplicate without user-selected canonical" bucket. Usually means /collections/X/products/Y and /products/Y are both indexed. Shopify's default canonical tag handles this. If it is broken, it is almost always a theme customization. -> "Excluded by noindex tag" on pages that should index. Check theme.liquid for conditional noindex logic and check every app that touches head tags. Reviews apps and translation apps are frequent offenders.

What to check in robots.txt.liquid:

-> Confirm /checkouts/, /cart, /orders, /account are disallowed. They should be by default. -> Confirm /search is disallowed unless you specifically run internal search as a content strategy (most stores should not). -> Confirm no one added Disallow: /collections/ or Disallow: /products/ during a staging push. This happens more than you would think. -> Confirm sitemap directives point to sitemap.xml at the root.

Pull the sitemap.xml and walk the children: products, collections, pages, blogs. Every URL in the sitemap should return 200, have a self-referencing canonical, and be indexable. Every important URL on the site should be in the sitemap. The sitemap is the single cleanest signal you send Google about what matters. Treat it as a contract.

On-page templates

Now you check the 9 templates against the same on-page checklist. This is the numbered list that every technical SEO on our team runs through, every time, in order.

The 24-item Shopify template checklist:

1. Title tag present, under 60 characters, includes the primary keyword, brand name at the end.
2. Meta description present, under 155 characters, includes a call to action.
3. Exactly one H1 per page, matches or extends the title tag, not an image.
4. H2 and H3 structure is hierarchical, not skipped for styling reasons.
5. Canonical tag present and self-referencing (or correctly pointing to a canonical version).
6. hreflang present if the store has international versions, with a return tag on every language variant.
7. Open Graph title, description, and image present for social sharing.
8. Twitter Card tags present.
9. Schema.org markup present and valid for the template type (Product, Article, BreadcrumbList, Organization).
10. Breadcrumb navigation visible and crawlable, not just in schema.
11. Image alt text present on every content image, empty on purely decorative images.
12. Internal links in body copy where editorially natural, not just in navigation.
13. No broken internal links (Screaming Frog Response Codes report).
14. No redirect chains longer than one hop.
15. URL is lowercase, hyphen-separated, and stable (no auto-generated IDs where avoidable).
16. Page depth is 3 clicks or fewer from the homepage for any revenue-driving product.
17. Word count is appropriate for the template: product pages 200+ words of unique copy, collection pages 150+ words of unique copy, blog posts 800+ words.
18. Product images are compressed, next-gen format (WebP or AVIF), and have dimensions set.
19. LCP element is preloaded (usually the hero image or first product image).
20. No JavaScript errors in the console on page load (a common on-page ranking hit nobody checks).
21. Page returns a 200 status code from every important bot (Googlebot, GPTBot, PerplexityBot, ClaudeBot if you care about AEO).
22. Mobile viewport meta tag present and correct.
23. Favicon and touch icons present at correct paths.
24. No <link rel="prev/next"> markup (deprecated since 2019, still ships in some themes and is harmless but a signal of stale theme code).

Run this checklist against one URL from each template. If 20 of 24 items pass on the product template, the product template is healthy. If 14 of 24 pass, you have a template-level problem and fixing it fixes thousands of URLs at once. This is how Shopify stores get leverage.

For a deeper look at what good on-page looks like across a whole site, see our D2C ecommerce SEO guide for 2026.

Internal linking and orphan pages

Orphan pages are URLs that exist in your sitemap or Shopify catalog but have zero internal links pointing to them. Google crawls them rarely, ranks them poorly, and eventually stops indexing them. Every Shopify store over 500 SKUs has orphan products. Most have more orphans than they realize.

Find them in two passes.

First pass, crawl-based: Screaming Frog Reports menu, Orphan Pages report. This requires you to connect GSC and GA4 to the crawl so Frog can cross-reference URLs it did not find during the crawl against URLs that showed up in GSC or GA4. The delta is your orphan list.

Second pass, Ahrefs Site Audit: pull the "Orphan pages (have no incoming internal links)" report from the Internal pages section. Ahrefs often catches orphans Screaming Frog misses because of how Shopify renders collection tiles.

What to do with the orphan list:

-> If the orphan is a retired product: 301 redirect it to the parent collection, not to home. -> If the orphan is a live product with zero collections: add it to at least 2 relevant collections. Every product should live in at least one "best of" collection and one category collection. -> If the orphan is a blog post: add contextual links from at least 3 other blog posts and from any relevant collection descriptions. -> If the orphan is a policy page: add it to the footer if it belongs there, or deindex it if it does not.

Collection linking is the second leverage point. Shopify stores under-link their collections because the default theme only surfaces collections that are pinned to navigation. Look at your top 20 collections by revenue in GA4. Then count how many internal links point to each one using a crawl. Collections that drive 5 percent of revenue but have 2 internal links are losing easy rankings. Fix this with contextual links from blog content, from related collection descriptions, and from the footer for your most important categories.

Core Web Vitals

Core Web Vitals are a ranking factor and a conversion factor. Both matter.

The three metrics, the thresholds, and how to check them:

-> LCP (Largest Contentful Paint) under 2.5 seconds on mobile. -> CLS (Cumulative Layout Shift) under 0.1. -> INP (Interaction to Next Paint) under 200ms.

Pull field data from CrUX for every important template. Lab data (PageSpeed Insights score in isolation) is useful for diagnosis but meaningless for judgment. Use the "Origin Summary" and per-URL data from the CrUX API or the free CrUX Dashboard on Looker Studio.

What each metric usually means on a Shopify store:

-> Bad LCP on product pages: hero image not preloaded, theme is loading a carousel script before the first image, or the image itself is not in WebP. Preload, lazy-load the rest, convert. -> Bad CLS: webfonts causing FOIT, review stars injecting above the fold after page load, announcement bar pushing content down. Reserve space for every above-fold element. -> Bad INP: a reviews or chat widget JavaScript bundle is blocking the main thread during hydration. Defer everything below the fold.

For the specific fix order, see the Shopify speed optimization playbook. An audit finds the issue. The playbook fixes it.

One thing to note on INP specifically. It replaced FID as a Core Web Vital in March 2024, and most stores that passed CWV in 2023 are failing on INP now because FID was a much softer metric. If you have not revisited speed in 18 months, INP is almost certainly your weakest of the three. Audit it explicitly.

Schema audit

Structured data does not help a store rank higher in the classical sense, but it does three things that matter: it enables rich results (stars, price, availability) which improve click-through, it helps Google parse your templates correctly when copy is ambiguous, and it is increasingly what AI answer engines use to cite sources.

What to check per template:

-> Product pages: Product schema with name, image, description, brand, sku, gtin (if available), offers (with price, priceCurrency, availability, url), and aggregateRating or review if reviews are live. -> Collection pages: BreadcrumbList plus CollectionPage or ItemList. Shopify's default does not output ItemList, but you should add it. -> Blog posts: Article or BlogPosting with headline, image, datePublished, dateModified, author, and publisher. -> Home page: Organization plus WebSite with SearchAction. -> All pages: BreadcrumbList. -> FAQ blocks: FAQPage schema only if the Q&A is actually visible on the page. Do not ship invisible FAQ schema, Google ignores it since 2023 and it is a manual action risk.

Validate with the Schema Markup Validator (not the deprecated Structured Data Testing Tool) and the Rich Results Test. Every error is a lost rich result. Every warning is a future error.

Common Shopify schema failures:

-> Price in schema does not match price on page (a currency conversion app is showing USD on page and EUR in schema, or a sale app is updating the display price but not the schema). -> availability stuck at InStock even when out of stock. -> Multiple review schemas on one page (theme and reviews app both inject it). -> Missing priceValidUntil on sale items. -> Broken image URL (protocol-relative //cdn.shopify.com/... when Googlebot expects https://).

Reporting the findings

The audit is worthless if it does not end in action. Reporting is part of the work, not a postscript.

What a useful audit report looks like:

-> A one-page summary with the top 5 issues, their estimated traffic impact, and recommended owner. -> A spreadsheet with every issue, severity (Critical, High, Medium, Low), template affected, estimated effort (hours), and a link to the fix documentation. -> A before-metrics baseline: indexed pages, organic sessions (28 days), CWV pass rate by template, top 10 landing pages, top 10 lost queries. -> A written POV on which issues to fix this sprint, next sprint, and backlog.

Severity is the hard part. A broken canonical on a 10-visitor-per-month blog post is not a Critical. A broken canonical on the top-of-funnel collection that drives 14 percent of organic revenue is a Critical even if the error looks small. Context matters. Never call severity from the error, always call it from the business impact of the pages affected.

Every issue in the report should answer three questions: what is broken, why does it matter, how do we fix it. If any of those answers is missing, the issue is not ready to ship to engineering. A senior SEO does not hand off "your H1 is wrong on PDPs." A senior SEO hands off "your H1 on PDPs is being overridden by the reviews app on line 214 of snippets/reviews-header.liquid; remove the h1 class and move the title up one div; this affects all 1,200 products and impacts approximately 8 percent of organic revenue based on current GSC query data."

The tool stack

If you run all eight tools, you will spend roughly 90 minutes of active work plus whatever the Ahrefs crawl takes in the background. That is the budget. More time does not produce a better audit. It produces a longer report.

What to do this week

-> Run the Screaming Frog JS-rendered crawl against your full store and cross-reference orphan pages with GA4 revenue data. Fix the top 10 revenue orphans this week. -> Export GSC Page indexing, identify your three largest "Crawled - currently not indexed" buckets, and diagnose whether the cause is thin content, duplicate content, or a Shopify quirk. -> Pull CrUX field data for your product and collection templates. If either fails on INP or LCP, open a ticket with engineering this sprint. -> Validate schema on one URL per template with the Schema Markup Validator. Every error becomes a fix ticket. -> Pick the 5 highest-impact fixes from the audit and assign owners with deadlines. An unowned audit is a document, not a project.

If running this against your own store sounds like too much, we do it for clients as part of our technical SEO service or as a one-time free audit. We also handle the implementation side through Shopify development so the fixes actually ship.

FAQ

Q: How often should I run a technical SEO audit on my Shopify store? A: A full audit once a quarter, a lightweight audit (crawl plus GSC review) once a month, and a real-time issue monitor on Ahrefs or a similar tool always on. The monthly review catches app-install regressions, which are the single most common cause of sudden Shopify SEO failures.

Q: Can I skip Screaming Frog and just use Ahrefs or Semrush? A: No. Hosted crawlers are great for trending and automation but they miss things JavaScript-rendered crawls catch, and they do not let you configure user agent and render behavior at the level you need for Shopify's client-side hydration. Use both. They answer different questions.

Q: My GSC shows "Discovered - currently not indexed" for hundreds of product pages. Is this a Shopify bug? A: Almost never. It usually means Google has seen the URLs (through sitemap or internal links) but has decided the site's overall quality signal does not justify spending crawl budget to fetch them yet. The fix is site-wide: improve internal linking depth to those products, strengthen the collections they sit in, and add unique content to the product descriptions. Indexation follows quality.

Q: Does Core Web Vitals still matter in 2026 given AI search? A: Yes, and more than before. AI answer engines use page speed as a quality signal when choosing which source to cite, the same way traditional search does. A slow store is less likely to be cited by Perplexity or ChatGPT, and still ranks worse on Google. INP in particular is the current frontier issue for Shopify stores.

Q: The audit found 400 issues. Which ones do I fix first? A: Ignore the count. Sort by template-level issues first (fixing one template fixes thousands of URLs), then by traffic-weighted impact, then by effort. A template-level canonical bug on the product template is always a Critical. A missing alt tag on a footer logo is never a Critical, regardless of how many tools flag it.