Before you start
- Access: Search Console (GSCGoogle's search performance and indexing tool.) for the property, a site crawler (a desktop or cloud crawler that fetches every page and records status, directives, links and page elements), analytics, and ideally a week or more of server logs. The log file analysis tutorial shows how to obtain those logs, isolate crawler requests and label them by template before the audit uses them.
- A list of the pages that matter: the pages that should rank, from the keyword map or from revenue and traffic data. The audit judges problems by their effect on these pages, not by raw counts.
- A baseline: current indexed-page counts, organic traffic by section, Core Web Vitals status, the number of URLs in each Search Console indexing category. The next audit compares against it.
- Scope: the whole site, or a section. Large sites are audited by template and section; auditing a million URLs as one list produces a list, not findings.
Gather the three views
Run a full crawl, configured to render JavaScript if the site depends on it, respecting robots.txtA file at a site's root telling crawlers which URLs they may and may not fetch., and starting from the homepage and the XML sitemapA file listing the URLs a site wants search engines to discover and crawl.. Export Search Console's page indexing report (every category with example URLs), the performance report by page, the Core Web Vitals report and the crawl stats. Pull server logs filtered to search-engine crawlers. Three lists now exist — URLs the crawler found, URLs Google knows about, URLs Googlebot actually requested — and most findings come from where they disagree. The settings behind that crawl, from its start points and agreed speed to rendering, parameters and the fields it extracts, are set out in the tutorial on configuring a site crawl.
Reconcile the lists
Compare the crawl with the sitemap and with Search Console. Pages in the sitemap but not in the crawl are orphans (nothing links to them). Pages in the crawl but not in the sitemap are either missing from the sitemap or should not exist. Pages Google indexed that the crawl did not find are usually parameter or legacy URLs reachable from outside. Pages Googlebot requests often in the logs that are not important are crawl waste. Record each discrepancy class with counts and examples; this step alone reveals most structural problems.
Check indexability of the pages that matter
For the priority list, confirm each page returns
200, is allowed by robots.txt, has nonoindexin HTML or headers, carries a self-referencing canonical, and appears in Search Console as indexed with Google's selected canonical equal to the declared one. Then look at the Search Console categories for the rest: "Excluded by noindex", "Blocked by robots.txt", "Duplicate, Google chose different canonical", "Crawled — currently not indexed", "Discovered — currently not indexed", "Soft 404", "Redirect error". Each category is a finding type with a known cause, covered in the crawling and indexing guide. A soft 404A page that returns a success status code but shows an error, empty or not-found message., for instance, is a page that returns a success code while showing an error or empty result. Anything that blocks an important page is a priority-one finding.Find duplication and canonical conflicts
From the crawl, group URLs by identical or near-identical titles, headings and content hashes. Common sources: trailing-slash and case variants, HTTP/HTTPS and www variants, tracking and sort parameters, paginationSplitting a long list of items, such as products or articles, across a series of numbered pages. and filter combinations, printer and AMP versions, staging URLs. For each group, check which URL is linked internally, which is in the sitemap, which is canonical and which Google selected. Conflicts — internal links pointing to a variant that canonicalises elsewhere, sitemaps listing non-canonicals, canonicals pointing to redirects — are findings. On e-commerce sites this step usually leads straight into faceted navigation.
Assess architecture and internal links
From the crawl's link graph: the click-depth distribution, the inlink count for every priority page, pages with zero or one inlink, pages with hundreds of outlinks, and redirect chainsA permanent server redirect telling browsers and search engines a URL has moved for good. and broken internal links. Priority pages deeper than three clicks or with fewer than a handful of inlinks are findings; so are navigation menus that link to everything and sections unreachable except through pagination. The site architecture guide gives the targets; the internal linking guide gives the page-level fixes.
Test rendering
For each template, run the URL inspection live test and compare the rendered HTMLThe step in which a search engine runs a page's HTML, CSS and JavaScript to build the content a browser would display before indexing it. with the expected content: headline, body, internal links, title, canonical, structured data. List resources Googlebot could not load. Load the template with JavaScript disabled to see what survives. Compare crawl results with and without rendering for link and content counts. Any priority content or link that exists only after client-side execution is a finding, graded by how much traffic the template carries; the JavaScript SEO guide explains the fixes.
Review page experience by template
Read the Core Web Vitals report grouped by URL pattern; for each failing template, reproduce in the lab on a throttled mobile profile and identify the element or script responsible. Record the metric, the template, the share of traffic affected and the cause. Check mobile usability basics on the same templates: viewport set, text readable, tap targets usable, no content wider than the screen. The Core Web Vitals guide covers diagnosis and fixes.
Validate structured data and head elements
From the crawl: missing, duplicate or over-long titles and descriptions by template; multiple H1s; missing canonicals; hreflang errors where the site is international; structured data presence and type by template. Validate one URL per template in the Rich Results Test and read Search Console's enhancement reports for errors across the site. Markup that describes content not visible on the page is a policy finding, not a technical one, and is graded as urgent because of the site-wide consequence. The structured data guide lists the rules.
Look for migration leftovers and hygiene
Redirect chains and loops, internal links to redirecting URLs, old sitemaps still submitted, HTTP resources on HTTPS pages, legacy parameters, staging references, broken images, oversized pages, and robots.txt rules nobody can explain. Each is small; together they describe how well the site is maintained, and several of them (chains, mixed content) have direct effects.
Score and write the backlog
For each finding: the pages affected (count and which), the business value of those pages (traffic, revenue or strategic priority), the expected effect of fixing it, and the effort. A simple score — pages affected multiplied by value, divided by effort — orders the list. Write each finding as a developer-ready ticket: what is wrong, where (example URLs), what correct looks like, how to verify the fix, and why it matters. Group template-level fixes together; one ticket that fixes a template outranks a hundred page-level ones. Finish with the three findings you would fix first and the date of the next audit.
Verify the result
A complete audit has: reconciled URL lists with discrepancy counts; indexability status for every priority page; duplicate groups with their canonical conflicts; the depth and inlink profile of priority pages; rendering results per template; page-experience status per template; markup validation per template; a hygiene list; and a scored backlog of tickets with example URLs and verification steps. Someone who was not involved could pick up the first ticket and fix it.
An audit's top three findings on a mid-sized retailer
First: category pages reachable at four URL variants with Google selecting the parameter version for a third of them — a redirect and canonical fix at the template level, affecting every category. Second: the product template renders its specification table client-side from an API on a subdomain disallowed in robots.txt, so specifications are absent from the index — allow the path, move the table to server rendering. Third: product images lazy-loaded including the first one, failing LCP on mobile for the whole template — eager-load the first image with a preload hint. Each ticket names example URLs, the correct behaviour and the Search Console report where the fix will be confirmed.
Troubleshooting
- The crawl is too large to finish. Crawl by section or template; sample parameter spaces rather than exhausting them; use the logs to find what Googlebot actually fetches.
- Search Console counts do not match the crawl. Expected; the discrepancies are the findings.
- Everything looks like a problem. Return to the priority page list; findings that do not touch important pages or templates are hygiene, not priorities.
- Developers reject the tickets. Each ticket needs a reproducible example, a definition of correct and a verification step; findings without those are opinions.
- Fixes do not show in Search Console. Recrawling takes time; use URL inspection to confirm the page behaviour, then wait for the reports.
Next steps
Pair the technical audit with the on-page review in keyword cannibalisation and the measurement set-up in the Search Console tutorial. The SEO page checker reads the head and directive basics of any single URL for quick spot checks between audits. The author's SEO audit expertise page shows an interactive audit simulation built on the same sequence.
To keep the same findings out of the next template, writing SEO requirements for developers turns them into acceptance criteria that are tested before a feature is built.
