The Technical SEO Audit Checklist We Use on Every Client

Phase One: Crawl and Indexation — Can Google Find What Matters?

Every technical audit we run follows the same sequence, because the failure modes follow the same sequence. Google has to crawl a page before it can render it, render it before it can evaluate it, and evaluate it before it can rank it. Audit in that order and you find root causes; audit in a tool’s export order and you spend hours polishing pages Google can’t even see. The full checklist runs to 47 line items across eight phases, and the phases are how this article is organized.

Phase one starts with robots.txt, read line by line, looking for rules that block more than intended — a leftover staging rule, a blocked directory that happens to contain CSS or JavaScript the pages need. Then the XML sitemap, checked for accuracy rather than existence: it should contain only live, indexable, canonical URLs — a sitemap full of redirects and 404s is a map Google learns not to trust.

The core of this phase is a single comparison: the pages you want indexed versus the pages Google has actually indexed. Search Console’s indexing report gives you Google’s side; your sitemap and page inventory give you yours. The gaps in both directions are the findings. Important pages stuck in “Discovered — currently not indexed” or “Crawled — currently not indexed” mean Google found them and declined — usually a quality, duplication, or internal-linking problem rather than a switch to flip.

The reverse gap is just as common: junk that is indexed and shouldn’t be — internal search results, tag archives, parameter variants, staging subdomains, PDF duplicates. A site:yourdomain.com search plus the Search Console page report surfaces most of it. The fix is deliberate noindex and canonical hygiene — not deleting things in a panic, which creates a wave of 404s you’ll be cleaning up in phase seven.

Phase Two: Rendering — What Google Actually Sees

A page can be crawlable and still be invisible, because what’s in the HTML source and what shows up in a browser are often two different documents. Modern sites lean on JavaScript to inject content and build navigation. Google does render JavaScript, but rendering is a second pass — and anything that only exists after JS runs is at the mercy of that pass succeeding.

The check is simple and most audits skip it. Take your money pages — the templates that drive revenue, not the homepage — and compare three views: the raw HTML source, the rendered DOM in the browser, and what Search Console’s URL Inspection tool shows under “View crawled page.” If the main content, internal links, or meta tags only appear in the rendered version, you’ve found a dependency worth flagging; if the URL Inspection view is missing content users see, you’ve found a real problem.

The most damaging variant isn’t missing content — it’s missing links. If category navigation or related-product links are assembled client-side and something fails, Google’s picture of your internal linking collapses, and with it the architecture you’ll audit in phase three. The same goes for content hidden behind interactions Google won’t perform, like infinite scroll with no paginated fallback.

The fix isn’t “remove all JavaScript.” It’s making sure critical content and links are server-rendered or statically generated, and treating client-side rendering as enhancement rather than foundation. The audit output here is a short list: which templates are fine, which depend on JS for their primary content, and what each needs.

Phase Three: Architecture — Depth, Internal Links, and Orphan Pages

Site architecture is where technical SEO stops being about switches and starts being about structure. The question this phase answers: from the homepage, how does authority flow, and does it reach the pages that earn money?

First check is crawl depth. Run a crawler from the homepage and look at how many clicks it takes to reach your important pages. Pages buried four or five clicks deep get crawled less often and inherit less internal authority. When a service page or top product sits deeper than a tag archive, the hierarchy is upside down and it shows in rankings.

Second is internal link distribution. Crawlers report how many internal links point at each URL, and the pattern on most sites we audit is the same: the homepage and a few hubs soak up everything, while the pages targeting commercial keywords get two or three links each, all from navigation. Redistributing internal links from strong pages to pages that deserve to rank is consistently one of the highest-leverage fixes in the entire audit, and it costs nothing.

Third is orphans: pages that exist, and may even be indexed, but have no internal links pointing at them. You find them by comparing what the crawl discovered against what the sitemap contains and what Search Console says gets impressions — URLs in the latter two but not the first are orphans. Each one either deserves links or deserves a deliberate retirement.

While we’re in the crawl data we also check anchor text — internal links that all say “learn more” waste the clearest relevance signal you fully control — and navigation bloat, where a 200-link mega-menu flattens the site until the structure says nothing.

Phase Four: Page Experience — Core Web Vitals and the Mobile Reality

