The Technical SEO Checklist for 2026: Everything Your Site Needs to Rank

Every time a site loses rankings after a Google update, the owner blames the algorithm. Nine times out of ten, the real cause is a technical issue that’s been quietly festering for months: a noindex tag nobody noticed, a redirect chain that diluted link equity, or a Core Web Vitals score that crossed the threshold from “fine” to “failing.”

Technical SEO isn’t complicated. It’s just thorough. This checklist covers every element that affects how search engines crawl, render, index, and rank your site. Each item includes what to check, what the correct state looks like, and what breaks when it’s wrong.

Use this as a living reference. Run through it quarterly, after every major site change, and whenever traffic does something unexpected.

Crawl Directives

These control whether search engines can access your pages at all. Get these wrong and nothing else on this list matters.

Robots.txt

Check: Fetch yourdomain.com/robots.txt directly. Read every line.
Correct state: No Disallow rules blocking important content directories. A Sitemap directive pointing to your XML sitemap. No leftover staging rules.
Common mistake: Blocking /wp-admin/ is fine. Blocking /wp-includes/ can prevent Googlebot from rendering your pages because CSS and JS resources live there. Blocking /blog or /products nukes entire sections from the index.
Test: Use Google’s robots.txt tester in Search Console, or Search Console’s URL Inspection tool to verify specific URLs aren’t blocked.

Meta Robots Tags

Check: Crawl your site with Screaming Frog and filter the Directives tab for noindex, nofollow, and none values.
Correct state: Only pages you deliberately want excluded from search should have noindex: thank-you pages, internal search results, login pages, staging pages. Every page you want to rank should have either index, follow or no meta robots tag at all (index/follow is the default).
Common mistake: CMS plugins or deployment scripts that apply noindex globally. WordPress migration from staging to production is a classic. The “Discourage search engines from indexing this site” checkbox stays checked.

X-Robots-Tag HTTP Headers

Check: In Chrome DevTools, Network tab, inspect response headers for key pages. Look for X-Robots-Tag.
Correct state: No X-Robots-Tag: noindex headers on pages you want indexed. These are invisible in the HTML source, which is why they’re easy to miss.
Common mistake: CDN or server configurations that apply X-Robots-Tag headers globally across certain URL patterns without anyone realising.

URL Structure

Clean, Descriptive URLs

Check: Review your URL patterns across all page types (blog, product, category, service).
Correct state: URLs should be lowercase, hyphen-separated, descriptive, and as short as practical. /services/technical-seo/ is good. /page.php?id=482&cat=seo&ref=nav is not.
Common mistake: CMS-generated URLs that include dates, categories, and parameters by default. Changing URL structure retroactively requires redirects, so get this right from the start.

Trailing Slash Consistency

Check: Test the same URL with and without a trailing slash. Do both return 200? Does one redirect to the other?
Correct state: Pick one format (trailing slash or not) and enforce it site-wide. The other version should 301 redirect to the canonical format. Both versions returning 200 creates duplicate content.
Common mistake: Inconsistent trailing slash handling between static pages and CMS pages on the same site.

URL Parameters

Check: Identify all URLs with query parameters (sort, filter, pagination, tracking). Are these being crawled and indexed?
Correct state: Parameter URLs that don’t create unique content should be handled with canonical tags pointing to the base URL, or blocked from indexation. Tracking parameters (UTMs) should never create indexable URLs.
Common mistake: Faceted navigation generating thousands of parameter combinations, each treated as a unique URL by Googlebot. A site with 500 products and 8 filter options can generate tens of thousands of crawlable URLs that dilute ranking signals.

Canonicalisation

Self-Referencing Canonicals

Check: Every indexable page should have a <link rel="canonical"> tag in the <head>. The value should be the page’s own URL.
Correct state: Canonical URL matches the page URL exactly: same protocol, same domain format (www or non-www), same trailing slash convention.
Common mistake: Canonicals pointing to HTTP when the site is on HTTPS. Canonicals missing the trailing slash when the page has one. Canonicals pointing to staging domain URLs.

Cross-Domain and Cross-Page Canonicals

