# technical-seo > Technical SEO is the process of optimizing a website for crawling and indexing by search engines. This guide covers all aspects of technical SEO implementation. - Author: GitHub Action - Repository: AmnadTaowsoam/CerebraSkills - Version: 20260130093005 - Stars: 1 - Forks: 0 - Last Updated: 2026-02-07 - Source: https://github.com/AmnadTaowsoam/CerebraSkills - Web: https://mule.run/skillshub/@@AmnadTaowsoam/CerebraSkills~technical-seo:20260130093005 --- # Technical SEO ## Overview Technical SEO is the process of optimizing a website for crawling and indexing by search engines. This guide covers all aspects of technical SEO implementation. --- ## 1. SEO Fundamentals ### How Search Engines Work ```markdown # Search Engine Crawling Process ## 1. Discovery - Search engines find URLs through: - Links from other pages - Sitemaps - Direct submission - Social media links ## 2. Crawling - Bots (spiders) visit pages - Download page content - Follow links to other pages - Respect robots.txt rules - Follow crawl-delay rules ## 3. Processing - Extract content from HTML - Parse structured data - Identify key elements - Process images and media - Extract links ## 4. Indexing - Store page in database - Analyze content and context - Rank for relevant queries - Update search index - Remove outdated content ## 5. Ranking - Match query to indexed pages - Apply ranking algorithms - Consider 200+ ranking factors - Return relevant results - Personalize for user ``` ### Key SEO Concepts ```markdown # SEO Concepts ## Indexing vs. Crawling ### Crawling - Search engine bots visiting your site - Following links to discover pages - Downloading page content - Happens before indexing ### Indexing - Adding pages to search database - Making pages available in search results - Happens after crawling - Not all crawled pages are indexed ## Organic vs. Paid Search ### Organic Search - Free search results - Based on relevance and quality - Long-term sustainable - Requires SEO optimization ### Paid Search (PPC) - Advertisements in search results - Based on bid amount and quality - Immediate results - Requires ongoing payment ## On-Page vs. Off-Page SEO ### On-Page SEO - Content optimization - Technical optimization - User experience - Under your control ### Off-Page SEO - Backlinks - Social signals - Brand mentions - Outside your control ## White Hat vs. Black Hat SEO ### White Hat SEO - Follows search engine guidelines - Focuses on user value - Long-term sustainable - Recommended approach ### Black Hat SEO - Violates search engine guidelines - Focuses on manipulating rankings - Short-term gains - Risk of penalties ``` --- ## 2. Crawlability and Indexability ### Crawlability ```markdown # Crawlability Optimization ## What is Crawlability? Ability of search engine bots to discover and access your website content. ## Crawlability Best Practices ### 1. Site Structure - Clear navigation hierarchy - Logical URL structure - Internal linking - Sitemap submission ### 2. Robots.txt - Allow crawling of important pages - Block unnecessary pages - Specify crawl-delay - Point to sitemap ### 3. Server Response - Fast server response times - Proper HTTP status codes - Handle errors gracefully - Avoid server errors ### 4. JavaScript Rendering - Server-side rendering preferred - Progressive enhancement - Avoid blocking resources - Test with Google tools ### 5. URL Parameters - Use canonical URLs - Avoid duplicate content - Handle parameters correctly - Use URL rewriting ## Crawl Budget Optimization ### What is Crawl Budget? Number of pages search engine will crawl on your site per day. ### Factors Affecting Crawl Budget - Site size - Site authority - Update frequency - Server performance - Number of errors ### Optimization Tips - Fix crawl errors - Improve site speed - Remove duplicate content - Prioritize important pages - Use sitemaps ``` ### Indexability ```markdown # Indexability Optimization ## What is Indexability? Ability of search engines to add your pages to their search index. ## Indexability Best Practices ### 1. Meta Robots Tag ```html ``` ### 2. Canonical Tags ```html ``` ### 3. Noindex Rules - Use for: - Duplicate content - Test pages - Admin pages - Thin content - Search result pages ### 4. Index Status Monitoring - Use Google Search Console - Check "Coverage" report - Monitor "Indexed, not submitted" - Fix indexing errors ### 5. Freshness - Update content regularly - Add new content - Remove outdated content - Update publication dates ``` --- ## 3. URL Structure ### Best Practices ```markdown # URL Structure Best Practices ## URL Characteristics ### Good URLs ``` https://example.com/blog/how-to-optimize-seo https://example.com/products/red-shoes https://example.com/category/electronics/laptops ``` ### Bad URLs ``` https://example.com/p=123 https://example.com/2023/01/15/article?id=456 https://example.com/products?category=shoes&color=red ``` ## URL Best Practices ### 1. Keep it Short - Aim for 50-60 characters - Remove unnecessary words - Use concise language - Focus on keywords ### 2. Use Hyphens - Use hyphens to separate words - Never use underscores - Avoid special characters - Keep it lowercase ### 3. Include Keywords - Use target keyword - Keep it natural - Don't overstuff - Focus on user intent ### 4. Use HTTPS - Secure your site - Boost rankings - Build trust - Required for modern browsers ### 5. Avoid Parameters - Use clean URLs - Rewrite dynamic URLs - Use URL routing - Avoid session IDs ## URL Structure Examples ### E-commerce ``` /products/category/product-name /products/shoes/red-running-shoes /products/electronics/laptops ``` ### Blog ``` /blog/year/month/post-title /blog/2023/12/how-to-optimize-seo /blog/category/seo-tips ``` ### Service Pages ``` /services/service-name /services/web-development /services/digital-marketing ``` ``` ### URL Rewriting ```markdown # URL Rewriting ## Apache (.htaccess) ```apache # Remove .php extension RewriteEngine On RewriteCond %{REQUEST_FILENAME} !-d RewriteCond %{REQUEST_FILENAME}.php -f RewriteRule ^(.*)$ $1.php [L] # Remove trailing slash RewriteCond %{REQUEST_FILENAME} !-d RewriteCond %{REQUEST_URI} (.+)/$ RewriteRule ^ %1 [L,R=301] # Force HTTPS RewriteCond %{HTTPS} off RewriteRule ^(.*)$ https://%{HTTP_HOST}%{REQUEST_URI} [L,R=301] # Remove www RewriteCond %{HTTP_HOST} ^www\.(.*)$ [NC] RewriteRule ^(.*)$ https://%1/$1 [R=301,L] ``` ## Nginx ```nginx # Remove .php extension location ~ \.php$ { try_files $uri =404; fastcgi_pass unix:/var/run/php/php7.4-fpm.sock; fastcgi_index index.php; include fastcgi_params; } # Remove trailing slash rewrite ^/(.*)/$ /$1 permanent; # Force HTTPS if ($scheme != "https") { return 301 https://$host$request_uri; } # Remove www if ($host ~* ^www\.(.*)) { set $host_without_www $1; rewrite ^(.*)$ https://$host_without_www$1 permanent; } ``` ## Next.js (next.config.js) ```javascript module.exports = { async rewrites() { return [ { source: '/old-path/:path*', destination: '/new-path/:path*', }, ]; }, }; ``` ``` --- ## 4. HTTPS and Security ### HTTPS Implementation ```markdown # HTTPS Implementation ## Why HTTPS Matters for SEO ### Ranking Factor - Google uses HTTPS as ranking signal - Secure sites rank higher - Required for modern features - Builds user trust ### Security Benefits - Encrypts data in transit - Protects user privacy - Prevents data tampering - Required for payment processing ## Implementation Steps ### 1. Get SSL Certificate - Let's Encrypt (free) - Commercial certificate - Wildcard certificate - Multi-domain certificate ### 2. Install Certificate - On server - Configure web server - Test SSL configuration - Verify installation ### 3. Force HTTPS - Redirect HTTP to HTTPS - Update internal links - Update sitemaps - Update canonical tags ### 4. Update External Links - Update backlinks if possible - Update social media profiles - Update directory listings - Update marketing materials ## Server Configuration ### Apache ```apache ServerName example.com DocumentRoot /var/www/html SSLEngine on SSLCertificateFile /path/to/cert.pem SSLCertificateKeyFile /path/to/key.pem SSLCertificateChainFile /path/to/chain.pem ServerName example.com Redirect permanent / https://example.com/ ``` ### Nginx ```nginx server { listen 443 ssl http2; server_name example.com; ssl_certificate /path/to/cert.pem; ssl_certificate_key /path/to/key.pem; ssl_protocols TLSv1.2 TLSv1.3; ssl_ciphers HIGH:!aNULL:!MD5; root /var/www/html; } server { listen 80; server_name example.com; return 301 https://$server_name$request_uri; } ``` ## Mixed Content - Fix mixed content warnings - Update HTTP resources to HTTPS - Use protocol-relative URLs - Test with browser dev tools ``` ### Security Headers ```markdown # Security Headers ## Essential Security Headers ### 1. X-Frame-Options ```http X-Frame-Options: DENY ``` Prevents clickjacking attacks ### 2. X-Content-Type-Options ```http X-Content-Type-Options: nosniff ``` Prevents MIME-type sniffing ### 3. X-XSS-Protection ```http X-XSS-Protection: 1; mode=block ``` Enables XSS filtering ### 4. Content-Security-Policy ```http Content-Security-Policy: default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval'; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; font-src 'self' data:; ``` Controls resource loading ### 5. Strict-Transport-Security ```http Strict-Transport-Security: max-age=31536000; includeSubDomains ``` Enforces HTTPS connections ## Implementation ### Apache (.htaccess) ```apache Header set X-Frame-Options "DENY" Header set X-Content-Type-Options "nosniff" Header set X-XSS-Protection "1; mode=block" Header set Content-Security-Policy "default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval'; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; font-src 'self' data:;" Header set Strict-Transport-Security "max-age=31536000; includeSubDomains" ``` ### Nginx ```nginx add_header X-Frame-Options "DENY" always; add_header X-Content-Type-Options "nosniff" always; add_header X-XSS-Protection "1; mode=block" always; add_header Content-Security-Policy "default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval'; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; font-src 'self' data:;" always; add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always; ``` ## Testing - Use securityheaders.com - Use Mozilla Observatory - Test with browser dev tools - Check with online scanners ``` --- ## 5. Mobile-First Indexing ### Mobile-First Indexing ```markdown # Mobile-First Indexing ## What is Mobile-First Indexing? Google primarily uses the mobile version of your site for indexing and ranking. ## Why It Matters - Mobile traffic > desktop - Google's default approach - Affects all sites - Requires mobile-friendly design ## Implementation Requirements ### 1. Responsive Design - Use CSS media queries - Flexible layouts - Scalable images - Touch-friendly navigation ### 2. Mobile-Friendly Content - Readable text size - Adequate spacing - No horizontal scrolling - Accessible buttons ### 3. Mobile Performance - Fast loading on mobile - Optimized images - Minimal JavaScript - Efficient CSS ### 4. Mobile SEO - Mobile sitemap - Mobile-specific content - Mobile-friendly meta tags - Mobile-optimized structured data ## Testing Tools - Google Mobile-Friendly Test - Chrome DevTools Device Mode - Responsive design checker - Mobile performance tools ``` ### Responsive Design ```markdown # Responsive Design for SEO ## Viewport Meta Tag ```html ``` ## Media Queries ```css /* Mobile First Approach */ .container { width: 100%; padding: 1rem; } /* Tablet */ @media (min-width: 768px) { .container { width: 750px; margin: 0 auto; } } /* Desktop */ @media (min-width: 1024px) { .container { width: 960px; margin: 0 auto; } } /* Large Desktop */ @media (min-width: 1200px) { .container { width: 1140px; margin: 0 auto; } } ``` ## Responsive Images ```html Description Description ``` ## Touch-Friendly Design ```css /* Minimum touch target size */ .button { min-height: 44px; min-width: 44px; padding: 12px 24px; } /* Spacing between touch targets */ .button + .button { margin-top: 16px; } /* No hover on touch devices */ @media (hover: none) { .button:hover { /* No hover effect */ } } ``` ``` --- ## 6. Page Speed Optimization ### Core Speed Metrics ```markdown # Page Speed Optimization ## Key Metrics ### Time to First Byte (TTFB) - Target: < 200ms - Measures server response time - Affects all other metrics - Critical for user experience ### First Contentful Paint (FCP) - Target: < 1.8s - First content rendered - User perceives loading started - Important for perceived speed ### Largest Contentful Paint (LCP) - Target: < 2.5s - Largest element rendered - Main content visible - Core Web Vital ### First Input Delay (FID) - Target: < 100ms - Time to first interaction - Responsiveness metric - Core Web Vital ### Cumulative Layout Shift (CLS) - Target: < 0.1 - Visual stability - Layout shifts - Core Web Vital ``` ### Optimization Techniques ```markdown # Speed Optimization Techniques ## 1. Minification ### HTML Minification ```bash # Using html-minifier html-minifier --collapse-whitespace --remove-comments --minify-css true --minify-js true index.html -o index.min.html ``` ### CSS Minification ```bash # Using cssnano npx cssnano styles.css styles.min.css ``` ### JavaScript Minification ```bash # Using terser npx terser script.js -o script.min.js ``` ## 2. Compression ### Gzip Compression ```apache # Apache AddOutputFilterByType DEFLATE text/html text/plain text/xml text/css text/javascript application/javascript application/xml+rss application/json ``` ```nginx # Nginx gzip on; gzip_types text/html text/plain text/xml text/css text/javascript application/javascript application/xml+rss application/json; gzip_min_length 1000; ``` ### Brotli Compression ```nginx # Nginx brotli on; brotli_types text/html text/plain text/xml text/css text/javascript application/javascript application/xml+rss application/json; brotli_comp_level 6; ``` ## 3. Caching ### Browser Caching ```apache # Apache ExpiresActive On ExpiresByType image/jpg "access plus 1 year" ExpiresByType image/jpeg "access plus 1 year" ExpiresByType image/gif "access plus 1 year" ExpiresByType image/png "access plus 1 year" ExpiresByType text/css "access plus 1 month" ExpiresByType application/javascript "access plus 1 month" ``` ```nginx # Nginx location ~* \.(jpg|jpeg|png|gif|ico|css|js)$ { expires 1y; add_header Cache-Control "public, immutable"; } ``` ## 4. Image Optimization ### Lazy Loading ```html Description ``` ### Modern Formats ```html Description ``` ## 5. Code Splitting ```javascript // Dynamic import const module = await import('./module.js'); // React lazy loading const Component = React.lazy(() => import('./Component')); ``` ## 6. Critical CSS ```html ``` ``` --- ## 7. Core Web Vitals ### LCP (Largest Contentful Paint) ```markdown # LCP Optimization ## What is LCP? Time it takes for the largest content element to become visible. ## Target - Good: < 2.5s - Needs Improvement: 2.5s - 4s - Poor: > 4s ## Optimization Strategies ### 1. Optimize Images - Use modern formats (WebP, AVIF) - Compress images - Use responsive images - Lazy load below-the-fold ### 2. Remove Blocking Resources - Defer non-critical CSS - Defer non-critical JavaScript - Inline critical CSS - Use async/defer for scripts ### 3. Improve Server Response - Use CDN - Optimize server configuration - Use HTTP/2 or HTTP/3 - Cache responses ### 4. Preload Important Resources ```html ``` ``` ### FID (First Input Delay) ```markdown # FID Optimization ## What is FID? Time from user's first interaction to when browser can respond. ## Target - Good: < 100ms - Needs Improvement: 100ms - 300ms - Poor: > 300ms ## Optimization Strategies ### 1. Reduce JavaScript Execution - Minimize main thread work - Use code splitting - Remove unused JavaScript - Optimize long tasks ### 2. Defer Non-Critical JavaScript ```html ``` ### 3. Use Web Workers ```javascript // Offload work to web worker const worker = new Worker('worker.js'); worker.postMessage(data); ``` ### 4. Optimize Event Handlers - Use event delegation - Debounce/throttle handlers - Avoid long-running handlers ``` ### CLS (Cumulative Layout Shift) ```markdown # CLS Optimization ## What is CLS? Measure of visual stability during page load. ## Target - Good: < 0.1 - Needs Improvement: 0.1 - 0.25 - Poor: > 0.25 ## Optimization Strategies ### 1. Reserve Space for Images ```html Description ``` ### 2. Reserve Space for Ads ```css .ad-container { min-height: 250px; width: 300px; } ``` ### 3. Avoid Injected Content - Don't insert content above existing content - Use skeleton screens - Load content in place ### 4. Use CSS Transitions ```css .element { transition: all 0.3s ease; } ``` ``` --- ## 8. Structured Data ### Schema.org Implementation ```markdown # Structured Data ## What is Structured Data? Code that helps search engines understand your content better. ## Benefits - Rich snippets in search results - Better search result appearance - Improved click-through rates - Enhanced search engine understanding ## Common Schema Types ### 1. Organization ```html ``` ### 2. Article ```html ``` ### 3. Product ```html ``` ### 4. BreadcrumbList ```html ``` ``` --- ## 9. XML Sitemaps ### Sitemap Creation ```markdown # XML Sitemaps ## What is a Sitemap? XML file that lists all important pages on your website. ## Benefits - Helps search engines discover pages - Provides metadata about pages - Indicates update frequency - Specifies page priority ## Sitemap Format ### Basic Sitemap ```xml https://example.com/ 2023-12-01 daily 1.0 https://example.com/page1 2023-12-01 weekly 0.8 ``` ### Sitemap Index (for large sites) ```xml https://example.com/sitemap1.xml 2023-12-01 https://example.com/sitemap2.xml 2023-12-01 ``` ## Sitemap Best Practices ### 1. Size Limits - Maximum 50,000 URLs per sitemap - Maximum 50MB file size - Use sitemap index for larger sites ### 2. Priority Values - 1.0: Most important (homepage) - 0.8: High priority - 0.5: Medium priority - 0.3: Low priority - 0.1: Least important ### 3. Change Frequency - always: Changes on every access - hourly: Changes hourly - daily: Changes daily - weekly: Changes weekly - monthly: Changes monthly - yearly: Changes yearly - never: Archived content ## Sitemap Submission - Submit to Google Search Console - Submit to Bing Webmaster Tools - Add to robots.txt - Ping search engines ``` --- ## 10. Robots.txt ### Robots.txt Configuration ```markdown # Robots.txt ## What is robots.txt? File that tells search engine bots which pages to crawl. ## Location - Must be at root: https://example.com/robots.txt - Case-sensitive - Must be accessible ## Basic Syntax ### Allow All ``` User-agent: * Allow: / ``` ### Block All ``` User-agent: * Disallow: / ``` ### Block Specific Paths ``` User-agent: * Disallow: /admin/ Disallow: /private/ Disallow: /temp/ ``` ### Allow Specific Bot ``` User-agent: Googlebot Allow: / User-agent: * Disallow: / ``` ## Advanced Directives ### Crawl-Delay ``` User-agent: * Crawl-delay: 1 ``` ### Sitemap Location ``` Sitemap: https://example.com/sitemap.xml Sitemap: https://example.com/sitemap2.xml ``` ### Wildcards ``` User-agent: * Disallow: /*.pdf$ Disallow: /admin/*/ Disallow: /temp/*.html ``` ## Best Practices - Test with Google tools - Use specific directives - Don't block important content - Keep it simple - Update regularly ``` --- ## 11. Canonical Tags ### Canonical Implementation ```markdown # Canonical Tags ## What are Canonical Tags? HTML tags that tell search engines the preferred version of a page. ## Why Use Canonical Tags? - Prevent duplicate content issues - Consolidate link equity - Specify preferred URL - Handle URL parameters ## Implementation ### Self-Referencing Canonical ```html ``` ### Cross-Domain Canonical ```html ``` ### Dynamic Canonical ```html ``` ### HTTP Canonical Header ```http Link: ; rel="canonical" ``` ## Best Practices ### 1. Absolute URLs ```html ``` ### 2. One Canonical Per Page ```html ``` ### 3. Consistent - Use same canonical across all versions - Include in HTTP header - Use absolute URLs - Point to accessible page ## Common Use Cases ### 1. URL Parameters ```html ``` ### 2. Mobile vs. Desktop ```html ``` ### 3. HTTPS vs. HTTP ```html ``` ``` --- ## 12. Hreflang Tags ### Hreflang Implementation ```markdown # Hreflang Tags ## What are Hreflang Tags? HTML attributes that tell search engines about language and regional targeting. ## Why Use Hreflang Tags? - Target specific languages - Target specific regions - Prevent duplicate content - Serve correct content ## Implementation ### HTML Head ```html ``` ### HTTP Header ```http Link: ; rel="alternate"; hreflang="en, ; rel="alternate"; hreflang="en-US", ; rel="alternate"; hreflang="es, ; rel="alternate"; hreflang="x-default" ``` ### XML Sitemap ```xml https://example.com/en/page ``` ## Language Codes ### Common Codes - en: English (general) - en-US: English (United States) - en-GB: English (United Kingdom) - es: Spanish (general) - fr: French (general) - de: German (general) - zh: Chinese (general) - ja: Japanese (general) ## Best Practices - Use correct language codes - Use x-default for default - Keep URLs consistent - Test with Google tools - Update regularly ``` --- ## 13. Internal Linking ### Internal Linking Strategy ```markdown # Internal Linking ## Why Internal Links Matter - Helps search engines discover pages - Distributes link equity - Establishes site hierarchy - Improves user navigation ## Best Practices ### 1. Link Structure - Create logical hierarchy - Use descriptive anchor text - Link to related content - Avoid broken links ### 2. Anchor Text - Use descriptive text - Include keywords naturally - Avoid generic text - Keep it concise ### 3. Link Placement - Link within content - Add navigation links - Use footer links - Include breadcrumb links ### 4. Link Quantity - Quality over quantity - Relevant links only - Avoid over-linking - Natural link distribution ## Link Types ### Navigation Links ```html ``` ### Contextual Links ```html

