Technical SEO

Technical SEO covers everything between your server and the index: how URLs are discovered, fetched, rendered, deduplicated and stored. Its scope includes robots.txt and crawl management, XML sitemaps, canonical tags and redirect logic, server rendering, HTTPS and host consolidation, mobile viewport configuration, structured data, pagination, and the performance budget that determines how much of your site a crawler bothers to fetch.

The unifying idea is eligibility. None of these signals tell Google your page is good; they tell Google your page exists, is unique, and is safe to send users to. This is why technical SEO produces step changes rather than gradual curves — a page either is or is not in the index — and why the discipline rewards precision over effort.

Googlebot discovers URLs from links and sitemaps, schedules fetches according to your crawl budget — a function of server speed and how often pages change and matter — and fetches raw HTML first. Pages that depend on JavaScript for their content enter a rendering queue that can lag the initial crawl by days or weeks, and content that still fails to appear after rendering is treated as absent.

Indexing is a separate decision from crawling. A fetched page can be excluded for duplication, for a noindex directive, for thin content, or simply because Google's models judge it adds nothing to the index — the 'Crawled, currently not indexed' verdict that frustrates site owners and almost always means the page needs more substance, not more markup.

The practical checks: every canonical URL returns 200 in one hop; the raw HTML contains the primary text; robots.txt disallows only what should never be crawled; and the sitemap lists exactly the URLs you want indexed — no redirects, no noindexed pages, no parameter duplicates.

Because they are the mechanism by which a site tells Google which of several identical URLs is real, and the mechanism is easy to get subtly wrong. A relative canonical, a canonical assembled from two absolute URLs, a canonical pointing at a redirected URL, or www and apex hosts both serving 200 — each produces a site where Google chooses the canonical itself, and it frequently chooses differently from you.

The fix is mechanical and absolute. Pick one host and one protocol. 301-redirect every variant to it in a single hop. Emit exactly one canonical per page, absolute, self-referencing, built from a single base constant. Then enforce trailing-slash consistency, because /page and /page/ are different URLs to a crawler even when your framework treats them as one.

Verify with Search Console's URL Inspection: the 'Google-selected canonical' line should match the URL you declared on every important page. When it does not, Google is telling you it found conflicting signals somewhere — find them rather than re-submitting.

Less than its reputation, more than its critics claim. Core Web Vitals — loading (LCP), responsiveness (INP) and visual stability (CLS) — are confirmed ranking signals, but they operate at the margin between otherwise comparable pages. A slow page with the best answer still outranks a fast page with a mediocre one; between two good answers, the faster and more stable page wins.

Where speed genuinely decides outcomes is crawling and conversion. Slow servers shrink crawl budgets on large sites, and slow pages lose visitors before any persuasion happens. Aim for passing thresholds — LCP under 2.5 seconds, INP under 200 milliseconds, CLS under 0.1 — rather than perfect scores, and spend the effort saved on content.

In order of how frequently they appear in real audits: indexation leakage (noindex left from staging, disallowed sections, sitemap drift), canonical confusion (wrong or missing canonicals, unresolved host variants), rendering dependence (primary content only after hydration), redirect chains and loops, and orphaned sections with no internal links.

The pattern is that all five are configuration failures, not content failures — introduced by deployments and invisible until someone looks. The durable defence is a small set of automated checks run after every release: fetch the canonical URL of each template type, assert the status code, the canonical value, the presence of the H1 in raw HTML, and the absence of noindex. Ten assertions catch nearly everything this category can do to you.