The Ultimate Technical SEO Checklist
60+ actionable technical SEO checklist items covering crawlability, Core Web Vitals, structured data, redirects, mobile SEO, AI search optimization, and technical audits. Every item includes code examples and step-by-step fixes. Free interactive checklist updated for 2026.
What Is Technical SEO?
A simple definition and why it matters more than ever in 2026.
Technical SEO is the practice of optimizing your website's infrastructure so search engines can find, crawl, understand, and index your content. Think of it as building the foundation of a house. No matter how beautiful the furniture (your content) or how many people talk about it (your backlinks), if the foundation is cracked, the house collapses.
It covers everything that happens behind the scenes: server configuration, site speed, URL structure, robots.txt, XML sitemaps, schema markup, security certificates, mobile responsiveness, and more.
A what is a technical SEO checklist example would include items like verifying index coverage in Google Search Console, fixing duplicate website versions, optimizing robots.txt for all crawlers, submitting XML sitemaps, and auditing canonical tags. Each item has a specific fix with code examples and verification steps.
Why It Matters More in 2026
Technical SEO now serves two masters: traditional search engines (Google, Bing) and AI-powered search systems (ChatGPT, Perplexity, Claude, Google AI Overviews). The same fixes that help Google index your pages also determine whether AI agents can access and cite your content.
A single technical issue, like blocking GPTBot in robots.txt or using broken HTML structure, can make you invisible across both surfaces simultaneously. The stakes have never been higher.
Technical SEO vs On-Page vs Off-Page
| Aspect | Technical SEO | On-Page SEO | Off-Page SEO |
|---|---|---|---|
| Focus | Infrastructure | Content | Authority |
| Examples | Site speed, crawling, indexing, schema, security | Keywords, headings, meta tags, internal links | Backlinks, social signals, brand mentions |
| Who does it | Developers + SEOs | Content writers + SEOs | PR + marketers |
| Tools | GSC, Screaming Frog, PageSpeed | Surfer, Yoast, AIOSEO | Ahrefs, Majestic, Moz |
| Time to impact | Days to weeks | Weeks to months | Months to years |
| Priority order | First | Second | Third |
| AI search impact | Direct | Indirect | Minimal |
Technical SEO comes first because search engines cannot rank content they cannot find.
Why Technical SEO Matters in 2026
Technical SEO is the foundation of every successful search strategy. If Google, Bing, or AI systems like ChatGPT and Perplexity cannot crawl and understand your site, nothing else matters. Not your content. Not your backlinks. Not your keyword research.
With AI-powered search now pulling content in real time, technical SEO serves two masters: traditional search engines and large language models. The same fixes that help Google index your pages also determine whether ChatGPT cites your content.
This checklist covers every layer: crawling, indexing, rendering, performance, structured data, security, mobile usability, and AI agent readiness.
How We Compare to Competitors
How to Use This Checklist
Two paths depending on your experience level. Both lead to a fully optimized site.
No Coding Required
Time: 2-3 hours total · Who: Non-developers, marketers, business owners
- Start with the For Non-Technical Marketers section
- Use the interactive checklist for the basics only
- Skip code items, focus on detection (GSC, PageSpeed)
- Share technical findings with your developer
- Bookmark the audit schedule for monthly check-ins
Full Technical Audit
Time: 1-2 days per full audit · Who: SEO pros, developers, agencies
- Complete every item from top to bottom
- Use code examples to implement fixes directly
- Run the full audit schedule (weekly, monthly, quarterly)
- Deep dive into category pages for advanced techniques
- Cross-reference with the tools comparison to optimize your stack
Crawlability and Indexing
Robots.txt, XML sitemaps, redirect chains, broken links, crawl budget, IndexNow, and more. 20 checks.
20 items →JavaScript SEO and Rendering
CSR vs SSR vs SSG, two-wave indexing, dynamic rendering, hydration, structured data, and AI crawler visibility. 14 checks.
14 items →Indexing and Canonicalization
Fix crawled currently not indexed, discovered currently not indexed, noindex, rel canonical, indexifembedded, and duplicate content. 16 checks.
16 items →International SEO and Hreflang
Hreflang tags, x-default, ccTLD vs subdirectory vs subdomain, multilingual SEO, and the International Targeting report. 14 checks.
14 items →HTTP Status Codes and Redirects
301 vs 302, redirect chains and loops, soft 404s, 410 gone, 500 errors, and preserving link equity. 14 checks.
14 items →Crawl Budget and Log Analysis
Googlebot crawl stats, server log file analysis, AI crawler audits, XML sitemap prioritization, crawl depth. 15 checks.
15 items →Image SEO
Alt text, image file names, WebP and AVIF, lazy loading, image sitemaps, Google Images and Lens signals. 15 checks.
15 items →On-Page Technical SEO
Title tags, meta descriptions, H1 and heading hierarchy, keyword placement, content depth, keyword cannibalization. 15 checks.
15 items →CDN, Caching, and Hosting
TTFB, cache-control headers, browser caching, CDN cache hit rates, HTTP/3, hosting location. 15 checks.
15 items →Ecommerce Faceted Navigation
Index bloat, filter URL crawl waste, noindex vs canonical for filters, parameter handling, infinite combinations. 15 checks.
15 items →Accessibility and A11y
WCAG 2.2 AA compliance, semantic HTML, alt text, color contrast, keyboard navigation, ARIA best practices, skip links. 15 checks.
15 items →E-E-A-T and Entities
Author entities, Person and Organization schema with sameAs, Knowledge Graph signals, trust, original research, scaled content abuse. 15 checks.
15 items →SEO Site Migrations
Golden 301 redirect map, staging lockdown, launch sequence, Change of Address, recovery U-curve monitoring. 15 checks.
15 items →Core Web Vitals and Performance
LCP, INP, CLS optimization, image compression, CDN, caching, TTFB, performance budgets. 12 checks.
12 items →Site Architecture
URL structure, internal linking, breadcrumbs, navigation, silo structure, topic clusters, orphan pages. 12 checks.
12 items →Structured Data and Schema
Article, Organization, Breadcrumb, FAQ, Product, HowTo, Person, and more. JSON-LD examples for 12 schema types.
12 items →Security and HTTPS
SSL certificates, mixed content, HSTS headers, CSP, TLS configuration, security headers audit. 12 checks.
12 items →Mobile and UX
Mobile-first indexing, responsive design, viewport, touch targets, font readability, interstitials, PWA. 12 checks.
12 items →AI Search and GEO
AI crawler access, semantic HTML, entity optimization, llms.txt, OKF bundles, agentic commerce, and more. 12 checks.
12 items →Technical SEO Audit
Weekly, monthly, quarterly, and annual audit routines. Agency-grade audit framework with P0-P3 priority. 20+ checks.
20+ items →For Non-Technical Marketers
What you can do without touching code. When to call a developer. Free tools that do the work. 15 checks.
15 items →Tools Comparison
Free vs paid tools. Which tool for which task. Google Search Console, Screaming Frog, Semrush, Ahrefs.
ReferenceInteractive Technical SEO Checklist
Click any item to check it off. Your progress saves automatically in your browser.
Crawlability and Indexing 12 items
Check if your site is indexed in Google Search Console
Open GSC > Pages report. Verify your index coverage. Look for "Crawled but not indexed" pages. If important pages are missing, investigate the reason.
2. Select your property
3. Click "Pages" in the left sidebar
4. Review the "Indexed" vs "Not indexed" counts
5. Click each exclusion reason to see affected URLs
Fix duplicate website versions
Your site should not be accessible on http/https and www/non-www simultaneously. Pick one version and 301 redirect everything else.
RewriteEngine On
RewriteCond %{HTTPS} off [OR]
RewriteCond %{HTTP_HOST} !^www\. [NC]
RewriteRule ^(.*)$ https://www.yourdomain.com/$1 [R=301,L]
# Nginx equivalent:
server {
listen 80;
server_name yourdomain.com www.yourdomain.com;
return 301 https://www.yourdomain.com$request_uri;
}
Optimize robots.txt for search engines and AI crawlers
Ensure your robots.txt allows important crawlers (Googlebot, Bingbot, GPTBot, Claude-Web) while blocking unnecessary paths. Verify no critical pages are blocked.
Allow: /
Disallow: /admin/
Disallow: /login/
Disallow: /cart/
Disallow: /checkout/
User-agent: GPTBot
Allow: /
User-agent: Claude-Web
Allow: /
Sitemap: https://www.yourdomain.com/sitemap.xml
Fix redirect chains and loops
Every redirect should point directly to the final URL. Chains waste crawl budget and dilute authority. Use Screaming Frog or Semrush Site Audit to detect them.
# Good: A -> C (direct redirect)
# Screaming Frog: Configuration > Response Codes > check "Redirect Chains"
# Semrush: Site Audit > Issues > search "redirect chains"
Fix broken links (internal and external)
Broken links create poor user experiences and waste crawl budget. Check for 404s on both internal links and outbound links.
1. Enter your domain and start crawl
2. Filter by "Client Error (4xx)"
3. Export all 404 URLs
4. Fix: restore pages, set 301 redirects, or update links
# Using command line with curl:
for url in $(cat urls.txt); do
status=$(curl -o /dev/null -s -w "%{http_code}" $url)
echo "$url - $status"
done
Fix server errors (5xx)
5xx errors prevent crawling and indexing entirely. Check for 500, 502, 503 errors in GSC and server logs. These require developer attention.
grep " 5[0-9][0-9] " /var/log/nginx/access.log | tail -100
# Using GSC:
1. Go to Settings > Crawl stats
2. Review "Total crawl requests" and "Error rate"
3. Click "View crawl errors" for details
Submit XML sitemap to Google Search Console
A well-formed sitemap helps search engines discover all your important pages. Include only canonical URLs with appropriate priority and change frequency.
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
<url>
<loc>https://www.yourdomain.com/</loc>
<lastmod>2026-07-15</lastmod>
<changefreq>weekly</changefreq>
<priority>1.0</priority>
</url>
<url>
<loc>https://www.yourdomain.com/blog/</loc>
<lastmod>2026-07-10</lastmod>
<changefreq>daily</changefreq>
<priority>0.8</priority>
</url>
</urlset>
Check for orphan pages
Orphan pages have no internal links pointing to them. They are invisible to both users and crawlers. Find them and add internal links.
1. Export all URLs from GA that received traffic in last 90 days
2. Export all URLs from your XML sitemap
3. Cross-reference with Screaming Frog crawl
4. Any URL in GA/sitemap but not found in crawl = orphan
# Fix: Add contextual internal links from relevant parent pages
Optimize crawl budget
Google allocates limited crawl resources to each site. Prioritize important pages by blocking low-value URLs in robots.txt and consolidating thin content.
Settings > Crawl stats > Host status
# Block low-value pages in robots.txt:
Disallow: /tag/
Disallow: /category/
Disallow: /page/2/
Disallow: /*?sort=
Disallow: /*?filter=
# Use noindex on thin content pages
<meta name="robots" content="noindex, follow">
Use IndexNow for faster indexing
IndexNow is a protocol that instantly notifies search engines when content changes. Supported by Bing, Yandex, Naver, and Seznam. Send pings whenever you publish or update pages.
GET https://bing.com/IndexNow?url=https://www.yourdomain.com/new-page&key=your-key
# Or submit via API:
curl -X POST https://bing.com/IndexNow \
-H "Content-Type: application/json" \
-d '{"host":"www.yourdomain.com","key":"your-key","keyLocation":"https://www.yourdomain.com/your-key.txt","urlList":["https://www.yourdomain.com/new-page"]}'
Check pagination with rel next/prev
Paginated series (blog page 2, 3, etc.) should use rel="next" and rel="prev" to signal the relationship between pages. Google now largely handles this via canonical, but it still helps.
<link rel="next" href="https://www.yourdomain.com/blog/page/3/" />
<!-- On page 3 -->
<link rel="prev" href="https://www.yourdomain.com/blog/page/2/" />
<link rel="next" href="https://www.yourdomain.com/blog/page/4/" />
Monitor Google Search Console regularly
GSC is the single most important free tool for technical SEO. Check it at least weekly for new issues, index coverage changes, and manual actions.
1. Overview dashboard - click "Open Report" for each card
2. Performance - check for traffic drops
3. Pages - new indexing issues
4. Enhancements - Core Web Vitals status
5. Security & Manual Actions - critical alerts
Core Web Vitals and Performance 8 items
Optimize Largest Contentful Paint (LCP)
LCP measures how quickly the main content loads. Aim for under 2.5 seconds. The LCP element is usually a hero image, heading, or video poster.
<link rel="preload" as="image" href="/images/hero.webp" fetchpriority="high">
# Optimize image delivery
<img src="/images/hero.webp" width="1200" height="600"
fetchpriority="high" alt="Hero image">
# Remove render-blocking resources
<script defer src="/js/main.js"></script>
<link rel="preload" href="/fonts/inter.woff2" as="font" crossorigin>
Optimize Interaction to Next Paint (INP)
INP measures page responsiveness. Aim for under 200ms. Long tasks, heavy JavaScript, and slow event handlers cause poor INP.
<script defer src="/js/analytics.js"></script>
<script async src="/js/widget.js"></script>
# Break up long tasks
// Before: blocking for 100ms
function processItems(items) {
items.forEach(item => heavyProcess(item));
}
// After: yield to main thread
async function processItems(items) {
for (const item of items) {
heavyProcess(item);
await new Promise(r => setTimeout(r, 0));
}
}
Optimize Cumulative Layout Shift (CLS)
CLS measures visual stability. Aim for under 0.1. Elements shifting after load frustrate users. Always set explicit dimensions on images, ads, and embeds.
<img src="/image.webp" width="800" height="450" alt="">
# Reserve space for dynamic content
<div style="min-height: 250px;" id="ad-container"></div>
# Prevent layout shift from fonts
<link rel="preload" href="/fonts/inter.woff2" as="font" crossorigin>
<style>body { font-display: swap; }</style>
Minify CSS, JavaScript, and HTML
Minification removes unnecessary characters without changing functionality. Reduces file size by 20-50%.
npx terser input.js -o output.min.js --compress --mangle
# Using clean-css for CSS
npx cleancss -o style.min.css style.css
# Using html-minifier
npx html-minifier index.html -o index.min.html \
--remove-comments --collapse-whitespace
# Build tool approach (Webpack/Vite):
// webpack.config.js
module.exports = {
optimization: { minimize: true }
};
Enable browser caching
Browser caching stores static assets locally so returning visitors load pages faster. Set appropriate Cache-Control headers for different resource types.
<IfModule mod_expires.c>
ExpiresActive On
ExpiresByType image/webp "access plus 1 year"
ExpiresByType image/jpeg "access plus 1 year"
ExpiresByType text/css "access plus 1 month"
ExpiresByType application/javascript "access plus 1 month"
ExpiresByType font/woff2 "access plus 1 year"
</IfModule>
# Nginx config
location ~* \.(jpg|jpeg|png|webp|gif)$ {
expires 1y;
add_header Cache-Control "public, immutable";
}
location ~* \.(css|js)$ {
expires 1M;
add_header Cache-Control "public";
}
Use a Content Delivery Network (CDN)
CDNs serve your content from servers closest to the user, dramatically reducing latency. Cloudflare, Bunny CDN, and AWS CloudFront are popular options.
1. Add your domain to Cloudflare
2. Update nameservers
3. Enable "Proxied" (orange cloud)
4. Configure caching rules in Rules > Page Rules
# Key CDN features to enable:
- Automatic HTTPS rewrites
- Brotli compression
- Minification (Auto Minify)
- Rocket Loader (with caution)
Optimize images with next-gen formats
Use WebP or AVIF instead of JPEG/PNG for 25-50% smaller files. Implement lazy loading for below-the-fold images.
cwebp -q 80 input.jpg -o output.webp
# HTML with fallback
<picture>
<source srcset="/image.avif" type="image/avif">
<source srcset="/image.webp" type="image/webp">
<img src="/image.jpg" width="800" height="450"
loading="lazy" alt="Description">
</picture>
Reduce server response time (TTFB)
Time to First Byte should be under 200ms. Slow TTFB indicates server, database, or hosting issues. Upgrade hosting or optimize backend queries.
curl -o /dev/null -s -w "Connect: %{time_connect}\nTTFB: %{time_starttransfer}\nTotal: %{time_total}\n" https://www.yourdomain.com
# Server optimizations:
# Enable PHP OPcache
opcache.enable=1
opcache.memory_consumption=256
opcache.max_accelerated_files=20000
# Nginx fastcgi cache
fastcgi_cache_path /tmp/nginx_cache levels=1:2 keys_zone=mycache:10m;
fastcgi_cache mycache;
Site Architecture 7 items
Use flat URL structure
Keep URLs short and logical. Ideally every page is 1-3 clicks from the homepage. Deep hierarchies bury important content.
yourdomain.com/
yourdomain.com/blog/
yourdomain.com/blog/keyword-rich-post
yourdomain.com/services/
yourdomain.com/services/seo-audit
# Avoid deep nesting:
yourdomain.com/2026/07/15/blog/technical/seo/checklist # Too deep!
Create logical URL structure
URLs should be readable, include target keywords, and follow a consistent pattern. Use hyphens, not underscores.
/technical-seo-checklist
/how-to-improve-core-web-vitals
/services/seo-audit
# Bad URLs:
/p=123
/index.php?page_id=45
/2026/07/15/random-post-title
Implement breadcrumb navigation
Breadcrumbs show users where they are in the site hierarchy. They also create internal links and appear as rich snippets in search results.
<nav aria-label="Breadcrumb">
<ol itemscope itemtype="https://schema.org/BreadcrumbList">
<li itemprop="itemListElement" itemscope itemtype="https://schema.org/ListItem">
<a itemprop="item" href="/"><span itemprop="name">Home</span></a>
<meta itemprop="position" content="1">
</li>
<li itemprop="itemListElement" itemscope itemtype="https://schema.org/ListItem">
<a itemprop="item" href="/technical-seo"><span itemprop="name">Technical SEO</span></a>
<meta itemprop="position" content="2">
</li>
<li itemprop="itemListElement" itemscope itemtype="https://schema.org/ListItem">
<span itemprop="name">Technical SEO Checklist</span>
<meta itemprop="position" content="3">
</li>
</ol>
</nav>
Implement strategic internal linking
Internal links distribute authority across your site. Link from high-authority pages to important but underperforming pages. Use descriptive anchor text.
1. Link from your homepage to your most important content
2. Use topic clusters: pillar page linking to cluster content
3. Add contextual links in blog posts (2-5 per article)
4. Update old posts with links to new content
5. Use descriptive anchor text ("technical SEO checklist" not "click here")
Optimize navigation menus
Primary navigation should include your most important categories. Limit to 5-7 items. Use clear, descriptive labels. Include a logical dropdown structure.
1. Most important pages get top-level placement
2. Secondary pages go in dropdowns (max 2 levels deep)
3. Use keywords in navigation labels
4. Include a search bar for large sites
5. Mobile: use hamburger menu with full hierarchy
Fix orphan pages
Any page with zero internal links pointing to it is an orphan. These pages cannot be found by crawlers or users. Add internal links from relevant parent pages.
1. Crawl your site
2. Go to "Bulk Export" > "HTML" > "All Inlinks"
3. Find pages with 0 inlinks (except from sitemap)
# Fix: add contextual links
Example: If your "Core Web Vitals guide" page is orphaned,
add a link from your "Technical SEO Checklist" page.
Create HTML sitemap for users
An HTML sitemap helps users navigate your site. Unlike XML sitemaps (for search engines), HTML sitemaps are visible on your site and link to all important pages.
<h1>Sitemap</h1>
<h2>Main Pages</h2>
<ul>
<li><a href="/">Home</a></li>
<li><a href="/about">About</a></li>
</ul>
<h2>Blog Categories</h2>
<ul>
<li><a href="/technical-seo">Technical SEO</a></li>
<li><a href="/content-marketing">Content Marketing</a></li>
</ul>
Structured Data & Schema 6 items
Add Organization schema to homepage
Organization schema tells search engines your business name, logo, URL, and social profiles. This powers the knowledge panel.
"@context": "https://schema.org",
"@type": "Organization",
"name": "Your Business Name",
"url": "https://yourdomain.com",
"logo": "https://yourdomain.com/logo.png",
"sameAs": [
"https://linkedin.com/company/yourprofile",
"https://twitter.com/yourprofile"
]
}
Implement Article schema on blog posts
Article schema helps Google understand your content and can enable rich results like headline and published date.
"@context": "https://schema.org",
"@type": "Article",
"headline": "Your Post Title",
"author": {
"@type": "Person",
"name": "Author Name"
},
"datePublished": "2026-01-15",
"description": "Short meta description"
}
Add BreadcrumbList schema
Breadcrumb schema produces rich breadcrumb trails in search results, improving click-through rates.
"@context": "https://schema.org",
"@type": "BreadcrumbList",
"itemListElement": [{
"@type": "ListItem",
"position": 1,
"name": "Home",
"item": "https://yourdomain.com"
}, {
"@type": "ListItem",
"position": 2,
"name": "Category",
"item": "https://yourdomain.com/category"
}]
}
Add FAQ schema to FAQ pages
FAQ schema enables expandable rich results in search, which can double your visibility on the SERP.
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [{
"@type": "Question",
"name": "Your question?",
"acceptedAnswer": {
"@type": "Answer",
"text": "Your answer."
}
}]
}
Add HowTo schema for tutorials
HowTo schema displays steps, images, and estimated time in search results. Excellent for process-oriented content.
"@context": "https://schema.org",
"@type": "HowTo",
"name": "How to do something",
"step": [{
"@type": "HowToStep",
"position": 1,
"text": "First step description"
}]
}
Test all schema with Rich Results Test
Always validate your JSON-LD with Google's Rich Results Test. Invalid schema is ignored and may cause warnings in GSC.
1. Google Rich Results Test: https://search.google.com/test/rich-results
2. Schema Markup Validator: https://validator.schema.org/
3. GSC > Enhancements > All reports for warnings
# Common mistakes to fix:
- Missing required fields
- Wrong @type values
- Duplicate schema on the same page
- Schema on wrong pages (e.g., FAQ schema on non-FAQ content)
Security & HTTPS 4 items
Enable HTTPS with a valid SSL certificate
HTTPS is a confirmed ranking signal. All pages must serve over HTTPS without mixed content warnings. Use Let's Encrypt for free certificates.
Settings > Crawl stats > HTTPS
# Fix mixed content in .htaccess:
Header always set Content-Security-Policy "upgrade-insecure-requests"
# Verify in browser:
Click the padlock icon in the address bar
Redirect HTTP to HTTPS
All traffic to http:// must permanently redirect (301) to https://. This prevents duplicate content and ensures security.
RewriteEngine On
RewriteCond %{HTTPS} off
RewriteRule ^(.*)$ https://%{HTTP_HOST}/$1 [R=301,L]
# Nginx:
server {
listen 80;
server_name yourdomain.com;
return 301 https://$server_name$request_uri;
}
# Cloudflare: Enable "Always Use HTTPS" in SSL/TLS > Edge Certificates
Implement security headers
Security headers protect your site and visitors. Key headers include HSTS, CORS, and X-Frame-Options.
Strict-Transport-Security: max-age=31536000; includeSubDomains
X-Content-Type-Options: nosniff
X-Frame-Options: DENY
Referrer-Policy: strict-origin-when-cross-origin
# Test your headers:
curl -I https://yourdomain.com | grep -i strict
Or use: https://securityheaders.com
Fix broken internal links and 4xx errors
Broken links create poor user experience and waste crawl budget. A 404 page should still exist but be helpful.
1. Crawl your site
2. Filter Response Codes to 4xx
3. Note each broken URL and its linking page
# Fix options:
1. Update/replace the broken link URL
2. Redirect to a working page (301)
3. If content is gone, redirect to a related page
# Custom 404 page tips:
- Show a helpful message
- Include search bar
- Link to popular pages or sitemap
Mobile & User Experience 5 items
Check mobile responsiveness across devices
Google uses mobile-first indexing. Every page must work well on all screen sizes. Use Chrome DevTools to test.
1. Right-click > Inspect
2. Toggle Device Toolbar (Ctrl+Shift+M)
3. Test at 320px, 375px, 768px, 1024px widths
4. Check text readability, button sizes, touch targets
# Google Mobile-Friendly Test:
https://search.google.com/test/mobile-friendly
Optimize tap targets for touch screens
Buttons and links must be at least 48x48 pixels with adequate spacing. Small tap targets frustrate mobile users.
button, a, .tap-target {
min-width: 48px;
min-height: 48px;
margin: 4px;
}
# Check in GSC:
Mobile Usability report > "Clickable elements too close together"
Set proper viewport meta tag
The viewport meta tag controls how your page renders on mobile. Without it, mobile browsers scale the page as if on desktop.
# Common mistakes:
- Missing viewport tag entirely
- Using maximum-scale=1 (prevents zooming, accessibility issue)
- Setting fixed width (e.g., width=1024)
Ensure readable font sizes on mobile
Body text should be at least 16px on mobile. Smaller fonts force zooming and create poor user experience.
html { font-size: 100%; } /* 16px default */
body { font-size: 1rem; }
h1 { font-size: 1.75rem; }
h2 { font-size: 1.375rem; }
# Avoid:
- Using px for font sizes (no responsive scaling)
- Text inside images for critical content
- Font sizes below 14px on any breakpoint
Eliminate intrusive interstitials on mobile
Popups and overlays that cover the main content hurt rankings, especially on mobile. Google penalizes intrusive interstitials.
- Cookie consent banners (non-blocking)
- Age verification (legal requirement)
- Small, dismissible banners (e.g., 15% of screen)
# Avoid:
- Full-screen popups on first visit
- Popups that appear immediately on page load
- Popups you cannot dismiss within 5 seconds
- Overlays covering more than 30% of viewport
AI Search & GEO Optimization 6 items
Check robots.txt allows AI crawlers
AI search engines (GPTBot, Claude-Web, PerplexityBot) must be allowed to crawl your content. Check that your robots.txt does not block them.
User-agent: GPTBot
Allow: /
User-agent: Claude-Web
Allow: /
User-agent: PerplexityBot
Allow: /
# To check: visit yourdomain.com/robots.txt
Structure content for AI extraction
AI models extract answers from well-structured HTML. Use semantic headings, lists, tables, and concise paragraph structures.
<h1>Primary topic</h1>
<p>Direct answer to the core question (1-2 sentences)</p>
<h2>Subtopic 1</h2>
<ul><li>Specific point with data</li></ul>
<h2>Subtopic 2</h2>
<table><tr><td>Comparison data</td></tr></table>
Create llms.txt file
llms.txt provides AI models with a curated guide to your most important content. It is becoming the standard for AI discovery.
# Content structure:
# Title
> Your Site Name
# About
> Brief description of your site
# Core pages
- [Page Title](https://yourdomain.com/page): Description
- [Another Page](https://yourdomain.com/another): Description
Add citation-friendly anchor text
AI search engines cite sources by extracting quotes and attributions. Use clear, descriptive anchor text that works standalone.
# Good: "According to [Site Name], technical SEO is..."
# Bad: "Click here to learn more"
# Internal linking for citations:
1. Link to specific sections using anchor IDs
2. Use descriptive link text: "LCP should be under 2.5 seconds per Google"
3. Avoid generic CTAs as anchor text
Optimize for zero-click SERP features
AI-powered search often delivers direct answers. Structuring your content for featured snippets increases the chance of AI citation.
1. Put the direct answer in the first paragraph (definition-style)
2. Use numbered lists for step-by-step processes
3. Use bullet lists for comparisons or features
4. Create dedicated FAQ sections with Q&A pairs
5. Add data points and statistics in a table format
Monitor AI search presence and citations
Track whether your content appears in AI-generated answers. Tools and manual checks help you understand your AI visibility.
1. Ask ChatGPT/Claude/Perplexity questions about your topic
2. Search your brand on AI search engines
3. Use tools like Brand24 or Mention for citation tracking
# Key signals AI visibility is improving:
- Your site linked in AI answers
- Increased referral traffic from AI platforms
- Brand mentions in AI-generated content
Download the Checklist
Get the complete technical SEO checklist as a printable PDF. Includes all 60+ items, code examples, and audit schedule.
Frequently Asked Questions
Common questions about technical SEO checklists and audits.
A technical SEO checklist is a structured list of checks and fixes that ensure search engines can crawl, index, and render your website properly. It covers areas like robots.txt, XML sitemaps, site speed, mobile usability, structured data, and site architecture.
Run basic checks weekly (index coverage, crawl errors, traffic drops), a medium audit monthly (Core Web Vitals, broken links, sitemaps), and a full audit quarterly (redirect chains, orphan pages, schema, security headers).
Not for all tasks. You can check index coverage, find broken links, and run performance tests using free tools like Google Search Console and PageSpeed Insights without coding. Server-level fixes (redirects, caching headers, CDN setup) typically require a developer.
Technical SEO focuses on website infrastructure: crawling, indexing, speed, security, and structure. On-page SEO focuses on content: keywords, meta tags, headings, and internal linking. Both are essential for ranking. Technical SEO comes first because search engines cannot rank content they cannot find.
AI systems like ChatGPT and Perplexity rely on the same crawl and index infrastructure as Google. If your robots.txt blocks AI crawlers, or your HTML is poorly structured, AI systems cannot access or use your content. Clean technical SEO directly improves your chances of being cited in AI-generated answers.
Free tools: Google Search Console, Google PageSpeed Insights, Screaming Frog (free tier), Bing Webmaster Tools. Paid tools: Semrush Site Audit, Ahrefs Site Audit, Sitebulb, DeepCrawl. Start with free tools and upgrade when you need deeper analysis.