Core Web Vitals are three measurements of how a page feels to load. Largest Contentful Paint (LCP) is how long the main content takes to appear. Interaction to Next Paint (INP) is how quickly the page responds when someone taps or clicks. Cumulative Layout Shift (CLS) is how much the page jumps around while loading. Google’s thresholds are public — 2.5 seconds for LCP, 200 milliseconds for INP, 0.1 for CLS — and the data that counts is field data from real Chrome users, not the lab score from a single test run.

That distinction drives the audit. PageSpeed Insights shows both: field data at the top, when the site has enough traffic, and the lab diagnosis below. Field data tells you whether there’s a problem; lab data tells you why. Chasing a lab score of 100 on a site that already passes its field thresholds is effort spent where no ranking system is looking.

When there is a real problem, the causes are boringly consistent. Slow LCP: slow server response, render-blocking CSS and scripts, oversized hero images. Poor INP: heavy JavaScript, usually third-party — tag managers stuffed with years of forgotten pixels, chat widgets, session recorders. Bad CLS: images without dimensions, embeds that inject themselves, fonts swapping late.

The other half of this phase is the mobile reality check, done on an actual phone over a cellular connection, because Google indexes the mobile version of your site and so should your audit. We’re looking past the metrics at experience: tap targets, interstitials and cookie banners that bury the content, and content present on desktop but trimmed from the mobile template — because if it’s not on mobile, as far as indexing is concerned, it’s not on the site.

Phase Five: Duplication and Canonicals — One Page, One URL

Every page on your site should have exactly one URL, and every signal — links, relevance, history — should accumulate against that one URL. Most sites violate this in a half-dozen small ways that compound.

The hostname-level checks come first because they affect every URL at once. Pick one of www and non-www, one of trailing slash and no trailing slash, and confirm the rejected versions 301 to the chosen ones — actually redirect, not just canonical-tag their way out. Each unresolved variant silently splits your site in two.

Then parameters. Tracking codes, sort orders, filters, session IDs — each combination mints a new URL with the same content. The audit step is pulling every parameterized URL from the crawl and from Search Console and sorting them into three buckets: parameters that change content meaningfully (keep, canonical to self), parameters that reorder or track (canonical to the clean URL), and parameter spaces so large they’re eating crawl budget (block or rebuild) — faceted navigation on e-commerce sites being the extreme case.

The subtler finding is near-duplicate templates: location pages where only the city name changes, product variants with identical descriptions, service pages cloned and lightly reworded. Google folds near-duplicates together and picks its own canonical, frequently not the one you’d pick — “Duplicate, Google chose different canonical than user” is the literal Search Console label. The fix is differentiation or consolidation, and the audit’s job is to say which, page by page.

Finally, canonical tag hygiene: every indexable page carries a self-referencing canonical, canonicals point at live 200-status URLs rather than redirects, and nothing is both canonicalized away and noindexed at once — pick one signal and send it cleanly.

Phase Six: Structured Data — Validation First, Opportunity Second

Structured data gets audited in two passes: is what’s there correct, and what’s missing that should be there.

Validation comes first. Run the key templates through Google’s Rich Results Test and check Search Console’s enhancement reports for errors at scale. The common failures are predictable: markup describing things that aren’t visibly on the page, which violates Google’s guidelines and risks a manual action; required fields missing, so the markup validates as schema but qualifies for nothing; review markup with hardcoded ratings nobody has updated in years; and duplicate blocks, usually a plugin and a theme both injecting markup.

The opportunity pass is template-driven. Service businesses: LocalBusiness or the relevant subtype, with name, address, phone, and hours that exactly match the Google Business Profile. E-commerce: Product markup with price, availability, and reviews — this is what puts pricing and stars into your results. Publishers: Article with author and dates. FAQ markup where pages genuinely answer questions, with caveats since Google has tightened which sites get FAQ rich results. Breadcrumb markup nearly everywhere.

Two grounding rules keep this phase honest. First, structured data is not a direct ranking factor — it changes how your results look and what they’re eligible for, and helps machines disambiguate what your pages are about. Worth doing, but it won’t rescue weak pages. Second, mark up what’s true. The temptation to stretch — aggregate ratings from three reviews, FAQ markup wrapped around marketing copy — produces short-lived rich results and long-lived trust problems.

Phase Seven: Hygiene — Redirect Chains, 404s, Soft 404s, and HTTPS

This phase is housekeeping, and it’s where neglected sites bleed the most accumulated equity.

