Technical SEO Audit Checklist: A Complete Step-by-Step Process

A technical SEO audit is a controlled diagnosis of how search engines discover, crawl, render, canonicalize and index a website. The output should not be a 200-row issue dump. It should be a prioritized implementation plan that separates critical blockers from improvements that can wait.

This checklist is designed for marketing sites, ecommerce platforms and custom applications. If you need a service-level review rather than a DIY process, see our SEO audit and technical SEO pages.

1. Establish a baseline before you crawl

Record the current state before changing anything. Capture:

• Google Search Console clicks, impressions, indexed-page trends and top landing pages;
• analytics sessions, conversions and revenue/lead data;
• current XML sitemaps;
• robots.txt;
• canonical host and protocol;
• known migrations, redesigns or CMS releases;
• top organic landing pages and their backlinks.

This baseline gives you something to compare against after fixes are deployed.

2. Crawl the site like a search engine

Run a full crawl of all discoverable HTML URLs. Export status codes, canonicals, titles, meta descriptions, headings, indexability, internal links, depth, images and structured data.

Do not treat the crawl as the truth. A crawler shows what it could discover from its starting points and configuration. Compare it with XML sitemaps, Search Console, server logs and analytics to find URLs that exist outside the crawl graph.

3. Check crawlability and indexability separately

These are different questions:

• Crawlability: can the crawler request the URL and access the resources required to understand it?
• Indexability: is the URL eligible to be indexed once crawled?

Review robots.txt, robots meta tags, X-Robots-Tag headers, authentication, HTTP status codes and canonical directives. Remember that robots.txt is not a reliable mechanism for removing a URL from Google’s index; a crawlable noindex or access restriction is the appropriate control for that use case.

4. Audit XML sitemaps

A sitemap should contain the canonical URLs you actually want search engines to discover and index.

Check for:

• non-200 URLs;
• redirecting URLs;
• noindex URLs;
• non-canonical duplicates;
• staging or utility pages;
• missing priority pages;
• incorrect or meaningless lastmod values.

Google describes sitemaps as a discovery signal, not an indexing guarantee. Keep the file accurate and automate it where the CMS can do so reliably.

5. Validate canonicalization

For each important page, identify the preferred canonical URL and verify that other signals agree with it:

• rel="canonical" points to the intended URL;
• internal links use the preferred URL;
• the sitemap contains the preferred URL;
• HTTP/HTTPS and www/non-www variants resolve consistently;
• parameters do not create uncontrolled duplicate clusters.

Google may choose a different canonical when signals conflict, so canonical tags should not be used to hide architecture problems.

6. Audit HTTP status codes and redirects

Prioritize:

• 4xx URLs linked internally;
• 5xx errors and intermittent server failures;
• redirect chains and loops;
• temporary redirects used for permanent moves;
• old URLs that should map to relevant replacements;
• soft 404 pages returning 200.

For permanent URL moves, server-side 301 or 308 redirects are the preferred solution. Redirect directly to the final destination instead of creating unnecessary chains.

7. Test JavaScript rendering

If important content, navigation or metadata depends on JavaScript, compare the initial HTML with the rendered page.

Use Search Console URL Inspection or Google’s testing tools to verify that:

• main content appears in rendered HTML;
• internal links are normal <a href> links;
• canonical and robots directives are consistent;
• error states return meaningful HTTP status codes;
• content is not dependent on user interaction such as scrolling or clicking before it exists.

Google can render JavaScript, but server-side rendering or pre-rendering can reduce crawling complexity and helps other crawlers that may not execute JavaScript.

8. Map architecture and internal links

Every page you care about should be reachable through crawlable internal links. Look for orphan pages, excessive click depth, repetitive anchors, dead-end pages and important commercial URLs that receive little internal authority.

A useful site architecture generally connects:

pillar page → supporting guides → implementation articles → related case studies → conversion page.

For migrations and complex builds, see our SEO migrations and custom CMS SEO resources.

9. Review Core Web Vitals and performance

Separate field data from lab diagnostics. Field data reflects real user experience where enough data is available; lab tools help diagnose what is causing a problem.

Prioritize issues that affect both users and rendering efficiency: oversized media, blocking scripts, unstable layouts, slow server response and unnecessary third-party code.

10. Verify mobile and HTTPS consistency

Check that the mobile experience exposes the same essential content and internal links as desktop. Verify HTTPS across all canonical URLs, remove mixed-content dependencies and ensure HTTP variants redirect consistently to the HTTPS canonical host.

11. Validate structured data

Structured data should describe content users can actually see. Run representative templates through Google’s Rich Results Test and check Search Console enhancement reports where applicable.

Prioritize schema types that reflect the real page purpose—such as Article, Breadcrumb, Organization, LocalBusiness or Product—rather than adding markup simply because it exists in Schema.org.

12. Audit titles, descriptions and headings at scale

Export duplicate, missing and unusually long titles/descriptions. Check that the title and H1 describe the same page intent without being mechanically identical across the site.

Look for template bugs that create:

• multiple H1s;
• no H1;
• blank metadata;
• duplicate titles across thousands of URLs;
• titles dominated by boilerplate rather than the page subject.

13. Audit images and media

Check image URLs, file sizes, dimensions, alt text and whether lazy loading depends on user interaction. Large images can be optimized and served in modern formats, but keep the original visual quality appropriate to the page.

For image-heavy pages, make sure important images are accessible through normal src attributes or a crawlable lazy-loading implementation.

14. Compare crawl data with server logs and Search Console

A crawl tells you what can be reached; logs tell you what bots actually requested. Search Console tells you how Google reports indexing and performance.

Use all three to find:

• valuable URLs Google rarely revisits;
• crawl waste on parameters or duplicates;
• unexpected 404/5xx requests;
• old URLs still being crawled after a migration;
• sections that are discovered but not indexed.

15. Turn findings into an implementation backlog

Do not prioritize by the number of errors. Prioritize by impact, confidence and implementation effort.

For every ticket, record the affected templates/URLs, expected result, QA method and owner. Re-crawl after release and compare against the baseline established in step one.

Technical SEO audit deliverables

A useful audit should leave the team with:

• a crawl and indexability map;
• prioritized issue backlog;
• redirect/canonical recommendations;
• internal linking opportunities;
• template-level implementation requirements;
• before/after measurement plan;
• a post-deployment validation checklist.

If you want a senior team to run the audit and translate it into implementation work, see Allinclusive. SEO Audits.

Sources and further reading

• Google: how Search works
• Google: SEO guide for web developers
• Google: canonicalization
• Google: JavaScript SEO basics
• Google: structured data guidelines