Technical SEO Checklist: From Core Web Vitals to Indexing

Technical SEO is the set of work that makes a website reliably crawlable, indexable, fast and unambiguous to search engines — and, increasingly, to the generative systems that build answers from web content. It does not produce content or earn links. It removes the obstacles that stop good content and good links from counting.

The order in which you fix things matters, because the layers depend on each other. There is no point tuning structured data on a page that is blocked from crawling.

The fix order

1. Access

• robots.txt returns 200, is not blocking CSS or JavaScript needed for rendering, and does not accidentally disallow a whole directory.
• Server returns correct status codes: 200 for live pages, 301 for permanent moves, 404 for genuinely missing pages, 410 for deliberately removed ones. Soft 404s — a “not found” message returned with a 200 — are a common and damaging error.
• HTTPS everywhere, with no mixed content and no redirect chains from HTTP.
• One canonical hostname. Choose www or bare domain and redirect the other, in one hop.
• No unintentional geo-blocking or bot-blocking at the CDN or WAF level. Aggressive bot protection that blocks legitimate crawlers is a frequent and invisible cause of traffic loss.
• Decide explicitly which AI crawlers you permit: GPTBot, OAI-SearchBot, PerplexityBot, ClaudeBot, Google-Extended, Applebot-Extended.

2. Indexing signals

• Every page has a self-referencing canonical unless it deliberately points elsewhere.
• Canonicals do not conflict with sitemap entries, hreflang annotations or internal links.
• noindex is used deliberately, and never combined with a robots.txt disallow on the same URL — the crawler must be able to fetch the page to see the directive.
• Parameter and filter URLs do not generate a large set of near-duplicate indexable pages. Faceted navigation is the single most common source of crawl waste on e-commerce sites.
• Pagination is crawlable with real links, not JavaScript-only “load more”.
• XML sitemaps contain only canonical, indexable, 200-status URLs, with accurate lastmod. Split large sitemaps by content type so index coverage problems are easier to localize.
• Search Console’s page indexing report is reviewed regularly, and each “crawled — currently not indexed” or “discovered — currently not indexed” cluster is explained rather than ignored.

3. Rendering

• Test what the crawler receives, not what your browser shows. Use the URL Inspection tool’s rendered HTML and a fetch without JavaScript.
• Primary content and internal links exist in the initial HTML where possible. Client-side rendered content is processed, but with delay and with more failure modes.
• Lazy loading uses native loading="lazy" or intersection observers that still expose content to the crawler; content that only appears on scroll events may never be seen.
• Critical navigation uses real <a href> elements. Links implemented as click handlers on non-anchor elements do not pass importance.

4. Site architecture and internal linking

• Important pages are reachable within a small number of clicks from the homepage.
• Internal links use descriptive anchor text rather than “click here”.
• Orphan pages — in the sitemap but linked from nowhere — are identified and either linked or removed.
• Related content is cross-linked deliberately: a service page to its supporting articles and back.
• Breadcrumbs exist and are marked up with BreadcrumbList.
• URL structure is stable, lowercase, hyphenated and readable. Changing URLs has a cost; change them once, correctly.

5. Core Web Vitals

Three metrics, measured on real user data in Search Console and in your own real-user monitoring:

Practical fixes, roughly in order of return:

1. LCP: identify the LCP element, then preload it, serve modern image formats, size images correctly, remove render-blocking resources, and improve server response time with caching or a CDN.
2. INP: break up long JavaScript tasks, defer non-critical scripts, reduce third-party tag weight, and avoid heavy work in event handlers. Excess client-side tagging is a frequent cause; moving tags server-side helps.
3. CLS: set explicit dimensions on images and embeds, reserve space for ads and banners, avoid injecting content above existing content, and preload fonts to prevent late swaps.

Lab tools are for diagnosis. Field data is the verdict.

6. Structured data

Implement as JSON-LD, and link entities with @id so they resolve into one graph:

Validate with the Rich Results Test and monitor the enhancement reports in Search Console. Structured data must describe what is actually on the page; marking up content the user cannot see is a policy violation.

7. Internationalization

• hreflang annotations are reciprocal, include a self-reference and an x-default.
• Language and region codes are valid, and the country code is only used when the page is genuinely region-specific.
• Each language version is genuinely localized, not machine-translated.
• No forced IP-based redirects; offer a visible language switcher instead.
• Canonicals point within the same language version, never across languages.

8. Monitoring and log analysis

Server logs are the only source that shows what crawlers actually did rather than what you believe they did. From a month of logs you can answer:

• Which URLs consume the most crawl requests, and are they the URLs that matter?
• How much crawl activity goes to parameter URLs, redirects or 404s?
• Which important pages are crawled rarely or never?
• Has crawl frequency changed after a release?

Set up alerting on: sudden changes in indexed page count, a spike in 5xx responses, Core Web Vitals threshold breaches, robots.txt changes, and unexpected noindex appearing in production. Most catastrophic SEO incidents are deployment accidents that went unnoticed for weeks.

A quarterly audit routine

1. Crawl the site with a desktop crawler and compare against the sitemap and against Search Console’s indexed set.
2. Reconcile the three lists; every discrepancy has a cause worth naming.
3. Pull a month of server logs and review crawl distribution.
4. Review Core Web Vitals field data by template, not by individual URL.
5. Validate structured data across one page of each template type.
6. Check hreflang reciprocity across all language versions.
7. Review redirect chains and internal links pointing at redirects or 404s.
8. Confirm crawler access rules, including AI user agents, still match policy.

Closing

Technical SEO is maintenance work with occasional large payoffs. The large payoffs almost always come from finding something broken — a blocked directory, a rogue noindex, a faceted navigation generating hundreds of thousands of crawlable URLs — rather than from an optimization nobody has thought of. Audit on a schedule, monitor continuously, and fix in dependency order.

Moon Workshop runs technical SEO alongside content and GEO work from Antalya, Türkiye, for sites operating in Turkish and in international markets: crawl and index diagnostics, Core Web Vitals remediation, structured data and monitoring handled as a continuing program rather than a one-off audit document.