Illustration of an SEO audit checklist with a magnifying glass over a site structure diagram

Most technical SEO audits start the same way: someone runs a crawler, exports a spreadsheet with hundreds of warnings, and sends it over. The problem is that a long list of warnings is not the same as an audit. Some of those warnings matter a lot. Many barely matter at all.

A useful audit answers a simpler question: is anything stopping search engines from finding, understanding and showing your most important pages? This guide walks through what a good audit should check, in roughly the order it makes sense to look.

Start with the pages that matter

Before touching any tool, write down the pages that actually bring in business. For most sites that means the home page, service or product pages, key category pages and a handful of articles that already get traffic or leads.

This list keeps the audit focused. A broken link on an old tag archive is not the same priority as a service page that has quietly dropped out of the index. Every finding should be judged by how much it affects these pages.

Crawlability: can search engines reach your pages?

If a crawler cannot reach a page, nothing else about that page matters. Check these first:

  • robots.txt: make sure it is not blocking important folders, CSS or JavaScript files. A single leftover rule from a staging site can block a whole section.
  • Server responses: important pages should return a 200 status. Look for unexpected 404s, 5xx errors and soft 404s (pages that say "not found" but return 200).
  • Redirects: look for redirect chains (A to B to C) and loops. Each link should point straight to the final URL where possible.
  • JavaScript rendering: if content or links only appear after JavaScript runs, check that they are visible in the rendered HTML. Google's URL Inspection tool in Search Console shows what Google actually sees.
  • Orphan pages: pages with no internal links pointing to them are hard to discover. Compare your sitemap and analytics against what a crawler can find by following links.

Indexing: are the right pages in, and the wrong ones out?

Being crawlable does not mean a page gets indexed. The Pages report in Google Search Console is the best place to start, because it tells you which URLs Google has chosen not to index and why.

Things to look for:

  • Stray noindex tags: a noindex left on a live page is one of the most common and most damaging mistakes, especially after a redesign or migration.
  • "Crawled, currently not indexed" and "Discovered, currently not indexed": a large number of these can point to thin pages, duplicate content or weak internal linking.
  • Index bloat: search results pages, filter combinations, tag pages and parameter URLs can create thousands of low-value pages. These usually should be kept out of the index.
  • XML sitemaps: the sitemap should list only canonical, indexable URLs that return 200. If it is full of redirects or noindexed pages, it sends mixed signals.

Canonicals and duplicate content

Duplicate content is rarely a penalty issue. It is a clarity issue. When several URLs show the same content, search engines have to guess which one to rank, and they do not always guess the way you would like.

Check that:

  • Every indexable page has a self-referencing canonical tag, or a canonical pointing to the preferred version.
  • Canonicals point to URLs that return 200 and are not redirected or noindexed.
  • HTTP and HTTPS, www and non-www, and trailing slash versions all resolve to one preferred format.
  • URL parameters for tracking, sorting or filtering do not create indexable duplicates.

Keep in mind that a canonical tag is a hint, not a command. If your internal links, sitemap and canonicals all point to different versions, the hint gets ignored.

Core Web Vitals and page experience

Core Web Vitals are Google's measures of loading, responsiveness and visual stability. Google's published "good" thresholds are:

  • Largest Contentful Paint (LCP): 2.5 seconds or less.
  • Interaction to Next Paint (INP): 200 milliseconds or less.
  • Cumulative Layout Shift (CLS): 0.1 or less.

Use field data where you can (the Core Web Vitals report in Search Console, or PageSpeed Insights when it has real user data), because lab scores from a single test can be misleading. Look at templates rather than individual URLs. If the product page template is slow, every product page is slow.

Common causes worth checking include oversized hero images, render-blocking scripts, heavy third-party tags, web fonts that shift text as they load, and images or ads without set dimensions.

Also confirm the basics of page experience: the site works properly on mobile, uses HTTPS everywhere, and does not hide content behind intrusive pop-ups.

Structured data

Structured data (usually JSON-LD using schema.org types) helps search engines understand what a page is about. It can also make pages eligible for rich results, though it never guarantees them.

In an audit, check:

  • Which types are in use (Organization, LocalBusiness, Article, Product, BreadcrumbList, FAQPage and so on) and whether they fit the page.
  • That the markup validates in Google's Rich Results Test and the Schema Markup Validator.
  • That the marked-up information matches what is visible on the page. Markup that describes content users cannot see is against Google's guidelines.
  • That details like business name, phone number and logo are consistent across the site.

Internal linking and site structure

Internal links are how both users and search engines find their way around. They also signal which pages you consider most important.

  • Click depth: key pages should be reachable within a few clicks of the home page.
  • Anchor text: links should describe the destination. "Web design services" tells a search engine much more than "click here".
  • Broken internal links: fix these, or point them to the correct page.
  • Links to redirects: update internal links so they point to the final URL.
  • Navigation and breadcrumbs: make sure they are plain, crawlable HTML links.

A common finding is that the pages a business cares about most get very few internal links, while old blog posts get many. Rebalancing this is often one of the cheapest improvements available.

On-page technical basics

These are not glamorous, but they add up across a whole site:

  • Unique, descriptive title tags and meta descriptions on important pages.
  • One clear main heading per page and a logical heading structure.
  • Descriptive alt text on meaningful images.
  • Correct hreflang tags if the site serves several languages or regions.
  • Clean, readable URLs that do not change without a redirect.

Turning findings into fixes

An audit is only useful if it leads to changes. For each issue, note three things: how many important pages it affects, how serious the impact is likely to be, and how much effort the fix takes.

Then sort the list. Problems that block crawling or indexing of key pages come first. Template-level fixes that help many pages at once come next. Cosmetic warnings come last, or get dropped.

Finally, write the fixes so a developer can act on them. "Fix canonicals" is vague. "Product pages with a ?colour= parameter should canonicalise to the parameter-free URL" is something a developer can build and test.

How often to audit

A full audit makes sense before and after any redesign, migration or platform change, since that is when most serious technical problems appear. Between those, a light monthly check of Search Console (indexing, Core Web Vitals and any manual actions or security issues) catches most surprises early.

Closing thoughts

A technical SEO audit does not need to be complicated. Focus on whether your most important pages can be crawled, indexed, understood and loaded quickly, then fix the issues that affect them most. If you would like a second pair of eyes on your site, OzTechVerse is happy to help.