Technical SEO Audit Checklist – Expert-Level Technical Framework
A Complete Step-by-Step Framework for Crawling, Indexing, Rendering, Performance, and Technical Infrastructure Optimization
A comprehensive technical SEO audit checklist is the foundation of sustainable organic growth. Without a structured framework for evaluating crawling, indexing, rendering, performance, and site architecture, even high-quality content and strong backlinks can fail to generate consistent search visibility.
This checklist is designed for advanced SEO professionals, agencies, and in-house technical teams who need a systematic, expert-level approach to diagnosing and resolving technical search issues at scale. It goes beyond surface-level audits and focuses on the infrastructure that determines how search engines access, interpret, render, and rank your website.
Whether you are preparing for a migration, troubleshooting indexing instability, optimizing crawl budget, or strengthening Core Web Vitals, this framework provides a structured methodology aligned with modern search engine behavior.
If you're looking for a deeper strategic breakdown of how to execute a full technical seo audit step by step, this checklist serves as the operational backbone for that process.
| Crawling | Check (SEO Expert Level) | How to Verify | Pass Criteria / Expected State | Priority | Estimated Impact | Tools to Use | Expert Notes |
|---|---|---|---|---|---|---|---|
| Preparation | Compile full inventory of URLs intended to rank (money pages, hubs, categories, key articles) | Export CMS routes + XML sitemap + crawl + analytics landing pages | Single canonical URL list exists and is reviewable | High | Very High | CMS export, Screaming Frog, GSC, GA4 | Everything downstream (crawl/index/canonicals) depends on the target URL set. |
| Preparation | Define non-SEO utility pages (cart, account, internal search, filters, checkout steps) and their crawl/index policy | Site mapping + crawl pattern review | Clear allow/deny rules documented and implemented | High | High | Screaming Frog, manual mapping | Prevents crawl budget waste and index pollution. |
| robots.txt | robots.txt exists at /robots.txt | Open https://domain.com/robots.txt | Accessible and returns content | High | Very High | Browser, cURL | Missing file often leads to uncontrolled crawling (esp. parameterized URLs). |
| robots.txt | robots.txt returns HTTP 200 (not 3xx/4xx/5xx) | Check headers/status | 200 OK | High | Very High | httpstatus.io, cURL, Screaming Frog | If not 200, bots may ignore rules completely. |
| robots.txt | File size within Google limit (<= 500KB) | Check Content-Length | <= 500KB | Medium | Moderate | DevTools Network, cURL | Over-limit directives may be ignored, causing accidental crawling. |
| robots.txt | Correct plain text format and UTF-8 (no BOM) | Open raw file in editor / inspect bytes | text/plain, UTF-8 without BOM | Medium | Moderate | VS Code, cURL | Encoding issues can silently break directive parsing. |
| robots.txt | User-agent rules are valid and apply to intended bots (User-agent: *) | Syntax review + test URLs | Rules parsed as intended | High | High | GSC robots.txt Tester | Missing/incorrect blocks cause unintended allow/deny behavior. |
| robots.txt | No accidental global block (Disallow: /) | Search file for Disallow: / | Site not globally blocked | High | Very High | Manual, GSC robots.txt Tester | Classic “SEO wiped out overnight” scenario after dev deploys. |
| robots.txt | No important directives accidentally commented out with # | Scan for leading # on rule lines | Directives active (not commented) | Medium | Moderate | Manual, editor | Comments are ignored by crawlers; very common deployment mistake. |
| robots.txt | Critical rendering resources are not blocked (CSS/JS) | Crawl blocked resources + render test | CSS/JS directories crawlable | High | High | Screaming Frog, DevTools, GSC URL Inspection | Blocking can break rendering and reduce trust in layout/mobile usability. |
| robots.txt | Images/media assets not blocked (if image SEO matters) | Review Disallow rules for /img /images /media | Images crawlable | Medium | Moderate | Manual, Screaming Frog | Also affects Google’s rendered view of pages. |
| robots.txt | Sitemap directive present (Sitemap: https://.../sitemap.xml) | Check robots.txt | Sitemap referenced | Medium | Moderate | Manual | Not mandatory, but helps discovery post-migration/new URLs. |
| Crawl Policy | Internal search result URLs blocked from indexing (and usually crawling) | Identify /search, ?s=, ?q= patterns + site: checks | Not accessible/indexable for bots | High | High | Screaming Frog, GSC, manual | Search pages create infinite crawl space and low-quality signals. |
| Crawl Policy | Filter URLs (facets) controlled to avoid infinite crawl space | Parameter discovery from crawl + logs | Only allowed facets are crawlable; others blocked/canonicalized | High | Very High | Logs, Screaming Frog, GSC | For eCom: define “indexable facets” strategy; everything else should be constrained. |
| Crawl Policy | Sorting URLs controlled (e.g., ?sort=) | Crawl for sort parameters; verify directives/canonicals | Not indexable; ideally not internally linked | High | High | Screaming Frog, GSC | Sorting variants are near-duplicates; huge crawl waste. |
| Crawl Policy | Pagination crawlable for discovery, but controlled to prevent low-value indexing | Crawl paginated URLs + inspect canonicals/noindex policy | Crawlable; canonical strategy defined; no index bloat | Medium | Moderate | Screaming Frog, GSC | Goal: discovery of deeper items without indexing thousands of thin paginated pages. |
| Crawl Policy | Tracking parameters (utm_, gclid, fbclid) prevented from generating crawlable duplicates | Check internal links for UTMs; crawl parameter variants | No internal UTMs; canonical consolidates | High | High | Screaming Frog, analytics link review | UTMs should be stripped from internal links; rely on analytics tagging differently. |
| Status Codes | All indexable pages return 200 (no internal 3xx targets) | Crawl: Internal links report + response codes | Internal links resolve directly to 200 | High | High | Screaming Frog | Internal redirects waste crawl budget and dilute internal link equity. |
| Status Codes | No redirect chains / hops (301→301→200) | Redirect chain report | Single-hop redirects only | High | High | Screaming Frog, httpstatus.io | Post-migration must-fix; chains can be truncated by bots. |
| Status Codes | Redirects do not end on 404/403 | Check final destination status | Redirects end on valid 200 pages | High | Very High | Screaming Frog, httpstatus.io | Leaks authority and creates dead ends for crawlers/users. |
| Status Codes | No internal links to 4xx/410 pages | Crawl broken links | Zero internal links to broken pages | High | High | Screaming Frog, GSC | Broken internal links are a maintenance/quality signal issue. |
| Status Codes | 5xx errors eliminated or mitigated (server reliability) | Crawl + server logs + GSC crawl stats | No persistent 5xx on important URLs | High | Very High | Logs, Screaming Frog, DevTools, GSC | Persistent 5xx can cause deindexing and crawl rate reduction. |
| Status Codes | Soft 404 detection (200 pages with “not found” content) | GSC reports + manual sampling + crawl soft 404 signals | Nonexistent URLs return 404/410 (not 200) | High | High | GSC, Screaming Frog, manual | Soft 404s inflate index/crawl waste and confuse canonical selection. |
| Status Codes | Timeouts / non-responding URLs resolved | Crawl error report + server monitoring | No recurring timeouts | High | High | Screaming Frog, DevTools, monitoring/logs | Non-responsive pages are treated as unreliable by bots. |
| HTTPS / Security | Valid SSL certificate (no expiration/misconfig) | Browser security + SSL test | Secure connection without warnings | High | High | SSL Labs, DevTools Security | SSL issues harm trust and can suppress crawling/visibility. |
| HTTPS / Security | Mixed content eliminated (no HTTP assets on HTTPS pages) | DevTools Console/Network + crawl “insecure content” | All assets load over HTTPS | High | High | DevTools, Screaming Frog | Blocked resources can break rendering for Google and users. |
| Site Versions | HTTP → HTTPS enforced via 301 (all paths) | Test multiple URLs | All HTTP resolves to HTTPS | High | Very High | httpstatus.io, Screaming Frog | Prevents duplicate site versions and signal splitting. |
| Site Versions | www ↔ non-www consolidated to one canonical hostname | Test both hostnames | One version 200; other 301 to canonical | High | Very High | httpstatus.io, Screaming Frog | Must be consistent in canonicals, sitemaps, internal links too. |
| Site Versions | Trailing slash normalization (choose /page vs /page/) | Crawl duplicates + test redirect behavior | Only one version resolves as 200 | Medium | Moderate | Screaming Frog, httpstatus.io | Large sites: trailing slash duplication causes serious crawl/index noise. |
| Site Versions | Uppercase URLs redirect to lowercase | Test /Page vs /page | Uppercase 301 → lowercase | Medium | Moderate | Screaming Frog, manual tests | Prevents duplicate URLs and analytics fragmentation. |
| Site Versions | Homepage duplicate URLs (index.php, index.html, /home) handled | Test known variants | 301 to canonical homepage or 404 | High | High | httpstatus.io, Screaming Frog | Homepage duplicates split authority and can confuse canonical selection. |
| Site Versions | Nonexistent random URL returns proper 404 (not 200 or homepage) | Open /thispagedoesnotexist123/ | 404/410 | High | High | Manual, Screaming Frog | Catch-all routing that returns 200 for everything creates massive crawl spaces. |
| Site Versions | Random subdomains do NOT resolve as 200 (wildcard subdomain risk) | Test randomsub.domain.com | 404/Fail/redirect to canonical | High | Very High | Manual, DNS review | Wildcard subdomains can create infinite duplicate site versions. |
| Staging / UAT | No staging/test URLs referenced on production (links, canonicals, scripts, images) | Crawl + search for staging hostname patterns | Zero references to dev/test hostnames | High | High | Screaming Frog, code search, DevTools | Common after migrations; can leak duplicates and break canonicalization. |
| Staging / UAT | Staging environments blocked from public crawling (auth/IP allowlist + robots) | Attempt access as public user; check robots + headers | Not accessible to bots/users (defense-in-depth) | High | Very High | Manual, server config review | Don’t rely on robots.txt alone for staging protection. |
| URL Hygiene | URL length within safe bounds (avoid > 2048 chars) | Identify longest URLs in crawl | No critical URLs exceed practical limits | Medium | Moderate | Screaming Frog | Very long URLs usually signal broken filters/tracking duplication. |
| URL Hygiene | No repeated path segments (e.g., /blog/blog/) | Pattern detection in crawl exports | No repeating segments unless intentionally designed | Low | Low | Screaming Frog, Excel/Sheets filters | Often indicates routing/template bugs or taxonomy duplication. |
| URL Hygiene | No spaces in URLs (encoded %20 issues) | Crawl for %20 | Spaces replaced by hyphens; redirects in place if legacy exists | Low | Low | Screaming Frog | Usability + cleanliness; usually easy fix. |
| URL Hygiene | Hyphens used instead of underscores | Crawl for _ patterns | Hyphenated keywords | Low | Low | Screaming Frog | Not typically a blocker, but best practice for readability. |
| URL Hygiene | No multiple consecutive slashes (//) creating duplicates | Crawl for // in path | Normalized paths | Medium | Moderate | Screaming Frog | Can generate duplicate crawl paths and index noise. |
| URL Hygiene | Domain string not duplicated inside URL path | Crawl for “https://” inside path | No malformed URLs | Medium | Moderate | Screaming Frog | Usually indicates broken templating or WYSIWYG editor artifacts. |
| Internal Links | No cyclic/self-referencing links (page links to itself) | Extract inlinks/outlinks by URL | Self-links removed unless intentional (rare) | Low | Low | Screaming Frog | Minor crawl noise; can indicate breadcrumb/template issues. |
| Internal Links | Internal links do not point to redirected URLs | Internal redirection report | All internal links point to final 200 destination | Medium | Moderate | Screaming Frog | Fixing internal redirects improves crawl efficiency and link equity flow. |
| Internal Links | Orphan URL discovery (important pages with zero internal links) | Compare inventory/sitemap vs crawl inlinks | No critical pages are orphaned | High | High | Screaming Frog, GSC | Orphans may be crawled via sitemap but perform poorly and are harder to sustain in index. |
| Internal Links | Crawl depth distribution is reasonable for scale (key pages within ~1–3 clicks) | Crawl depth report + segment key templates | Revenue/priority pages not buried deep | Medium | High | Screaming Frog | Deep pages can be crawled less frequently; impacts discovery + ranking potential. |
| Rendering | Googlebot can render primary content (SSR/DSR/hydration not hiding content) | Inspect rendered HTML + compare with View Source | Core content visible in rendered output | High | High | GSC URL Inspection (render), DevTools | JS-heavy sites: ensure critical content isn’t gated behind blocked resources or delayed rendering. |
| Rendering | Robots blocks do not prevent JS/CSS required for rendering | Test blocked resources + render comparison | Rendered page matches user view materially | High | High | Screaming Frog, GSC URL Inspection | Blocked resources can cause “thin content” perception when rendered. |
| Sitemaps | XML sitemap exists and loads consistently | Open /sitemap.xml or discover via robots | Accessible and stable | Medium | Moderate | Browser, Screaming Frog | Discovery path matters especially for large/complex sites. |
| Sitemaps | Sitemap lists only 200-status, indexable canonical URLs | Crawl sitemap URLs (list mode) | No 3xx/4xx/5xx; no blocked/noindex URLs | High | High | Screaming Frog, GSC Sitemaps | A “dirty sitemap” reduces trust and wastes crawl budget. |
| Sitemaps | Sitemap respects limits (50k URLs, 50MB uncompressed) and uses index files when needed | Count URLs and file sizes | Within limits; proper sitemap index used | Medium | Moderate | Screaming Frog, server file info | Large sites should segment by template (products/categories/blog/etc.). |
| Crawl Budget | Server log review: Googlebot hits focus on valuable URLs vs infinite spaces | Analyze logs by bot, path, parameters, status | High-value templates get crawled regularly; low-value minimized | High | High | Server logs, log analyzer | Logs reveal the truth: what Google actually crawls vs what you think it crawls. |
| Crawl Budget | Parameter explosion controlled (crawl traps: calendars, faceted combos, session IDs) | Logs + crawl discovery + parameter clustering | No runaway crawling of param combinations | High | Very High | Logs, Screaming Frog | Define allowlist facets and block/normalize everything else. |
| Quality Signals | Favicon is accessible in supported format (minor but polish) | Check link rel=icon and file request | Loads successfully | Low | Low | DevTools, browser | Low severity, but contributes to professional technical hygiene. |
| Indexing | Check (SEO Expert Level) | How to Verify | Pass Criteria / Expected State | Priority | Estimated Impact | Tools to Use | Expert Notes |
|---|---|---|---|---|---|---|---|
| Indexing Baseline | Benchmark: compare “URLs that should rank” vs “URLs indexed” | Export intended URL set (sitemap + curated list) and compare to GSC Page Indexing + site: sampling | High alignment: key templates indexed; exclusions intentional and explainable | High | Very High | GSC Page Indexing, Screaming Frog, site: queries | This is the master diagnostic: if pages aren’t indexed, nothing else matters. |
| Indexing Baseline | Identify important pages NOT indexed (money pages, hubs, categories) | GSC → Page Indexing → Not indexed (segment by directory/template) | All priority pages are either Indexed or have a documented, fixable cause | High | Very High | GSC, Screaming Frog | Prioritize by revenue / search demand, not by sheer URL count. |
| Indexing Baseline | Identify pages indexed that should NOT be indexed (index bloat) | GSC → Indexed pages + “site:” queries for patterns (filters, search, cart, parameter URLs) | No low-value/system pages indexed; index contains mostly SEO-intent URLs | High | High | GSC, site: queries, Screaming Frog | Index bloat dilutes signals, wastes crawl budget, and can suppress quality scoring. |
| Indexing Directives | Important pages are NOT blocked by meta robots noindex | Crawl and extract meta robots; validate on key templates | Indexable templates do not contain noindex (unless intentional) | High | Very High | Screaming Frog (Directives), View Source | Common after staging pushes or template toggles. |
| Indexing Directives | Important pages are NOT blocked by X-Robots-Tag (HTTP header) | Inspect response headers at scale | No X-Robots-Tag: noindex on pages intended to rank | High | Very High | Screaming Frog, DevTools Network, httpstatus.io | Header noindex is a “silent killer” and often missed in audits. |
| Indexing Directives | No contradictory signals (robots disallow + sitemap include, or noindex + in sitemap) | Cross-check robots rules, sitemap URLs, and directives output | Signals aligned: indexable URLs are crawlable + indexable; blocked/noindex URLs are excluded from sitemap | High | High | Screaming Frog, robots.txt review, GSC Sitemaps | Conflicting instructions reduce trust in your hints and waste crawl budget. |
| Canonicalization | Every HTML page has a canonical tag (except where intentionally omitted) | Crawl canonical extraction; spot-check templates | Canonical present and stable across templates | High | High | Screaming Frog, View Source | Missing canonicals forces Google to choose, increasing duplicate risk. |
| Canonicalization | Important pages use self-referencing canonicals | Filter important URLs and verify canonical equals the URL (normalized) | Canonical points to itself (primary URL) | High | Very High | Screaming Frog, GSC URL Inspection | Wrong canonicals can cause deindexing of key pages. |
| Canonicalization | No multiple canonical tags (duplicate outputs) | Inspect source / crawl “multiple canonicals” | Exactly one canonical tag per page | High | High | Screaming Frog, View Source | Multiple canonicals create ambiguity; worst case Google ignores them. |
| Canonicalization | No conflicting canonicals pointing to different targets | Identify pages with multiple canonicals & different href targets | Single, correct canonical target per page | High | Very High | Screaming Frog, View Source | This can destabilize indexing and cause incorrect URL to rank. |
| Canonicalization | Canonical targets are indexable and return 200 (not 3xx/4xx/5xx, not blocked/noindex) | Crawl canonical destinations; validate status + directives | Canonical target is 200 + crawlable + indexable | High | Very High | Screaming Frog, httpstatus.io | Canonical to a redirect/404/noindex makes Google ignore your hint. |
| Canonicalization | Canonical URLs are absolute (not relative) and use the preferred domain + HTTPS | Extract canonical format; validate hostname/protocol consistency | Absolute canonical, correct preferred host, HTTPS | Medium | Moderate | Screaming Frog | Reduces risk with multi-host setups and migrations. |
| Canonicalization | Canonical tag is located in <head> (not body, not injected late) | View Source (not just DOM) + template inspection | Canonical appears once in <head> in raw HTML | High | High | View Source, Screaming Frog | Late-injected canonicals may be ignored or inconsistently processed. |
| Duplicate URL Control | Parameter URLs are not getting indexed (filters, sorts, tracking params) | GSC indexed patterns + site: queries + crawl parameter clusters | Only approved parameter pages indexed (rare); most consolidated via canonical/noindex | High | Very High | GSC, Screaming Frog, site: queries | Define allowlist for indexable facets (if any). Everything else should consolidate. |
| Duplicate URL Control | Internal search pages are not indexed | site: query for /search, ?q=, ?s=; GSC indexed pages review | Search URLs absent from index | High | High | GSC, site: queries, Screaming Frog | Internal search indexing creates infinite low-quality pages. |
| Duplicate URL Control | Pagination strategy prevents “thin paginated pages” being indexed at scale | Check paginated URLs in index + canonical policy on page=2+ | No index bloat from pagination; discovery preserved | Medium | Moderate | Screaming Frog, GSC | Modern practice: allow crawl for discovery, control indexing via canonicals/noindex (context dependent). |
| Duplicate URL Control | Trailing slash, uppercase, and alternate homepage URLs do not create indexable duplicates | Test variants + crawl duplicates + site: checks | Single canonical URL is indexed; others 301 or canonicalize properly | High | High | httpstatus.io, Screaming Frog, site: queries | Signal splitting from URL variants is a frequent cause of unstable rankings. |
| Duplicate URL Control | Duplicate content from “same product in multiple categories” is consolidated (eCom) | Identify multiple paths to same SKU; check canonical + internal linking | One product = one indexable URL; others canonicalize/redirect | High | High | Screaming Frog, manual sampling | Choose primary URL logic (category-less or primary category). Enforce everywhere. |
| Sitemaps & Indexing | Sitemap contains ONLY canonical, indexable URLs returning 200 | Crawl sitemap in List Mode; verify status + canonical + directives | 100% clean sitemap: 200-only, indexable-only, canonical-only | High | High | Screaming Frog (List Mode), GSC Sitemaps | A “dirty sitemap” reduces trust and slows discovery of new pages. |
| Sitemaps & Indexing | GSC sitemap processing shows Success (no errors/warnings) | GSC → Sitemaps report | All submitted sitemaps processed successfully | Medium | Moderate | GSC | Fix sitemap errors early—otherwise discovery becomes unpredictable. |
| Sitemaps & Indexing | Discrepancy analysis: Indexed URLs vs Sitemap URLs | Compare counts and sample mismatches (missing or extra) | Mismatches explainable (intentional exclusions, known low-value templates) | Medium | Moderate | GSC, Screaming Frog, Sheets/Excel | Large gaps often reveal canonical errors, orphan pages, or crawl traps. |
| Indexing Diagnostics | Investigate “Crawled - currently not indexed” / “Discovered - currently not indexed” clusters | GSC exclusions by reason; segment by template + directory | Key templates do not pile up in these states; causes identified and addressed | High | High | GSC Page Indexing, Screaming Frog | Often tied to perceived quality, duplication, weak internal linking, or rendering issues. |
| Indexing Diagnostics | Soft 404s: identify and correct false 200 “not found” experiences | GSC soft 404 reports + manual validation | Nonexistent pages return 404/410; thin placeholders fixed | High | High | GSC, Screaming Frog, manual | Soft 404s create crawl/index noise and quality suppression. |
| Indexing Diagnostics | Redirect indexing: ensure old URLs resolve cleanly and aren’t indexed as redirects | Check GSC for “Page with redirect” and redirect chain reports | No important URLs trapped in redirect chains; 1-hop redirects only | High | High | GSC, Screaming Frog, httpstatus.io | Critical after migrations; chains slow recrawls and slow reindexing. |
| Indexing Diagnostics | 404 and 410 handling: intentional removals vs accidental missing pages | GSC 404 reports + server logs + internal link checks | Removed pages are intentional; no broken internal links; useful custom 404 UX | High | High | GSC, Screaming Frog, logs | For removed content: consider 410 or 301 to closest equivalent where appropriate. |
| Indexing Diagnostics | 5xx errors do not affect important URLs (stability for indexing) | GSC crawl stats + server monitoring + error logs | No persistent 5xx patterns; bots can fetch pages reliably | High | Very High | GSC Crawl Stats, logs, monitoring | Repeated 5xx can reduce crawl rate and trigger deindexing. |
| Rendering & Indexability | Google can render and index primary content on JS-heavy templates | GSC URL Inspection (rendered HTML), compare rendered vs source | Primary content and internal links visible to Google after rendering | High | High | GSC URL Inspection, DevTools | If content appears only after user interaction or blocked scripts, indexing may fail. |
| Rendering & Indexability | Robots blocks do not prevent crawling of essential resources (CSS/JS) needed for rendering/indexing | Confirm robots allow for required asset directories | Assets crawlable; rendered page not “broken” for Google | High | High | robots.txt review, GSC URL Inspection | Rendering issues can look like “thin content” to Google. |
| Environment Hygiene | No staging/UAT/dev sites indexed (and cannot be indexed) | site: queries for staging hosts + GSC property checks if available | Staging not indexed; protected by auth/IP + noindex + disallow | High | Very High | site: queries, Screaming Frog, server config review | Staging indexation creates full-site duplicates and can tank trust signals. |
| Environment Hygiene | Preferred domain version is the one indexed (HTTPS + chosen host) | Sample indexed URLs and validate protocol/host consistency | Index contains preferred host/protocol only | High | High | GSC, site: queries, httpstatus.io | Domain mismatches often come from canonicals/sitemaps/internal links inconsistency. |
| Signals Affecting Indexing | Orphan detection: important URLs have internal links (not only in sitemap) | Compare intended URLs vs crawl inlinks | Key pages have >=1 internal link and reasonable crawl depth | High | High | Screaming Frog, GSC | Sitemap-only discovery is weaker and can cause unstable indexing. |
| Signals Affecting Indexing | Internal links avoid non-canonical URLs (no parameter/redirect targets) | Internal link destination normalization audit | Internal linking consistently points to canonical 200 URLs | Medium | Moderate | Screaming Frog | Internal linking is a primary canonical hint; keep it consistent. |
| Index Management | Define and enforce indexation policy by template (index / noindex / canonicalize / block) | Create template matrix and validate implementation at scale | Every template has a consistent indexation rule; exceptions documented | High | High | Screaming Frog, GSC, documentation | Enterprise approach: template governance prevents regression after releases. |
| Index Management | Monitor indexing changes after releases/migrations (regression detection) | Track GSC indexing trends; annotate deployments; run delta crawls | Indexing stable; spikes explained; rapid rollback possible | Medium | High | GSC, Screaming Frog scheduled crawls, release notes | Indexing issues often correlate directly with deployments. |
| Page Experience & Performance | Check (SEO Expert Level) | How to Verify | Pass Criteria / Expected State | Priority | Estimated Impact | Tools to Use | Expert Notes |
|---|---|---|---|---|---|---|---|
| Core Web Vitals (Field Data) | Assess CWV status using real-user data (URL groups) and isolate failing templates | Review GSC CWV report and segment by template (product/category/blog/etc.) | All key templates pass CWV (mobile first); failures mapped to specific patterns | High | High | Google Search Console (Core Web Vitals), CrUX (if available) | Field data is the ranking-relevant view; always start here, not lab-only. |
| Core Web Vitals (Field Data) | Validate that CWV issues correspond to organic landing pages (not low-value URLs) | Match CWV failing URL groups against GA4/landing pages and top queries/pages | CWV remediation prioritized on traffic/revenue templates and top landing pages | High | High | GA4, GSC Performance, GSC CWV | Fix what matters: prioritize CWV issues on pages that actually rank/convert. |
| LCP | Identify the LCP element (image, hero block, heading, video poster) per key template | Run PSI/Lighthouse; confirm LCP element in performance trace | LCP element is stable, cacheable, and loads early without heavy JS dependency | High | High | PageSpeed Insights, Lighthouse, Chrome DevTools Performance | LCP differs by template; fixing one page ≠ fixing the site. Standardize per template. |
| LCP | Optimize server delivery for LCP (TTFB, caching, CDN, HTML streaming) | Measure TTFB; inspect cache headers; compare origin vs CDN | TTFB consistently low; HTML served fast with caching/CDN where appropriate | High | High | WebPageTest, DevTools Network, server/CDN logs | Many LCP failures are actually server-side (slow backend, no caching, poor CDN config). |
| LCP | Prioritize LCP resource loading (preload hero image/fonts; avoid late discovery) | Check HTML for preload hints; verify request order in waterfall | LCP resource requested immediately; no render-blocking delays | High | High | DevTools Network, Lighthouse, WebPageTest | Preload only when you’re sure of the LCP resource to avoid wasted bandwidth. |
| LCP | Images: correct sizing, compression, and next-gen formats on above-the-fold assets | Audit image weight, dimensions, format, responsive srcset | Hero images properly sized; compressed; modern formats used where feasible | High | High | PageSpeed Insights, Lighthouse, DevTools Network | Don’t ship desktop-sized hero images to mobile. Ensure responsive images are real, not cosmetic. |
| CLS | Identify layout shift sources (ads, images without dimensions, late fonts, injected banners) | Run Lighthouse/DevTools; inspect “Layout Shift” entries | CLS stable; major shifts eliminated on key templates | High | High | Lighthouse, DevTools Performance, PSI | CLS issues often come from third-party tags or late-injected UI elements. |
| CLS | Reserve space for dynamic content (ads, embeds, consent banners, recommendations) | Inspect DOM for placeholders and fixed containers | All dynamic modules have reserved height/width; no “push-down” behavior | High | High | DevTools, Lighthouse | For ads: use stable ad slots and avoid collapsible containers above the fold. |
| CLS | Prevent font-induced shifts (FOIT/FOUT) via proper font loading strategy | Check font display strategy and preloads; measure shifts on slow connections | Minimal font swapping shifts; fonts loaded efficiently | Medium | Moderate | Lighthouse, DevTools Network | Preload critical fonts only; too many preloads can harm LCP and total load. |
| INP / Interaction | Identify interaction delays from main-thread long tasks (JS bloat, hydration, heavy frameworks) | Profile long tasks; check Total Blocking Time (lab proxy) and script execution | Main thread not blocked; interactions respond quickly across key templates | High | High | DevTools Performance, Lighthouse, WebPageTest | INP is frequently caused by large JS bundles and third-party scripts—attack those first. |
| INP / Interaction | Reduce JS payload and execution cost (remove unused JS, code split, defer non-critical) | Analyze bundle size, unused JS, script coverage | Non-critical JS deferred; critical JS minimized; unused JS reduced | High | High | Lighthouse, DevTools Coverage, bundler reports | Execution time matters more than file size. Optimize for CPU on mobile. |
| INP / Interaction | Third-party script governance (tag audit, remove unused, load after consent, async/defer) | List all third-party domains; measure their blocking time and impact | Only essential third-party scripts remain; non-critical loaded late; consent-managed | High | High | DevTools Network, Lighthouse, Tag Manager audit | Third-party scripts are the #1 cause of regressions. Create an allowlist policy. |
| Render Path | Eliminate render-blocking CSS/JS above the fold (critical CSS strategy) | Check PSI “render-blocking resources”; inspect CSS delivery | Critical styles delivered early; non-critical CSS deferred/loaded efficiently | Medium | Moderate | PageSpeed Insights, Lighthouse, DevTools | Be careful: aggressive CSS splitting can cause FOUC/CLS. Validate visually. |
| Render Path | Ensure Googlebot can render pages (no blocked CSS/JS, no broken hydration) | GSC URL Inspection “View tested page” + compare rendered HTML vs source | Rendered content matches user view; core content and links present | High | High | GSC URL Inspection, DevTools | Rendering failures can look like “thin content” and lead to indexing/ranking issues. |
| Mobile Usability | Mobile-friendly validation on key templates (viewport, tap targets, readability) | Run Lighthouse mobile; check GSC Mobile Usability (if available) and real-device spot checks | No mobile usability errors; stable UX on common devices | High | High | Lighthouse, GSC, real-device testing | Mobile-first indexing: prioritize mobile template fixes even if desktop looks perfect. |
| Mobile Experience | Interstital/UX friction audit (cookie banners, popups, overlays) on organic landing pages | Manual testing + layout shift analysis + interaction impact | No intrusive overlays blocking content; banners don’t cause major CLS/INP degradation | Medium | Moderate | Manual QA, Lighthouse, DevTools | Even compliant consent banners can harm CLS/INP if injected late without reserved space. |
| Server / Delivery | Compression enabled (Brotli/Gzip) for HTML/CSS/JS | Check response headers and transfer sizes | Compression enabled and effective across assets | Medium | Moderate | DevTools Network, WebPageTest | Compression alone doesn’t fix CWV, but it improves total load and bandwidth efficiency. |
| Server / Delivery | Modern caching strategy (CDN, cache-control, ETags) for static assets | Inspect cache headers; repeat-load tests | Static assets cached long-term; versioned filenames; minimal revalidation | Medium | Moderate | DevTools, WebPageTest | Cache correctness is critical: wrong caching breaks releases; do versioned asset filenames. |
| Server / Delivery | HTTP/2 or HTTP/3 enabled where feasible | Protocol check in DevTools/Security/Network | Modern protocol used; multiplexing benefits realized | Low | Low | DevTools, WebPageTest | Usually incremental benefit vs larger wins like caching/TTFB/JS reduction. |
| Media Optimization | Lazy-load below-the-fold images, but never delay LCP hero | Inspect loading="lazy" usage; confirm hero loads eagerly | Below-fold lazy; above-fold eager; no CLS from late loads | High | High | DevTools, Lighthouse | Common mistake: lazy-loading the hero image increases LCP dramatically. |
| Media Optimization | Video embeds optimized (poster image, deferred loading, no heavy autoplay above fold) | Check network requests; measure LCP/INP impact | Video does not become LCP bottleneck; loads efficiently | Medium | Moderate | DevTools, Lighthouse, PSI | Replace heavy embeds with click-to-load where appropriate. |
| Fonts | Font loading optimized (subset, preconnect, preload critical only) | Inspect font requests and their timing | Minimal font files; efficient loading; no major CLS from swap | Medium | Moderate | DevTools Network, Lighthouse | Self-hosted fonts often outperform third-party providers when configured correctly. |
| Page Experience Signals | Basic accessibility hygiene (alt text presence on key images, form labels, contrast issues) | Lighthouse Accessibility + manual spot checks on templates | No critical accessibility blockers on main templates | Low | Low | Lighthouse, manual QA | Not a direct CWV metric, but improves UX and reduces risk (especially for large brands). |
| Monitoring & Regression | Performance regression monitoring for releases (CWV trend watch + lab baselines) | Track CWV trends weekly; run template benchmarks before/after deploys | Regressions detected quickly; clear ownership and rollback plan | Medium | High | GSC CWV, Lighthouse CI (if available), WebPageTest | Most CWV failures come from regressions—establish a governance process. |
| Monitoring & Regression | 3-second content load target for key templates (business KPI proxy) | Lab tests on mobile throttling + real device samples | Primary content visibly available quickly; no “blank screen” phases | Medium | High | PageSpeed Insights, WebPageTest, real-device | This is not a Google threshold, but a practical conversion + UX benchmark. |
| Internal Linking & Site Architecture | Check (SEO Expert Level) | How to Verify | Pass Criteria / Expected State | Priority | Estimated Impact | Tools to Use | Expert Notes |
|---|---|---|---|---|---|---|---|
| Architecture Baseline | Validate site structure logic (topic/category hierarchy matches user intent + SEO targets) | Map IA (navigation, categories, hubs) and compare to keyword/topic model | Clear, consistent hierarchy; no conflicting taxonomies; “where does this live?” is obvious | High | High | Manual IA review, Screaming Frog (crawl tree), GSC Performance | Bad structure creates weak internal link signals and forces Google to guess topical relationships. |
| Architecture Baseline | Click-depth distribution for priority pages (money pages within 1–3 clicks) | Analyze crawl depth for key templates and top organic landing pages | Priority pages are not buried (>3 clicks); deep URLs justified (archives, long-tail) | High | High | Screaming Frog (Crawl Depth), GA4 landing pages | Depth affects crawl frequency and PageRank flow. Fix nav before “more content.” |
| Architecture Baseline | Identify structural dead ends (pages with zero outlinks or minimal navigational paths) | Find pages with low outlinks + high depth; validate template outlink modules | No important page is a dead end; each page connects to relevant parents/siblings | Medium | Moderate | Screaming Frog (Outlinks), manual sampling | Dead ends reduce crawl discovery and weaken topical clustering. |
| Orphan Pages | Detect orphans (URLs in sitemap/analytics but not in crawl graph) | Compare sitemap URLs and GA4 landing pages to crawl inlinks | Zero orphan priority pages; orphans either linked or intentionally excluded | High | High | Screaming Frog, XML sitemap, GA4, GSC | Orphans often “exist” but don’t rank because internal authority never reaches them. |
| Orphan Pages | Ensure new/updated pages are discoverable via internal links (not only via sitemap) | Spot-check recently published URLs: where are they linked from? | New pages have at least one internal link from relevant hub/category within hours/days | Medium | Moderate | CMS, Screaming Frog, internal search | Sitemap is a hint; internal linking is the real authority and discovery engine. |
| Link Quality | Internal links point to canonical 200 URLs (no redirects, no non-canonical variants) | Audit internal links → destination status + canonical consistency | Internal links resolve directly to final canonical 200 URLs | High | High | Screaming Frog (Response Codes + Canonicals), httpstatus.io | Internal linking is Google’s strongest canonical hint. Keep it consistent everywhere. |
| Link Quality | No internal links to 4xx/5xx or soft-404 pages | Broken link audit + “soft 404” sampling | Zero internal broken links; removed pages handled via redirect or removal | High | High | Screaming Frog, GSC Page Indexing | Broken internal links waste crawl budget and degrade perceived site maintenance quality. |
| Link Quality | Anchor text relevance (descriptive, non-generic, consistent with target intent) | Export inlinks to priority pages and review anchors at scale | Anchors describe destination topic; limited “click here”; internal anchors not spammy | Medium | Moderate | Screaming Frog (Anchors), site exports | Use natural variation; avoid exact-match stuffing sitewide (footers/sidebars). |
| Link Quality | Image links have meaningful alt attributes (when images act as anchors) | Extract image inlinks and check alt usage | Alt text acts as anchor substitute where relevant; decorative images empty alt | Low | Low | Screaming Frog, manual template review | Helps accessibility and provides context; don’t keyword-stuff alt. |
| Navigation | Main navigation surfaces key commercial categories/hubs (not hidden behind JS-only menus) | Inspect HTML source + rendered DOM; crawl nav links | Primary nav links crawlable; key sections linked sitewide in HTML | High | High | Screaming Frog, View Source, DevTools | If nav links aren’t present in HTML (or are blocked), discovery and authority flow suffer. |
| Navigation | Breadcrumbs implemented and internally consistent | Check breadcrumb links, hierarchy consistency across templates | Breadcrumbs link to true parent categories; no self-links; no broken crumbs | Medium | Moderate | Screaming Frog, manual sampling | Breadcrumbs are scalable internal linking; also support structured data later. |
| Navigation | Contextual modules exist (related content/products, “popular”, “recent”, “next steps”) | Template audit + outlink patterns by type | Modules provide meaningful related links; not random; not overly repetitive | Medium | Moderate | Manual review, Screaming Frog outlink exports | Relevance beats volume—linking “everything to everything” dilutes signals. |
| Pagination | Pagination is crawlable for discovery and internally linked correctly | Check paginated URL patterns and inlink/outlink flow | Google can reach deeper items; no broken paginated chains | Medium | Moderate | Screaming Frog, manual | Goal: allow discovery without indexing thousands of weak paginated pages (handled in indexing rules). |
| Facets / Filters | Internal links do not leak into infinite faceted combinations (crawl traps) | Crawl and identify parameterized internal links; measure unique URL explosion | Facet linking policy enforced; only allowed facets are internally linked/indexable | High | Very High | Screaming Frog, logs (if available), GSC | Faceted internal linking is the most common cause of crawl budget collapse on eCom. |
| Facets / Filters | Internal search links aren’t promoted sitewide (avoid linking to search result URLs) | Search crawl for /search, ?q=, ?s= linked internally | No global internal linking to internal search result pages | High | High | Screaming Frog | Internal search URLs create infinite spaces and low-quality content signals. |
| Authority Flow | Identify “authority sinks” (pages receiving many links but not contributing SEO value) | Analyze inlinks distribution (highest linked pages) and assess their SEO purpose | Top-linked pages are intentional SEO hubs/categories; utility pages not soaking equity | Medium | High | Screaming Frog (Inlinks), GA4, GSC | Common sinks: login, policy pages, internal search, account areas linked sitewide. |
| Authority Flow | Internal linking supports priority clusters (hub → subtopics → supporting content) | Cluster mapping vs internal graph; sample cluster navigation | Each cluster has a hub with strong internal links; spokes interlink logically | Medium | High | Manual cluster map, Screaming Frog exports | Think “topic graph” not “random related posts.” Build intentional pathways. |
| Authority Flow | Strategic internal links from high-authority pages to priority pages (“link boosting”) | Identify pages with high internal inlinks + external backlinks; add contextual links | Priority pages receive links from strong pages where topically relevant | Medium | High | Ahrefs/SEMrush (optional), Screaming Frog, GSC | Use relevance-based boosting; avoid sitewide footer spam. |
| Anchor Strategy | Detect anchor over-optimization (sitewide exact-match anchors) | Export anchor texts at scale; look for repetition patterns from templates | Anchors vary naturally; exact-match not repeated mechanically sitewide | Medium | Moderate | Screaming Frog (Anchors), Sheets/Excel | Template-driven anchors (nav/footer) can accidentally create spam signals. |
| Anchor Strategy | Generic anchors minimized (“read more”, “learn more”) on key contextual links | Audit anchors on editorial links and modules | Most contextual links are descriptive, especially to money pages | Low | Low | Screaming Frog, manual sampling | Not a direct penalty issue; just wasted opportunity for relevance signals. |
| Canonical Consistency | Internal links never point to non-canonical variants (parameters, session IDs, alternate paths) | Compare internal link destinations vs canonical targets | Internal linking always matches canonical preferred URLs | High | High | Screaming Frog (Canonicals + Inlinks), custom extraction | If internal links disagree with canonicals, Google may pick the “wrong” URL to rank. |
| Crawlability of Links | Critical internal links are plain HTML <a href> (not JS onclick only) | Inspect templates and rendered HTML; crawl extraction comparison | Key links are discoverable in HTML; JS enhances UX but not required for discovery | High | High | View Source, DevTools, Screaming Frog (rendered crawl if needed) | JS-only navigation increases risk: rendering delays, missed links, inconsistent crawling. |
| Crawlability of Links | Links blocked by robots/noindex policy are not heavily linked internally (avoid wasting equity) | Identify blocked/noindex URLs and their inlink volume | Non-indexable pages are minimally linked and only where necessary | Medium | Moderate | Screaming Frog, robots rules review | Some utility links are necessary; the goal is preventing sitewide equity bleed. |
| Architecture Variants (Optional) | Language/region sections are clearly separated and internally linked correctly (if international site) | Crawl language folders/subdomains; check cross-links and navigation rules | Correct segmentation; no accidental cross-region cannibalization via internal links | Medium | Moderate | Screaming Frog, manual sampling | If applicable, pairing this with hreflang audits is mandatory. |
| Governance | Template-level internal linking rules documented (nav, breadcrumbs, related modules, footer) | Document link modules and which templates they appear on | Clear linking spec exists; changes are intentional and reviewable | Medium | High | Documentation, CMS, template review | Prevents regressions after redesigns and enables scalable SEO architecture. |
| Governance | Internal link change monitoring (post-release crawl diffs and key KPI checks) | Run scheduled crawls and compare inlinks/depth changes; annotate deployments | No unexpected loss of links to priority pages; regressions detected quickly | Medium | High | Screaming Frog scheduled crawls, GSC, release notes | Internal linking regressions often cause ranking drops with no obvious “technical error.” |
| Structured Data & SERP Enhancements | Check (SEO Expert Level) | How to Verify | Pass Criteria / Expected State | Priority | Estimated Impact | Tools to Use | Expert Notes |
|---|---|---|---|---|---|---|---|
| Schema Coverage | Define schema strategy by template (Home, Category, Product, Article, FAQ, HowTo, Local, Organization) | Map templates and required/optional schema types per page type | Every key template has an intentional schema plan (not “plugin default”) | Medium | High | Manual mapping, Screaming Frog (structured data extraction) | Start from business goals: rich results & trust signals, not “add all schemas.” |
| Schema Coverage | Check structured data presence on pages where it should exist | Crawl templates and validate schema blocks exist | Expected schema present consistently per template | Medium | Moderate | Screaming Frog, View Source | Template drift is common after redesigns; validate at scale. |
| Validation | Validate eligibility and errors for rich results on priority templates | Run Rich Results Test for representative URLs; check GSC Enhancements reports | No critical errors; warnings understood and addressed where beneficial | High | High | Google Rich Results Test, GSC Enhancements | Errors can remove eligibility; warnings can still reduce appearance frequency or quality. |
| Validation | Ensure structured data matches visible page content (“content parity”) | Compare schema properties to on-page content (price, availability, rating, FAQ answers, etc.) | Schema claims are fully supported by visible content and updated in real time | High | High | Manual QA, Rich Results Test, template inspection | Mismatches can lead to loss of rich results and trust signals. |
| Validation | Confirm schema is parseable in raw HTML (not injected too late via JS) | View Source vs DOM; test with Rich Results Test | Schema available to crawlers reliably (server-side or early render) | High | Moderate | View Source, Rich Results Test, DevTools | JSON-LD is preferred; JS-injected schema can be inconsistent for indexing pipelines. |
| Implementation | Use JSON-LD as primary format (avoid microdata sprawl unless legacy) | Inspect markup format across templates | JSON-LD used consistently; minimal duplication/mixed formats | Low | Low | View Source, Screaming Frog | JSON-LD is easier to maintain and less prone to template breakage. |
| Implementation | Avoid duplicate/conflicting schema blocks (same type repeated with different values) | Crawl and compare schema entities per URL | No conflicting entities; one coherent graph per page | Medium | Moderate | Screaming Frog, View Source | Common when CMS theme + plugin both inject schema. |
| Implementation | Use consistent entity IDs (@id) to build a connected graph (Organization, WebSite, WebPage, BreadcrumbList) | Inspect JSON-LD graph structure and entity linking | Entities connected with stable @id values and consistent naming | Low | Moderate | View Source, schema review | Connected graphs improve clarity and reduce duplication across templates. |
| Brand Trust | Organization schema present with correct identifiers (name, logo, URL, sameAs) | Check homepage/brand pages and validate properties | Organization data accurate; logo accessible; sameAs links legit | Medium | Moderate | Rich Results Test, View Source | Supports brand trust and knowledge graph association (not guaranteed but helpful). |
| Brand Trust | WebSite schema with SearchAction (only if internal site search is supported and correct) | Validate SearchAction URL template | SearchAction returns valid results and doesn’t generate indexable junk URLs | Low | Low | Rich Results Test, manual validation | Be careful: wrong SearchAction can create crawl traps or poor UX. |
| Navigation Rich Results | BreadcrumbList schema present on templates with breadcrumbs | Test pages in Rich Results Test; verify itemListElement | Breadcrumb schema valid; reflects real hierarchy; URLs are canonical | Medium | Moderate | Rich Results Test, Screaming Frog | Breadcrumb rich results improve SERP display and can support sitelinks clarity. |
| Editorial Rich Results | Article/NewsArticle/BlogPosting schema implemented correctly (headline, datePublished, dateModified, author) | Validate on article templates | Required fields present; dates accurate; author entity consistent | Medium | Moderate | Rich Results Test, GSC Enhancements | Dates must match visible content; avoid fake “updated” timestamps. |
| Editorial Rich Results | Author schema alignment (Person) where authorship matters (E-E-A-T support) | Inspect author pages and entity linkage | Author identity consistent; links to author bio page where relevant | Low | Low | Manual, View Source | Not a direct ranking factor, but helps content clarity and trust presentation. |
| Ecommerce Rich Results | Product schema completeness (name, image, description, brand, offers, availability) | Test representative product pages | All required fields valid; values match visible content | High | High | Rich Results Test, Merchant Center (if used), GSC Enhancements | Product rich results can significantly impact CTR and conversion intent. |
| Ecommerce Rich Results | Offers accuracy (price, currency, availability, seller, validUntil where relevant) | Cross-check schema values vs on-page price/stock; test multiple variants | Real-time accurate offers; no stale “in stock” claims | High | High | Rich Results Test, manual QA | Mismatch is a common reason for losing product snippets or reduced trust. |
| Ecommerce Rich Results | AggregateRating/Review markup compliance (only if reviews are genuine and visible) | Validate review source and visibility; test pages | Ratings reflect visible reviews; no self-serving invalid review markup | High | Moderate | Rich Results Test, GSC Enhancements | Google has strict policies on review markup; misuse can remove eligibility. |
| Ecommerce Rich Results | Variant handling: prevent duplicate product entities across parameter URLs | Check canonical + product schema consistency across variants | One canonical product URL; variants consolidated appropriately | High | High | Screaming Frog, GSC URL Inspection | Variant URL chaos harms both indexing and product rich results consistency. |
| FAQ / HowTo | FAQPage schema used only where FAQs are present and meaningful | Check page content vs schema | FAQ Q&A visible on page; answers match schema exactly | Medium | Moderate | Rich Results Test | Don’t spam FAQ markup sitewide; use selectively on high-intent pages. |
| FAQ / HowTo | HowTo schema used only for real step-by-step instructional content | Validate step structure, images, and instructions | Steps visible and complete; schema matches page | Low | Low | Rich Results Test | Eligibility varies; use when content truly fits “HowTo” intent. |
| Local SEO (Optional) | LocalBusiness schema accuracy (NAP, geo, openingHours, priceRange) | Validate location pages and compare to Google Business Profile / site | NAP consistent across site; hours accurate; location-specific pages structured | Medium | Moderate | Rich Results Test, manual QA | Critical for multi-location brands; mismatch can confuse local signals. |
| SERP Enhancements | Title tag optimization per template (unique, intent-aligned, avoids truncation patterns) | Export titles and evaluate uniqueness, patterns, length, duplication | Unique and compelling titles; avoid boilerplate duplication | Medium | High | Screaming Frog, GSC Performance | Not schema, but directly impacts CTR. Fix duplicates and weak patterns at scale. |
| SERP Enhancements | Meta description strategy (CTR support; not duplicated; aligns with query intent) | Export meta descriptions; check duplication and template overuse | High-value pages have useful descriptions; duplicates minimized | Low | Moderate | Screaming Frog, GSC Performance | Google may rewrite, but strong descriptions can still improve CTR for many queries. |
| SERP Enhancements | Image SEO basics for SERP features (OG image, primary images indexable, correct sizes) | Check image accessibility, sizes, and indexing; validate key templates | Images crawlable, properly sized, and relevant; no blocked media folders | Low | Low | Screaming Frog, DevTools, manual | Supports Google Images and rich cards; also impacts perceived quality. |
| Monitoring | GSC Enhancements report monitored and triaged by template (errors vs warnings) | Review Enhancements weekly/monthly; segment errors by directory | Errors resolved promptly; warnings evaluated for ROI | Medium | Moderate | GSC Enhancements | Schema regressions are common after releases. Treat as a QA gate. |
| Monitoring | Track SERP feature gains/losses (rich results appearance + CTR impact) | Measure GSC performance changes for pages with schema vs without | Rich result eligible pages show stable/positive CTR trends | Medium | High | GSC Performance, rank tracking (optional) | Schema is only valuable if it changes SERP appearance and improves CTR/conversions. |
| International SEO (hreflang) | Check (SEO Expert Level) | How to Verify | Pass Criteria / Expected State | Priority | Estimated Impact | Tools to Use | Expert Notes |
|---|---|---|---|---|---|---|---|
| Strategy & Architecture | Confirm international targeting model (ccTLD vs subdomain vs subfolder; language-only vs language+region) | Review URL structure and country/language targeting requirements | Chosen architecture matches business needs and is consistent sitewide | High | High | Manual review, GSC (properties), crawl exports | Wrong targeting model causes chronic mis-targeting and cannibalization across markets. |
| Strategy & Architecture | Define locale mapping rules (which pages have alternates, which do not) | Create a URL mapping matrix by template and market | Clear mapping rules exist; missing markets are intentional and documented | High | High | Sheets/Excel, CMS exports, Screaming Frog | Enterprise hreflang fails when mapping is “ad hoc.” Treat it as a governed system. |
| Implementation Method | Hreflang implementation type is consistent (HTML tags OR HTTP headers OR XML sitemap) | Inspect templates + headers + sitemap configuration | One primary method per template set; no conflicting dual implementations | High | High | View Source, Screaming Frog, server header checks | Mixing methods can create conflicts and maintenance complexity; be deliberate. |
| Implementation Method | Hreflang tags are present in the raw HTML (not injected too late) | View Source (not DOM) on representative pages | Hreflang is visible in server-delivered HTML head | High | Moderate | View Source, Screaming Frog | JS-injected hreflang can be unreliable and inconsistent for crawlers. |
| Syntax & Standards | Language-region codes follow correct format (ISO 639-1 + optional ISO 3166-1 Alpha 2) | Validate hreflang attributes (e.g., en, en-GB, fr-FR, de-DE) | All hreflang values valid; no typos or unsupported codes | High | High | Screaming Frog, hreflang validators | One wrong code breaks clustering (e.g., “en-UK” is invalid; use “en-GB”). |
| Syntax & Standards | Use of x-default is correct (global selector / fallback page) | Check hreflang sets for x-default presence and target URL | x-default points to the correct “selector” or global fallback page | Medium | Moderate | View Source, Screaming Frog | x-default is especially useful when you have a language selector or global homepage. |
| Cluster Integrity | Reciprocal hreflang links (A references B, B references A) | Crawl hreflang sets and validate return links | 100% reciprocity across alternates; no “one-way” hreflang relationships | High | Very High | Screaming Frog (hreflang reports) | Non-reciprocal links are one of the most common reasons hreflang “does nothing.” |
| Cluster Integrity | Self-referencing hreflang exists (each page includes itself in its hreflang set) | Inspect hreflang list per URL | Each URL includes a self hreflang entry | High | High | Screaming Frog, View Source | Without self-referencing, clusters can become unstable and partial. |
| Cluster Integrity | Hreflang sets are complete (no missing key markets for equivalent pages) | Compare expected locale mapping vs extracted hreflang links | No unexpected missing alternates; gaps are intentional | Medium | High | Screaming Frog, mapping spreadsheet | Incomplete clusters cause mis-targeting and inconsistent URL selection in SERPs. |
| Canonical Alignment | Each locale page canonicalizes to itself (not to another language/region) | Extract canonicals and compare across alternates | Self-referencing canonicals on localized pages unless intentional consolidation | High | Very High | Screaming Frog (Canonicals), GSC URL Inspection | Canonical-to-other-locale overrides hreflang; Google will consolidate and ignore alternates. |
| Indexability | All hreflang target URLs are indexable (200, not noindex, not blocked) | Crawl hreflang destinations and validate status/directives | All alternate URLs return 200 and are indexable | High | High | Screaming Frog, httpstatus.io | Non-indexable alternates break clusters and cause Google to choose the wrong regional page. |
| URL Consistency | Absolute URLs used in hreflang (avoid relative paths and inconsistent hosts) | Check href values in hreflang links | Absolute URLs with correct HTTPS + preferred host | Medium | Moderate | Screaming Frog, View Source | Relative hreflang can break in multi-host deployments and staging mirroring. |
| URL Consistency | Hreflang does not point to redirected URLs or URL variants (slash/uppercase/params) | Validate final destination is 200 canonical URL | No hreflang targets returning 3xx; all point to canonical version | High | High | Screaming Frog, redirect mapper | Redirects slow processing and can break reciprocity at scale. |
| Targeting Accuracy | Localized pages contain genuinely localized content (language, currency, units, formatting) | Manual review; check templates (currency symbols, shipping, contact info) | Strong locale differentiation; no “copy-paste” thin localization | Medium | High | Manual QA, content audits | Hreflang is not a substitute for localization quality; weak localization reduces performance. |
| Targeting Accuracy | Avoid “wrong language in wrong market” issues (e.g., en-US shown in UK) | Check SERP results per country; validate which URL ranks; review GSC by property | Correct locale URLs surface in correct markets for core queries | High | High | GSC Performance (country filter), SERP sampling, rank tracking (optional) | When hreflang works, wrong-country ranking issues reduce substantially over time. |
| XML Sitemap hreflang (Optional) | If hreflang is in sitemaps, XML syntax and grouping are correct | Validate sitemap entries with xhtml:link rel="alternate" hreflang | Valid sitemap format; all alternates listed per URL entry; reciprocity maintained | High | High | Sitemap validator, Screaming Frog (List Mode) | Great for large sites; easier to manage at scale than HTML, but must be kept clean. |
| XML Sitemap hreflang (Optional) | Sitemaps contain only canonical, indexable, 200 URLs across locales | Crawl sitemap URLs and verify status/indexability | No 3xx/4xx/5xx; no noindex; no blocked URLs | High | High | Screaming Frog (List Mode), GSC Sitemaps | Dirty international sitemaps create massive noise and slow processing. |
| Common Failure Modes | Detect “language selector redirects” that prevent proper indexation (geo/IP redirects) | Test with different locations/headers; check if bots get redirected incorrectly | No forced geo-redirect for Googlebot; users can choose locale; stable indexable URLs exist | High | Very High | Manual testing, DevTools, server config checks | Forced geo redirects often break indexing and cause wrong URLs to be selected globally. |
| Common Failure Modes | Confirm hreflang sets don’t include non-equivalent pages (mismatched intent/templates) | Sample clusters: compare page purpose and content equivalence | Only true equivalents are connected; no mismatched category↔product or different topics | Medium | Moderate | Manual QA, mapping spreadsheet | Hreflang is about equivalents; mismatches reduce trust and cause ignoring. |
| Monitoring | Ongoing monitoring for hreflang errors and mis-targeting symptoms | Regular crawls + SERP sampling + GSC country performance checks | Errors trend down; correct country URLs dominate impressions in each region | Medium | High | Screaming Frog scheduled crawls, GSC Performance | Hreflang processing is not instant; monitor changes after releases/migrations. |
| Monitoring | Regression control after deployments (hreflang template drift, missing alternates) | Crawl diff: compare hreflang extraction pre vs post release | No sudden drops in hreflang coverage/reciprocity; fast rollback path | Medium | High | Screaming Frog scheduled crawls, release notes | International SEO breaks frequently after template refactors—treat as a QA gate. |
| Log File Analysis | Check (SEO Expert Level) | How to Verify | Pass Criteria / Expected State | Priority | Estimated Impact | Tools to Use | Expert Notes |
|---|---|---|---|---|---|---|---|
| Data Collection | Confirm access to raw server logs (not just CDN summaries) with required fields | Validate logs include timestamp, URL, status, user-agent, IP, bytes, referrer, response time | Logs are complete, consistent, and cover relevant time range (ideally 30–90 days) | High | Very High | Server/hosting export, CDN logs (if applicable), BigQuery/S3 | Without raw logs, you can’t see what Google actually crawls (vs what you assume). |
| Data Collection | Normalize log format across sources (origin + CDN + WAF) and remove noise | Standardize fields; deduplicate entries; align timezones; parse into a single schema | One clean dataset usable for slicing by bot/template/status/day | High | High | BigQuery, Python, Splunk/ELK, log analyzer | Timezones and duplicated CDN/origin events are common pitfalls. |
| Bot Verification | Verify Googlebot authenticity (reverse DNS / official verification) | Validate IPs claiming Googlebot via reverse DNS and forward DNS lookup | Googlebot dataset contains only verified bots (no spoofed UAs) | High | High | DNS tools, log analyzer, custom scripts | UA spoofing is real; don’t base strategy on fake “Googlebot” traffic. |
| Crawl Budget | Measure crawl distribution by template (money pages vs low-value pages) | Group URLs by pattern (products/categories/blog/search/filters) and count Googlebot hits | High-value templates receive the majority of crawl hits; low-value minimized | High | Very High | BigQuery, Screaming Frog URL pattern mapping, log analyzer | This reveals crawl waste and whether Google invests in your important URLs. |
| Crawl Budget | Detect crawl traps (facets, search, calendar, infinite parameters, session IDs) | Find high-unique URL counts with low value; analyze parameter combinations and depth | No runaway crawling; traps blocked/normalized/canonicalized | High | Very High | Logs, Screaming Frog, GSC URL Parameters review (if applicable) | Crawl traps are the #1 reason large sites fail to get new pages indexed quickly. |
| Crawl Budget | Quantify crawl of non-indexable URLs (noindex, blocked, 4xx) to measure wasted budget | Join logs with crawl data: directives (noindex), robots blocks, status codes | Low proportion of Googlebot hits wasted on non-indexable/errored URLs | High | High | Logs + crawl export (Screaming Frog), BigQuery | If Google spends time on junk, important URLs get crawled less often. |
| Crawl Frequency | Measure crawl frequency for priority URLs (median time between hits) | Compute time deltas per URL for Googlebot hits; segment by template | Priority templates recrawled frequently enough for business needs | High | High | BigQuery/Python, log analyzer | Great for diagnosing slow reindexing after updates and content refreshes. |
| Crawl Frequency | New content discovery speed (time from publish to first Googlebot hit) | Join publish timestamps with first Googlebot request timestamps | New URLs discovered quickly (hours/days depending on site size) and not blocked | High | High | CMS timestamps, logs, GSC URL Inspection sampling | If discovery is slow: internal linking + sitemap + crawl traps are usual culprits. |
| Status Codes | Measure 5xx error rates for Googlebot (server reliability signal) | Filter Googlebot hits by 5xx; trend by hour/day; correlate with traffic spikes/deploys | 5xx rates near zero; no sustained periods of Googlebot failures | High | Very High | Logs, monitoring (APM), GSC Crawl Stats | Persistent 5xx can reduce crawl rate and cause temporary deindexing. |
| Status Codes | Measure 404/410 rates from Googlebot and identify high-hit missing URLs | Rank 4xx URLs by Googlebot hits; identify sources (internal links, sitemaps, legacy backlinks) | 4xx crawl reduced; important missing URLs redirected or intentionally 410 with cleanup | High | High | Logs, Screaming Frog, backlink tools (optional) | High-hit 404s = crawl waste and lost link equity opportunity. |
| Status Codes | Identify redirect waste (3xx volume, chains, loops) as seen by Googlebot | Measure Googlebot hits on 3xx; reconstruct chains from Location headers if logged | Minimal 3xx crawl; chains eliminated; legacy redirects one-hop | High | High | Logs, httpstatus.io, Screaming Frog redirect reports | Redirect-heavy sites slow recrawl and dilute efficiency, especially at scale. |
| Rendering & Resources | Confirm Googlebot fetches critical JS/CSS assets and they return 200 | Filter Googlebot hits to /assets/, /js/, /css/ and check status/latency | Critical resources frequently fetched and served reliably | Medium | Moderate | Logs, DevTools, GSC URL Inspection | Blocked or failing resources can cause partial rendering and indexing issues. |
| Robots & Blocks | Validate robots.txt behavior in real logs (Googlebot should NOT request blocked patterns frequently) | Compare blocked URL patterns vs Googlebot requests in logs | Googlebot requests align with allowed crawl policy; blocked paths rarely requested | Medium | Moderate | Logs, robots.txt review | Google may still request blocked URLs occasionally; high volume indicates internal linking leaks or traps. |
| Robots & Blocks | Detect “blocked but indexed” symptoms via log patterns + indexing reports | Find high-hit blocked URLs; compare with GSC indexing and site: queries | Blocked URLs are not showing up as indexed (except rare legacy cases) | Medium | Moderate | Logs, GSC Page Indexing | Robots blocking alone doesn’t remove indexed URLs—use noindex (if crawlable) or removal strategy. |
| Sitemap ROI | Measure Googlebot crawl coverage of sitemap URLs vs non-sitemap URLs | Join logs with sitemap URL set and compute hit rates/frequency | Sitemap URLs are crawled more consistently than non-sitemap (for priority templates) | Medium | Moderate | Logs, sitemap export, BigQuery | If sitemap URLs aren’t crawled, sitemap quality/trust or crawl budget may be the issue. |
| Sitemap ROI | Detect “dirty sitemap” impact (Googlebot hits to sitemap URLs returning 3xx/4xx) | Filter log hits where URL in sitemap AND status != 200 | Near-zero non-200 hits for sitemap URLs | High | High | Logs, Screaming Frog (List Mode), GSC Sitemaps | Non-200 URLs in sitemap waste crawl budget and reduce sitemap trust. |
| Indexing Diagnostics | Identify URLs heavily crawled but not indexed (potential quality/duplication/canonical issues) | Cross-reference frequently crawled URLs with GSC indexing status | Important URLs that are heavily crawled are also indexed; exceptions diagnosed | High | High | Logs, GSC Page Indexing, URL Inspection | “Crawled but not indexed” + high crawl frequency often indicates duplication or weak perceived value. |
| Indexing Diagnostics | Find URLs rarely/never crawled but expected to index (discovery/internal linking issue) | Join intended URL set with logs; identify zero-hit or low-hit URLs | All priority URLs receive Googlebot hits within reasonable windows | High | High | Logs, Screaming Frog (orphan/depth), sitemap | Fix internal linking depth/orphans before blaming “Google.” |
| Bot-Observed Performance | Analyze response time/latency for Googlebot by template and status | Use logged response time fields (or infer from upstream) and trend over time | Stable low latency; spikes correlate with known incidents and are remediated | Medium | Moderate | Logs, APM (Datadog/New Relic), GSC Crawl Stats | Slow responses can reduce crawl rate; Google adapts crawl load to server health. |
| Bot Segmentation | Segment by Googlebot types (smartphone vs desktop; image bot, video bot) | Parse UAs; group crawl patterns by bot type and directory | Smartphone bot crawls key HTML; image bot crawls media when relevant | Medium | Moderate | Logs, UA parsing libraries | Helpful for diagnosing mobile-first indexing issues and blocked media assets. |
| Security / WAF | Ensure Googlebot is not intermittently blocked by WAF/CDN rules (403/429 patterns) | Filter verified Googlebot hits by 403/429; correlate with firewall logs/rules | No sustained 403/429 for verified Googlebot; allowlisting rules in place if needed | High | Very High | Logs, WAF/CDN dashboard, security team review | Bot blocks can silently cause deindexing and crawling drops without obvious site errors. |
| Reporting & Action | Create a crawl budget “waste map” (top wasted patterns by hits and unique URLs) | Rank patterns (params, filters, search, 404, redirects) by Googlebot hits and uniqueness | Clear prioritized list of fixes with estimated crawl budget recovered | High | Very High | BigQuery/Python, log analyzer, Sheets | This turns logs into roadmap: block traps, clean internal links, fix sitemaps, improve server reliability. |
| Reporting & Action | Set up ongoing monitoring and regression alerts (crawl rate drops, 5xx spikes, 403/429 spikes) | Build dashboards + alerts tied to deployments and traffic patterns | Fast detection of SEO-impacting incidents; documented incident response | Medium | High | Looker/Datastudio, BigQuery, APM, GSC Crawl Stats | Log monitoring is a competitive advantage for large sites and frequent deploy cycles. |
| JavaScript SEO & Rendering | Check (SEO Expert Level) | How to Verify | Pass Criteria / Expected State | Priority | Estimated Impact | Tools to Use | Expert Notes |
|---|---|---|---|---|---|---|---|
| Rendering Model | Identify rendering approach per template (SSR / SSG / ISR / CSR / DSR) and SEO risk profile | Review framework (Next.js/Nuxt/React/Vue), server headers, HTML source completeness, hydration behavior | Critical SEO pages are SSR/SSG/ISR (or have reliable prerender); CSR-only pages are not SEO-critical | High | Very High | View Source, DevTools, framework docs/config, GSC URL Inspection | CSR-only for money pages is the #1 “indexing is random” root cause on modern stacks. |
| Rendering Model | Verify that primary content exists in initial HTML response (not only after JS execution) | Compare View Source (raw HTML) vs rendered DOM; check if key text is missing from source | Key content (H1/body copy/product data) is present in raw HTML for SEO pages | High | Very High | View Source, DevTools Elements, GSC URL Inspection (rendered HTML) | Google can render JS, but it’s delayed and less reliable at scale—raw HTML wins. |
| Rendering Pipeline | Confirm Googlebot Smartphone can render pages without blocked JS/CSS dependencies | GSC URL Inspection “View tested page” + blocked resources checks | Rendered view is complete; no critical resource fetch failures | High | High | GSC URL Inspection, DevTools Network, robots.txt review | Robots blocks on /_next/, /static/, /assets/ can cripple rendering and indexing. |
| Link Discovery | Critical internal links are in crawlable HTML (<a href>), not JS-only handlers (onclick/router push) | Inspect source for href links; crawl extraction comparison; test without JS | Navigation and contextual links exist as normal anchors with valid hrefs | High | Very High | View Source, Screaming Frog, DevTools | JS-only links can be missed or deprioritized, especially on large sites and deep pages. |
| Link Discovery | SPA routing does not hide URLs (every important state has a unique URL and is internally linked) | Navigate key flows (filters, tabs, product variants) and check URL changes + crawlability | Each indexable page state has a unique URL, accessible via internal links | High | High | Manual QA, Screaming Frog, DevTools | If UI states don’t map to URLs, Google can’t reliably discover/rank them. |
| Link Discovery | Ensure internal linking is not generated only after user interaction (click/scroll/consent gates) | Check if links appear only after interaction; test no-JS and slow 3G throttling | Links to key pages available without interaction; consent doesn’t block core navigation | High | High | DevTools (disable JS), Lighthouse, manual throttling | Interaction-gated links cause discovery failures and slow indexation. |
| Head Management | Title tags and meta descriptions are server-rendered (not only client-side) | Compare View Source vs rendered DOM head; sample templates | Correct titles/descriptions present in raw HTML and stable per URL | High | High | View Source, Screaming Frog, DevTools | Client-only head tags often cause wrong metadata in index and SERPs. |
| Head Management | Canonical tags are server-rendered and correct (self-referencing on important pages) | Extract canonicals; verify they’re in <head> in raw HTML | Canonical present, single, accurate, and points to indexable 200 URL | High | Very High | Screaming Frog, View Source, GSC URL Inspection | JS-injected canonicals are risky; conflicting canonicals cause deindexing/duplication. |
| Head Management | Meta robots / x-robots directives are consistent and not accidentally applied via JS or middleware | Check raw HTML + headers; crawl directives at scale | No accidental noindex on ranking pages; directives consistent per template | High | Very High | Screaming Frog, DevTools Network, httpstatus.io | Header-based noindex is common in edge/middleware deployments. |
| Structured Data | Structured data (JSON-LD) available in raw HTML and matches visible content | View Source + Rich Results Test + compare to rendered UI values | Schema present in source, valid, and content-parity holds | Medium | High | Rich Results Test, View Source, GSC Enhancements | JS-injected schema can “flicker” and lead to eligibility instability. |
| Indexing Reliability | Detect “two-wave indexing” risk: pages crawled but not indexed due to JS dependency | Find URLs in GSC “Crawled - currently not indexed”; compare raw HTML completeness | SEO pages index without heavy reliance on JS rendering | High | High | GSC Page Indexing, URL Inspection, View Source | CSR content often delays indexing; at scale it becomes a consistent suppression factor. |
| Indexing Reliability | Ensure pre-render/SSR does not serve “shell HTML” to bots (empty containers) | Inspect HTML response for meaningful text vs placeholder divs | No “app shell only” responses for important pages | High | Very High | View Source, curl, GSC URL Inspection | App shells are the fastest route to “thin content” signals and non-indexing. |
| JS Payload & Execution | Measure JS bundle size and execution time on mobile (INP/TBT risk) | Lighthouse + DevTools Performance + Coverage | Critical templates have optimized bundles; long tasks reduced | High | High | Lighthouse, DevTools Performance, DevTools Coverage | Execution time (CPU) is usually the bottleneck, not download size. |
| JS Payload & Execution | Code splitting works (route-based chunks) and avoids shipping sitewide JS unnecessarily | Inspect chunking behavior; compare scripts loaded across templates | Each template loads only what it needs; shared chunk is minimal | Medium | High | DevTools Network, bundle analyzer (framework tool) | Common issue: one giant bundle for everything → poor INP and slow rendering. |
| JS Payload & Execution | Third-party tags are controlled (async/defer, consent-gated, loaded late) | Audit third-party domains and measure their main-thread cost | Non-essential scripts deferred; no heavy blocking tasks from tags | High | High | DevTools Performance/Network, Lighthouse, Tag Manager audit | Third-party is the most common source of SEO performance regressions. |
| Hydration & Rendering | Hydration errors not present (console errors, mismatches, broken interactive components) | DevTools Console + QA on key templates | No hydration mismatch warnings or runtime exceptions impacting content | High | High | DevTools Console, monitoring (Sentry etc.) | Hydration failures can cause content not to load for users and may affect Google rendering. |
| Hydration & Rendering | Critical content is not loaded via blocked APIs (CORS/auth) when Googlebot requests pages | Simulate bot access; check API response codes for bot-like requests | APIs accessible to bots where needed; no auth walls for public content | High | Very High | DevTools Network, server logs, curl | Common issue: API blocks unknown UAs or requires cookies → Google sees empty content. |
| Prerendering | If using prerender/dynamic rendering, confirm it’s stable and content-parity holds | Compare bot HTML vs user HTML; monitor output changes | Prerendered output equals user-visible content; no cloaking-like divergence | Medium | High | curl UA tests, GSC URL Inspection, diff tools | Dynamic rendering is fragile; prefer SSR/SSG when possible. |
| Routing & Status Codes | Client-side routing returns correct HTTP status codes (404/410 not served as 200 shell) | Request non-existent URLs and validate server response status + body | Real 404/410 returned for missing pages; no 200 “soft 404 shell” | High | Very High | curl/httpstatus.io, Screaming Frog, GSC (soft 404) | SPA catch-all routes that return 200 for everything create massive crawl/index pollution. |
| Routing & Status Codes | Redirects are server-side (301/302), not JS-only redirects | Check redirect behavior with JS disabled and via header inspection | Redirects occur via HTTP status + Location header | High | High | httpstatus.io, DevTools, Screaming Frog | JS redirects are less reliable for crawlers and can cause indexing delays. |
| Edge & Personalization | Personalization does not change indexable content (no geolocation/cookie-dependent core content) | Compare HTML output across locations/cookies/UAs | Stable indexable HTML; variations limited to non-critical UI | Medium | High | curl with different headers, CDN logs, manual testing | Geo/cookie personalization can create inconsistent indexing signals and wrong canonical selection. |
| Edge & Personalization | Cache headers do not cause “wrong content served” across locales (Vary headers correct) | Inspect Vary, Cache-Control, CDN config; test cache hits across locales | Correct caching by locale/device where required; no cross-locale leaks | Medium | High | DevTools, CDN dashboard, logs | Misconfigured caching can cause hreflang/content parity issues and indexing chaos. |
| Monitoring | JS SEO regression testing in CI (HTML snapshot tests for key templates) | Set up automated fetch + diff of raw HTML and key SEO tags | Deploys cannot ship “empty shell” or missing canonicals/titles undetected | Medium | High | Custom scripts, Lighthouse CI, snapshot testing | Best practice for modern stacks: treat SEO tags/content as testable artifacts. |
| Monitoring | Ongoing monitoring of “Indexed vs Not indexed” for JS templates after releases | Track GSC Page Indexing trends and annotate deployments | No spikes in “Crawled/Discovered - not indexed”; issues caught early | Medium | High | GSC, scheduled crawls, release notes | Indexing instability is often correlated with frontend releases and route changes. |
FAQ
What is a technical SEO audit checklist?
A technical SEO audit checklist is a structured framework used to evaluate how search engines crawl, render, index, and interpret a website. It covers infrastructure areas such as crawling accessibility, index control, canonicalization, internal linking, performance, JavaScript rendering, structured data, hreflang, and log file analysis.
How often should a technical SEO audit be performed?
For most sites, a full audit should be conducted quarterly. It is also essential before and after major migrations, redesigns, or CMS changes. High-deployment environments benefit from continuous monitoring and regression testing instead of relying only on periodic audits.
What is the difference between technical SEO and on-page SEO?
Technical SEO ensures search engines can properly crawl, render, and index pages. On-page SEO focuses on content quality, keyword targeting, and semantic optimization. Without technical stability, even well-optimized content may struggle to rank.
Why is crawl budget important?
Crawl budget determines how efficiently search engines allocate resources to your website. If Googlebot spends time crawling parameter URLs, redirects, soft 404 pages, or infinite faceted combinations, important pages may be discovered and indexed more slowly.
Why are pages marked “Crawled – currently not indexed”?
This status often indicates thin content, duplication, weak internal linking, canonical conflicts, or JavaScript rendering issues. Resolving it typically requires improving content quality, strengthening internal links, and validating technical signals.
Does JavaScript affect SEO?
Yes. If critical content, links, metadata, or canonicals are loaded only after client-side rendering or require user interaction, indexing may be delayed or inconsistent. Server-side rendering (SSR) or static generation (SSG) generally improves reliability.
Do Core Web Vitals directly impact rankings?
Core Web Vitals are part of Google’s page experience evaluation. While relevance remains the primary ranking factor, poor performance can reduce competitiveness, user engagement, and overall visibility in close SERPs.
Is structured data required for ranking?
Structured data does not directly increase rankings, but it enables rich results and can improve click-through rate by enhancing SERP appearance. Implementation must align with visible page content to remain eligible.
What tools are required for a comprehensive technical SEO audit?
An expert-level audit typically requires Google Search Console, a crawler such as Screaming Frog, performance testing tools, server log access, and manual source code inspection. Combining crawl data with log file analysis provides the most accurate view of search engine behavior.
Get clear on what to fix first
Get in touch today for a free SEO consultation and discover how we can grow your business together.
Email me directly at: contact@askseocoach.com