Skip to content
Faisal Mahmud TusherDigital marketing, SEO & analytics
with Faisal Tusher

SEO › Technical SEO

How to Run a Technical SEO Audit

A repeatable technical SEO audit: gather crawl, Search Console and log data, run the checks in order, and turn findings into a prioritised backlog.
Tutorialintermediate7 min readUpdated

Before you start

  • Access: Search Console (GSC) 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.
  1. Gather the three views

    Run a full crawl, configured to render JavaScript if the site depends on it, respecting robots.txt, and starting from the homepage and the XML sitemap. 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.

  2. 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.

  3. Check indexability of the pages that matter

    For the priority list, confirm each page returns 200, is allowed by robots.txt, has no noindex in 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 404, 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.

  4. 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, pagination 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.

  5. 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 chains 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.

  6. Test rendering

    For each template, run the URL inspection live test and compare the rendered HTML 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.

  7. 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.

  8. 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.

  9. 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.

  10. 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.

Illustrative example — not a real result

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.

Terms used on this page

Tools to try

Frameworks

Where this page is used

Also related

Sources

  1. Page Indexing report — Google Search Console Help

Related