Redirect chains first. Every redirect should be a single hop: old URL, 301, final URL, done. What we actually find on sites that have been through a redesign or two are chains: HTTP to HTTPS to non-trailing-slash to the new template to the current URL. Four hops where one should be, each a chance for signals to degrade. The crawl exposes every chain; the fix is pointing each rule directly at the final destination, then updating internal links so they don’t hit redirects at all — those are self-inflicted, since you control both ends.

Then the error inventory. 404s themselves aren’t a problem — a 404 is the correct response for a page that’s gone with no replacement. The findings are the exceptions: 404s with internal links still pointing at them, 404s with external backlinks whose equity should be 301d to the closest relevant page, and 404 volume spiking after a migration, which means the redirect map missed.

Soft 404s deserve their own line because they hide. A soft 404 returns a 200 status with nothing on it — an empty category, a “no results found” page, an expired listing. Google flags these in Search Console, and they’re worse than honest 404s because they look like thin content at scale. Empty states should return a real 404 or be noindexed until they have content.

HTTPS rounds out the phase: valid certificate across subdomains, every HTTP variant redirecting in one hop, no mixed-content warnings, no internal links still written with http:// a decade after the migration. Boring, fast to check, embarrassing to fail.

Phase Eight: International and Local — Only If It Applies, but Strictly If It Does

This phase is conditional — a single-language, single-market site can skip it. But when a site serves multiple countries or languages — or competes for local results — the checks are strict, because the failure modes are silent. Nothing visibly breaks; you just rank with the wrong page in the wrong country.

Hreflang first, because almost every implementation we audit has at least one error. The non-negotiables: annotations must be reciprocal — if the Canadian page points at the Australian page, the Australian page must point back, or Google ignores both. Every page includes a self-referencing annotation. Codes must be valid ISO codes — en-GB, not en-UK. An x-default designates the fallback. And hreflang URLs must be the canonical, indexable versions — pointing hreflang at redirected or canonicalized-away URLs voids the whole cluster. For sites with near-identical English variants across Canada, the US, the UK, and Australia, hreflang is the only thing telling Google which page belongs to which market; when it breaks, the wrong country’s page ranks and conversion quietly suffers.

For businesses competing in local results, the technical layer is shorter but just as commonly fumbled. Name, address, and phone number consistent between the site, the markup, and the Google Business Profile. One genuinely distinct page per location — phase five’s lesson, not a city-name find-and-replace. And each location page actually linked from the navigation or a locations hub, not orphaned the way phase three keeps finding them.

What to Fix First, What to Ignore, and How to Run This Yourself

The audit isn’t the deliverable. A 60-page PDF of findings that never get implemented is the most common artifact in this industry. The deliverable is a prioritized fix list, and the prioritization is a simple impact-times-effort sort.

Top priority — high impact, low effort: indexation blockers on money pages, redirect chains, internal links pointing at redirects or 404s, link redistribution to striking-distance pages, canonical conflicts, soft 404s. Most of these ship in days. Second — high impact, high effort: rendering dependencies that need template work, faceted navigation rebuilds, Core Web Vitals failures rooted in the theme or tag manager, near-duplicate consolidation. These get scheduled as projects. Third — low impact, low effort: structured data gaps, image attributes, sitemap cleanup. Batch them into maintenance.

Then the fourth bucket, which saves the most money: low impact regardless of effort, also known as most of what your audit tool is screaming about. Meta descriptions flagged as too long, “low word count” warnings on pages doing their job fine, H1 warnings on pages that rank. Tools score exhaustively because exhaustive looks rigorous; rankings don’t care about most of it. The judgment to ignore three hundred warnings and fix the eleven findings that matter is the difference between an audit and an export.

You can run a credible version of this yourself with free tools. Google Search Console covers indexation, canonicals, Core Web Vitals field data, structured data errors, and hreflang. PageSpeed Insights handles the page experience diagnosis. A desktop crawler — Screaming Frog is free for the first 500 URLs — covers depth, internal links, redirect chains, duplicates, and orphans once you cross-reference against your sitemap. For a site under a few hundred pages, a focused afternoon gets you through most of the phases.

Where it’s worth bringing in help: large or faceted sites where crawl budget is a real constraint, JavaScript-heavy builds, post-migration recoveries, and any situation where the findings are clear but nobody internal can ship the fixes. That last one is the honest reason most audits get commissioned twice — the first one found the problems, and then nothing happened. If you’d rather the second audit be unnecessary, SearchPod runs this checklist with the implementation attached.