Running your first technical SEO audit
Crawl the site, reconcile it against what actually got indexed, fix in the order that matters, and verify each change instead of assuming.
Scope the audit and get a crawl you can trust
Decide the boundary before you start: which hostnames, which subdomains, whether country variants are in scope, and whether parameterized URLs count as separate pages. Then run a crawl that reaches everything a search engine could, which means starting from the homepage and also feeding in your sitemaps, your internal link data, and a URL list from your analytics, since a page nothing links to will never appear in a link-following crawl. Compare the counts. A crawl that finds four thousand URLs when the sitemap lists twelve thousand is itself the first finding. Respect your own rate limits so you do not take the site down, and crawl as a search engine user agent so you see what it sees rather than whatever your firewall serves to unknown clients. Save the raw crawl, because recrawling from scratch to answer one small question wastes a morning. Record the settings you used, including the user agent, the rate, and whether JavaScript was executed. Two crawls of the same site with different settings produce different findings, and without the settings written down you cannot tell a fix from a configuration change.
Reconcile the crawl against what is actually indexed
A crawl tells you what exists. Your search console tells you what the engine chose to keep. The gap between them is where the real problems live. Pull the index coverage report and line it up against your crawl, looking for three patterns: URLs you want indexed that are excluded, URLs indexed that you never intended to expose (parameter variants, print views, internal search results, paginated archives), and cases where the canonical the engine selected differs from the one you declared. That last one is the quiet killer, because the page looks healthy, returns 200, declares a canonical to itself, and the engine has still decided some other URL is the real one. Also check what share of your submitted sitemap URLs are indexed as a blunt ratio, since a low number across an entire template deserves more attention than a long list of individual page notices.
Fix indexability before anything else
Work the chain that decides whether a page can rank at all, in order: is it reachable by a link, does robots.txt allow it, does it return 200, does it carry a noindex, does its canonical point at itself, and is it in a sitemap. Anything failing here cannot be rescued by content work, so it comes first. Look for template-wide patterns rather than single pages: a noindex left behind after a staging deploy, a robots.txt disallow on a directory that later got real content, a canonical tag built from a variable that is empty on some page types, or a noindex on paginated pages that are the only path to half your catalogue. Check the live response headers as well as the HTML, since an X-Robots-Tag in the response can contradict the page and is easy to miss when you only read the source.
Collapse duplicates into one URL per thing
Most sites serve the same content at several addresses: with and without a trailing slash, with and without www, on both protocols, with tracking parameters attached, with filters applied in any order, and under more than one category path. Every variant splits signals and spends crawl budget. Pick one canonical form per rule and enforce it with a redirect where you can and a canonical tag where you cannot. Then handle the near-duplicates, which are harder: location pages generated from one template with the city swapped, product variants differing by a single attribute, thin tag archives holding one post each. For those the decision is consolidate, differentiate, or remove, and for a page with nothing unique on it the honest answer is usually remove. Scan for identical title tags and identical opening paragraphs across the site, since both find the clusters worth examining fast. Before removing anything, check whether it earns traffic or links. A thin page with twenty referring domains should be merged into a stronger URL with a redirect rather than deleted, and the difference between those two choices is one query against your analytics.
Clean up redirects and internal links
Redirects accumulate silently across migrations. Find the chains where one URL hops twice or more before resolving and point the first hop straight at the final destination, since each extra hop costs a little and slows the page. Find the loops, which are outright breakage. Then fix the internal links: every link in your own templates and content should point at the final URL rather than at something that redirects, because you control those links and leaving them stale means every crawl rediscovers the same chains. Look for redirects landing on something irrelevant, which is what happens when a batch of dead URLs gets swept to the homepage, and prefer a clean 404 or a redirect to the nearest real equivalent. Check orphan pages at the same time: a page with no internal links pointing at it is telling you either that it needs one or that nobody values it.
Audit what renders, not what ships
Compare the raw HTML your server returns against the DOM after JavaScript runs, for one page of every template. Anything existing only in the rendered version is at risk, because rendering is deferred and never guaranteed. The things that go missing are usually the things that matter: canonical tags injected client-side, main content loaded by a fetch after mount, internal links rendered as click handlers with no href, and pagination that only works through a button. Check what happens when no consent has been given as well, since a consent wall that blocks content for unknown visitors blocks it for crawlers too. The test is simple: disable JavaScript, load the page, and read what is there. If the primary content and the primary links are absent, that is your headline finding, and it outranks every missing meta description in the report.
Treat speed as a field measurement
Lab tools run one page on a simulated connection and hand you a score. Field data reports what real users on real devices experienced, and only the second one reflects how your pages are judged. Start from the field data in your search console, grouped by template, and find the template that fails rather than the single page. Then use a lab run on one example of that template to locate the cause. The usual culprits are specific and findable: an uncompressed hero image, a font that blocks first paint, a third-party tag loaded synchronously in the head, a layout that jumps when a banner inserts itself, and a main thread blocked by scripts during interaction. Fix the template once and every page it serves improves. Resist chasing a lab score on your homepage, frequently the least representative page you own and the one your users visit least.
Fix in batches, verify each one, keep the log
Order the work by whether it blocks indexing, how much traffic sits behind it, and how cheap it is to ship, then take the whole top batch rather than the single top item. Group fixes by template so one deploy covers hundreds of URLs. After each deploy, recrawl just the affected URLs and confirm the issue is gone in the response, not in your intention. Then look for second-order breakage, because a canonical change can deindex a page, a redirect rule can catch URLs you never meant to include, and a performance fix that lazy-loads content can hide it from rendering entirely. Keep a dated log of what changed and which URLs it touched. Six weeks later, when traffic moves, that log is the only thing that lets you connect the movement to a cause, and without it you will be guessing at precisely the moment it matters most. Set a date two weeks out to recheck the index status of everything the batch touched, because deindexing shows up slowly and the deploy that caused it will already be out of mind. Then start the next batch rather than a second pass on this one.