Check: Identify any canonical tags pointing to a different URL than the current page.
Correct state: Only used intentionally, for syndicated content, print-friendly versions, or AMP pages that should credit the original. Every cross-page canonical should have a documented reason.
Common mistake: CMS pagination generating canonical tags that point every paginated page back to page 1. This tells Google to ignore pages 2, 3, 4, etc. entirely.

WWW vs. Non-WWW

Check: Load your site with www. and without. Do both resolve? Does one redirect to the other?
Correct state: One format is canonical. All other versions (http://www, http://non-www, https://www, https://non-www) 301 redirect to the single canonical version.
Common mistake: Both versions serving content without redirects, splitting your ranking signals across two domains.

Redirects

Redirect Status Codes

Check: Crawl your site and review all redirects. Are they 301 (permanent) or 302 (temporary)?
Correct state: Permanent URL changes should use 301 redirects. 302s tell search engines the original URL might come back, so they don’t transfer full link equity.
Common mistake: CMS platforms defaulting to 302 redirects. Shopify did this for years. If your redirects are 302s and they’re meant to be permanent, you’re leaking PageRank.

Redirect Chains

Check: In Screaming Frog, filter for redirect chains (any redirect that passes through more than one URL before reaching the final destination).
Correct state: Every redirect should point directly to the final URL. No A to B to C chains.
Common mistake: Migrations layered on top of previous migrations. Site moved in 2021 (old URL to mid URL), redesigned in 2024 (mid URL to new URL), now old URL redirects through two hops. With every migration, the chains get longer. If you’re planning a migration, map your redirects before you launch - cleaning up chains after the fact costs ten times the effort.

Redirect Loops

Check: Screaming Frog flags these automatically. URL A redirects to URL B, which redirects back to URL A.
Correct state: Zero redirect loops. They’re always a bug, never intentional.
Common mistake: Conflicting redirect rules in .htaccess or server config. Rule 1 says redirect A to B. Rule 2 says redirect B to A.

Soft 404s

Check: Search Console > Pages report, look for “Soft 404” entries. Also check for pages that return a 200 status code but display “page not found” content.
Correct state: Missing pages should return a proper 404 (or 410) status code. Serving a “not found” message with a 200 status wastes crawl budget and confuses indexation.
Common mistake: Custom 404 page templates that don’t set the correct HTTP status code in the response header.

Core Web Vitals

Largest Contentful Paint (LCP)

Check: PageSpeed Insights for field data. Lighthouse for lab diagnostics. Target: under 2.5 seconds on mobile.
Correct state: The largest element in the viewport (usually hero image or heading text) renders within 2.5s.
Fix priorities: Optimise images (format, compression, responsive sizing, preload the LCP image), eliminate render-blocking resources, improve server response time (TTFB under 800ms), implement a CDN for global audiences.

Interaction to Next Paint (INP)

Check: PageSpeed Insights field data. Chrome DevTools Performance panel for diagnostics. Target: under 200ms.
Correct state: The page responds to clicks, taps, and key presses within 200ms.
Fix priorities: Reduce main thread JavaScript work, break up long tasks (anything over 50ms), defer third-party scripts, reduce DOM size (under 1,400 elements is ideal).

Cumulative Layout Shift (CLS)

Check: PageSpeed Insights field data. Layout Shift regions visible in DevTools Performance panel. Target: under 0.1.
Correct state: No visible layout shifts during page load or interaction.
Fix priorities: Set explicit width and height on all images and videos, preload fonts and use font-display: swap with size-adjusted fallbacks, reserve space for dynamically loaded content (ads, embeds, lazy-loaded elements).

Core Web Vitals failing? Get a free teardown - we’ll run PageSpeed diagnostics and show you exactly what’s slowing your site down.

Schema Markup

Implementation

Check: Use Google’s Rich Results Test on your key page types. Validate with Schema.org’s validator for syntax errors.
Correct state: Valid JSON-LD schema in the <head> or <body> of every page type that benefits from structured data. No errors, no warnings.
Minimum schema for most sites:
- Organisation schema on the homepage
- Article/BlogPosting schema on blog posts
- BreadcrumbList schema on all pages with breadcrumbs
- FAQ schema on pages with FAQ sections
- Product schema on product pages (if e-commerce)
- LocalBusiness schema (if you serve specific locations)

Accuracy

Check: Compare schema markup content against visible page content.
Correct state: Schema data must match what’s on the page. The price in your Product schema must match the displayed price. The questions in your FAQ schema must match the visible FAQ content.
Common mistake: Schema markup generated from CMS fields that are outdated or inconsistent with page content. Google treats mismatched schema as spammy and can issue manual actions.

Internal Linking

Link Equity Distribution

Check: Export internal link counts from Screaming Frog. Identify your most-linked and least-linked pages.
Correct state: Your highest-value pages (those targeting your most important keywords with the highest revenue potential) should receive the most internal links. Internal links from the navigation, footer, and contextual body links should all point toward priority content.
Common mistake: Navigation redesigns that remove links to key pages. A footer overhaul that drops links to service pages. Both silently reduce link equity to important URLs.

Orphan Pages

Check: Compare your sitemap URLs against URLs discovered during a crawl. Any URL in the sitemap but not found via crawling is orphaned.
Correct state: Zero orphan pages. Every indexable page should be reachable by following internal links from the homepage.
Common mistake: Blog posts published months ago that were linked from the homepage at the time but are now buried with no contextual internal links pointing to them.

Anchor Text

Check: Review internal link anchor text for your most important pages.
Correct state: Anchor text should be descriptive and relevant to the target page’s topic. “Click here” and “read more” waste the opportunity to signal relevance. “Our technical SEO services” linking to your technical SEO page reinforces the topic connection. The same principle applies to external backlinks - anchor text variety and relevance signal quality to Google.
Common mistake: Over-optimised anchor text (every internal link using the exact target keyword) or completely generic anchor text (every link saying “learn more”).

XML Sitemaps

Sitemap Contents

Check: Fetch your sitemap URL and review its contents. Cross-reference against your crawl data.
Correct state: Sitemap includes only canonical, indexable, 200-status URLs. No redirects, no noindexed pages, no 404s, no non-canonical URLs.
Common mistake: CMS-generated sitemaps that include every URL the system knows about, including parameter URLs, paginated pages, and drafts. This signals to Google that you consider these URLs important, when they’re not.

Sitemap Size and Structure

Check: Is the sitemap under 50MB and 50,000 URLs? If your site is larger, do you have a sitemap index file?
Correct state: Large sites use a sitemap index that references multiple category sitemaps (blog sitemap, product sitemap, page sitemap). Each sub-sitemap is under the limits.
Common mistake: A single monolithic sitemap that times out when Google tries to fetch it.

Sitemap Freshness

Check: Does the sitemap include <lastmod> dates? Are they accurate?
Correct state: <lastmod> should reflect the actual last modification date of each page. If you update it every time your sitemap regenerates (whether content changed or not), Google ignores it.
Common mistake: Setting <lastmod> to today’s date on every page to trick Google into crawling more frequently. Google caught on to this years ago and now treats inaccurate <lastmod> as unreliable.

JavaScript Rendering

Content Availability

Check: Disable JavaScript in your browser (Chrome DevTools > Settings > Debugger > Disable JavaScript) and load your key pages.
Correct state: All critical content (headings, body text, links, images) is visible in the initial HTML without JavaScript. Interactive enhancements can depend on JavaScript; core content should not.
Common mistake: Single-page applications that serve an empty <div> to Googlebot and rely entirely on client-side rendering. Google can render JavaScript, but it’s slower, less reliable, and your pages sit in a rendering queue while server-rendered competitors get indexed immediately.

Internal Links in JavaScript

Check: View your page source (not the rendered DOM, the actual source). Are navigation links, footer links, and contextual links present in the HTML?
Correct state: All internal links exist as standard <a href="..."> tags in the HTML source. Links generated dynamically via JavaScript (like React Router <Link> components that don’t render server-side) may not be followed by Googlebot during initial crawl.
Common mistake: JavaScript-based navigation where link elements are rendered client-side. Googlebot may not discover linked pages if the links don’t exist in the initial HTML.

Mobile-First Indexing

Content Parity

Check: Compare your mobile and desktop page content. Use Chrome DevTools device emulation or Google’s Mobile-Friendly Test.
Correct state: The mobile version contains all the same content, links, structured data, and meta tags as the desktop version. Google indexes the mobile version, so if content is desktop-only, it effectively doesn’t exist for ranking purposes.
Common mistake: Hiding content on mobile with display: none or loading different content via JavaScript based on viewport. Tabbed content and accordions that are collapsed on mobile may receive less indexing weight.

Mobile Usability

Check: Search Console > Mobile Usability report. Also manually test on a real phone.
Correct state: Zero mobile usability errors. Text readable without zooming, tap targets adequately spaced (at least 48px), no horizontal scrolling, no intrusive interstitials.
Common mistake: Desktop-first design where the mobile experience is an afterthought. Fixed elements that overlay content on small screens. Cookie consent banners that take up 40% of the mobile viewport.

HTTPS and Security

SSL Configuration

Check: Load your site and verify the padlock icon. Use an SSL checker tool (like SSL Labs) for a detailed assessment.
Correct state: Valid SSL certificate covering your domain and all subdomains in use. Grade A or A+ on SSL Labs. No certificate warnings.
Common mistake: Certificate expired and nobody noticed. Subdomain not covered by the certificate. Wildcard certificate misconfigured.

HTTP to HTTPS Redirects

Check: Test all four protocol/subdomain combinations: http://domain.com, http://www.domain.com, https://domain.com, https://www.domain.com.
Correct state: All three non-canonical versions 301 redirect to the single canonical HTTPS version. No chains. Each redirect should be a single hop.
Common mistake: The www to non-www redirect works, but the HTTP to HTTPS redirect doesn’t (or vice versa), leaving some combinations serving content on multiple URLs.

Mixed Content

Check: Chrome DevTools Console tab. Look for mixed content warnings. Also check in Screaming Frog under “Insecure Content.”
Correct state: Zero mixed content warnings. All resources (images, scripts, stylesheets, fonts, iframes) loaded over HTTPS.
Common mistake: Hardcoded HTTP image URLs in old blog content. Third-party embed codes using HTTP. CMS-stored asset URLs that predate the HTTPS migration.

Log File Analysis

Crawl Behaviour

Check: Obtain server access logs and parse them for Googlebot requests (identify by user-agent string). Screaming Frog Log File Analyser or a custom script can process these.
Correct state: Googlebot is crawling your important pages frequently and spending minimal budget on low-value URLs. Crawl frequency should roughly correlate with page importance.
What to look for:
- Pages that receive heavy Googlebot crawling but aren’t in your sitemap (possibly waste)
- Important pages that Googlebot hasn’t visited in weeks (discovery problem)
- High volumes of 404 or 5xx responses to Googlebot (error signals)
- Googlebot crawling parameter URLs you didn’t intend to be crawlable

Crawl Budget Efficiency

Check: In Search Console > Settings > Crawl Stats, review total crawl requests, response times, and response codes over time.
Correct state: Steady or increasing crawl rate. Average response time under 500ms. Minimal 404 and 5xx responses. The ratio of “useful” crawled pages (indexed, ranking content) to “wasted” crawls (redirects, errors, low-value pages) should be heavily skewed toward useful.
Common mistake: Ignoring crawl budget because “Google crawls everything.” True for small sites. For sites with tens of thousands of pages or more, crawl budget directly affects how quickly new and updated content enters the index.

How to Use This Checklist

Don’t try to do everything at once. Work through it in this order:

Crawl directives and indexation: are your pages accessible and indexed?
Redirects and canonicals: is your URL structure clean?
Core Web Vitals: is your site fast enough?
Schema and structured data: are you giving Google extra context?
Everything else: internal linking, sitemaps, log analysis, mobile

Fix the items that block indexation first. Everything downstream of “Google can’t see this page” is irrelevant until that’s resolved.

Want the full system? Read our complete Technical SEO guide.