Learn more about our web development services.

``` ### Breadcrumb Links ```html ``` ### Footer Links ```html ``` ``` --- ## 14. Image Optimization ### Image SEO Best Practices ```markdown # Image Optimization ## Image SEO Checklist ### 1. File Names - Use descriptive names - Include keywords - Use hyphens - Keep it short ### Good Names ``` red-running-shoes.jpg seo-optimization-guide.jpg company-logo.png ``` ### Bad Names ``` IMG_1234.jpg image1.png photo.jpg ``` ### 2. Alt Text - Describe image content - Include keywords naturally - Keep it concise - Use empty alt for decorative images ```html Red running shoes on white background ``` ### 3. File Size - Compress images - Use appropriate format - Optimize dimensions - Remove metadata ### 4. Modern Formats - Use WebP when possible - Use AVIF when supported - Provide fallbacks - Test compatibility ```html Description ``` ### 5. Responsive Images - Use srcset attribute - Use sizes attribute - Provide multiple sizes - Use lazy loading ```html Description ``` ### 6. Image Sitemaps ```xml https://example.com/page https://example.com/image.jpg Image caption Image title ``` ``` --- ## 15. Technical SEO Checklist ### Comprehensive Checklist ```markdown # Technical SEO Checklist ## Crawlability - [ ] Robots.txt properly configured - [ ] XML sitemap created and submitted - [ ] Sitemap points to important pages - [ ] No crawl errors in Search Console - [ ] Internal linking structure is clear - [ ] No broken internal links - [ ] No broken external links ## Indexability - [ ] Meta robots tags correct - [ ] Noindex on appropriate pages - [ ] Canonical tags implemented - [ ] No duplicate content issues - [ ] Pages are indexed in Search Console - [ ] Index coverage is good ## URL Structure - [ ] URLs are clean and descriptive - [ ] URLs use hyphens - [ ] URLs are lowercase - [ ] No unnecessary parameters - [ ] HTTPS implemented - [ ] www/non-www redirect configured ## Mobile - [ ] Site is mobile-friendly - [ ] Viewport meta tag present - [ ] Responsive design implemented - [ ] Mobile performance is good - [ ] Touch targets are adequate - [ ] No horizontal scrolling ## Page Speed - [ ] LCP < 2.5s - [ ] FID < 100ms - [ ] CLS < 0.1 - [ ] Images optimized - [ ] CSS and JS minified - [ ] Browser caching enabled - [ ] Gzip/Brotli compression enabled - [ ] CDN configured ## Security - [ ] HTTPS implemented - [ ] SSL certificate valid - [ ] Security headers configured - [ ] No mixed content - [ ] No security vulnerabilities ## Structured Data - [ ] Schema markup implemented - [ ] Structured data is valid - [ ] Rich snippets appearing in SERPs - [ ] No errors in Structured Data Testing Tool ## International - [ ] Hreflang tags implemented (if applicable) - [ ] Language-specific URLs - [ ] Region-specific URLs (if applicable) - [ ] Correct language codes used ## Content - [ ] Title tags optimized - [ ] Meta descriptions optimized - [ ] H1 tags present - [ ] Heading hierarchy correct - [ ] Content is unique - [ ] Content is valuable - [ ] Keyword usage is natural ## Technical - [ ] No 404 errors - [ ] No 5xx errors - [ ] Redirects configured correctly - [ ] Server response time < 200ms - [ ] DNS is fast - [ ] No blocking resources ``` --- ## Testing Tools ### Essential Tools ```markdown # SEO Testing Tools ## Google Tools ### Google Search Console - Index coverage - Mobile usability - Core Web Vitals - Manual actions - Links report ### PageSpeed Insights - Performance scores - Core Web Vitals - Optimization suggestions - Mobile and desktop scores ### Rich Results Test - Structured data validation - Rich snippet preview - Schema markup testing ### Mobile-Friendly Test - Mobile usability check - Page rendering - Touch targets - Text readability ## Third-Party Tools ### Screaming Frog - Site crawl - Technical audit - Link analysis - Duplicate content ### Ahrefs - Backlink analysis - Keyword research - Content gap analysis - Competitor analysis ### SEMrush - Site audit - Keyword tracking - Backlink analysis - Content optimization ### Moz - Domain authority - Keyword research - Site crawl - Link analysis ## Browser Tools ### Chrome DevTools - Performance analysis - Network analysis - Lighthouse audit - Mobile emulation ### Lighthouse - Performance audit - Accessibility audit - Best practices audit - SEO audit ``` --- ## Best Practices ### Technical SEO Best Practices 1. **Monitor Regularly** - Check Search Console daily - Monitor performance metrics - Track indexing status - Review crawl errors 2. **Fix Issues Quickly** - Prioritize critical issues - Fix 404 errors - Resolve indexing problems - Address speed issues 3. **Stay Updated** - Follow Google updates - Read SEO blogs - Attend conferences - Join communities 4. **Test Changes** - Use staging environment - Test with Google tools - Monitor impact - Rollback if needed 5. **Document Everything** - Keep change log - Document decisions - Track results - Share knowledge