Technical SEO Checklist: Site Speed, Core Web Vitals, and Crawlability

You can write the best content on the internet and still get no organic traffic. If your site has technical problems — slow load times, crawl errors, broken redirects, missing canonical tags — search engines either can’t find your pages or choose not to rank them.

Technical SEO is the infrastructure layer. It’s not glamorous, and it rarely gets the attention that content strategy or link building receives. But it’s the foundation everything else depends on.

This checklist covers every technical SEO element that matters in 2026. Work through it methodically. Fix what’s broken. Optimize what’s working but could be better. And build the habits to keep your technical foundation solid over time.

Core Web Vitals

Google’s Core Web Vitals remain direct ranking signals in 2026, and they’re measured using real user data from the Chrome User Experience Report (CrUX). Lab tools like Lighthouse give you estimates, but your actual ranking impact comes from field data — how your site performs for real visitors.

Largest Contentful Paint (LCP)

What it measures: How long it takes for the largest visible content element (usually a hero image or headline text block) to fully render.

Target: Under 2.5 seconds for at least 75% of page loads.

Checklist:

• Identify your LCP element on key pages using PageSpeed Insights or Chrome DevTools Performance panel
• Optimize LCP images: serve in WebP or AVIF format, use proper sizing, implement fetchpriority="high" on the LCP image
• Eliminate render-blocking resources: defer non-critical CSS and JavaScript
• Implement server-side rendering or static site generation where possible
• Use a CDN for static assets, and ensure your CDN is properly configured for your primary audience geography
• Preconnect to required third-party origins using <link rel="preconnect">
• Minimize server response time (TTFB under 800ms; ideally under 200ms)
• Avoid lazy-loading your LCP element — it should load eagerly

LCP failures are the most common Core Web Vital problem, and they’re almost always caused by oversized images, slow server response, or render-blocking resources. Start there.

Interaction to Next Paint (INP)

What it measures: The responsiveness of your page to user interactions (clicks, taps, key presses). INP replaced First Input Delay (FID) as a Core Web Vital in March 2024 and is a more comprehensive responsiveness metric.

Target: Under 200 milliseconds.

Checklist:

• Identify slow interactions using Chrome DevTools Performance panel or the Web Vitals JavaScript library
• Break up long JavaScript tasks (anything over 50ms) into smaller chunks using requestIdleCallback or scheduler.yield()
• Minimize main thread work: defer non-essential JavaScript, remove unused code
• Avoid layout thrashing — don’t read layout properties and then immediately write to the DOM
• Be cautious with third-party scripts (analytics, chat widgets, advertising tags) that can dominate the main thread
• Test on mid-range mobile devices, not just your fast development machine

INP is where many sites fail without realizing it. If your site uses heavy JavaScript frameworks (React, Angular, Vue) or has complex interactive elements, test INP rigorously.

Cumulative Layout Shift (CLS)

What it measures: Visual stability. How much content shifts unexpectedly as the page loads.

Target: Under 0.1.

Checklist:

• Set explicit width and height attributes (or CSS aspect-ratio) on all images and video elements
• Reserve space for ad slots and dynamically injected content
• Avoid inserting content above existing content after initial render (banners, cookie consent overlays, promotional bars)
• Use font-display: swap with font preloading to prevent layout shifts from web font loading
• Ensure embeds and iframes have defined dimensions

CLS failures are often caused by ads, late-loading images without dimensions, and web font rendering. These are straightforward to fix once identified.

Site Speed Beyond Core Web Vitals

Core Web Vitals are the metrics Google uses for ranking, but site speed optimization goes deeper than passing those thresholds.

Image Optimization

Images are typically the heaviest resources on a page. A thorough image audit should address:

• Format: All images should be served in modern formats (WebP or AVIF) with fallbacks for older browsers
• Sizing: Serve images at the dimensions they’ll be displayed, not larger. Use responsive images with srcset and sizes attributes
• Compression: Use lossy compression for photographs (quality 75-85 in WebP is usually indistinguishable from original) and lossless for graphics with text
• Lazy loading: Apply loading="lazy" to all images below the fold
• CDN delivery: Serve images from a CDN, ideally with automatic format negotiation

JavaScript Optimization

• Audit your JavaScript bundle size. Tools like Webpack Bundle Analyzer or Source Map Explorer reveal what’s taking up space
• Remove unused JavaScript. Google estimates that the average page ships 35-40% more JavaScript than it actually executes
• Code-split by route or component so users only download the JavaScript needed for the page they’re viewing
• Defer non-critical scripts with defer or async attributes
• Consider whether you need that JavaScript framework at all. Static and server-rendered pages consistently outperform client-rendered SPAs for content-focused sites

CSS Optimization

• Inline critical CSS (the styles needed for above-the-fold content) and defer the rest
• Remove unused CSS. Tools like PurgeCSS or Tailwind’s built-in purging can dramatically reduce CSS file size
• Minimize CSS specificity conflicts that cause browser rendering slowdowns

Server and Hosting

• Time to First Byte (TTFB) should be under 200ms for cached pages
• Use HTTP/2 or HTTP/3 — most modern hosts support this by default, but verify
• Enable Brotli compression (20-30% smaller than gzip for text-based resources)
• Implement effective caching headers: long cache lifetimes for versioned static assets, shorter lifetimes for HTML

Crawlability and Indexation

If search engines can’t efficiently discover and crawl your pages, nothing else in this checklist matters. Crawlability is the gatekeeping function of technical SEO.

Robots.txt

• Confirm your robots.txt file exists at your domain root and is accessible
• Verify you’re not accidentally blocking important content, JavaScript files, or CSS files
• Use robots.txt to block low-value pages that waste crawl budget (internal search results, paginated archives, filtered product pages)
• Don’t use robots.txt to try to deindex pages — it prevents crawling but not indexing. Use noindex meta tags instead
• Point to your XML sitemap in robots.txt

XML Sitemaps

• Maintain an XML sitemap that includes all indexable pages
• Keep the sitemap updated automatically when pages are added or removed
• Exclude pages with noindex tags, redirected URLs, and non-canonical URLs from your sitemap
• For larger sites (1,000+ pages), use sitemap index files
• Submit your sitemap to Google Search Console and Bing Webmaster Tools
• Monitor the “Coverage” or “Indexing” report in Search Console for sitemap-related issues

Canonical Tags

• Every indexable page should have a self-referencing canonical tag
• Canonical tags should point to the preferred version of duplicate or near-duplicate content
• Ensure canonical URLs use the correct protocol (HTTPS) and are consistent about trailing slashes and www vs. non-www
• Don’t canonicalize paginated content to page 1 — each page in a paginated series should self-canonicalize
• Audit for conflicting signals: a canonical tag pointing to URL A while the sitemap includes URL B creates confusion for search engines

Internal Linking and Site Architecture

Internal links are how search engines discover pages and understand your site’s hierarchy. As we covered in our guide to on-page SEO best practices, internal linking is one of the most underused optimization levers.

• Ensure every indexable page is reachable within 3-4 clicks from the homepage
• Use descriptive anchor text for internal links (not “click here” or “read more”)
• Implement breadcrumb navigation for hierarchical site structures
• Fix broken internal links — these waste crawl budget and create dead ends
• Audit for orphan pages (pages with no internal links pointing to them)
• Build logical content clusters with hub pages linking to related subtopic pages, following topical authority principles

Crawl Budget Management

For most small to medium sites (under 10,000 pages), crawl budget isn’t a practical concern — Google will crawl everything. But for larger sites, or sites with significant amounts of parameterized or faceted URLs, crawl budget becomes critical.

• Use Google Search Console’s Crawl Stats report to monitor crawl rate and responses
• Block low-value URL parameters from crawling via robots.txt or Search Console’s URL parameter tool
• Consolidate duplicate and near-duplicate content
• Fix server errors (5xx responses) that waste crawl budget
• Improve site speed — Google crawls faster sites more aggressively

Mobile-Friendliness

Google has been on mobile-first indexing for years, meaning the mobile version of your site is what Google evaluates for rankings. This isn’t negotiable.

Checklist:

• Use a responsive design that adapts to all screen sizes
• Test on actual mobile devices, not just browser dev tools
• Ensure tap targets (buttons, links) are at least 48x48px with adequate spacing
• Text should be readable without zooming (minimum 16px base font size)
• No horizontal scrolling on mobile viewports
• Forms should be usable on mobile with appropriate input types
• Pop-ups and interstitials must comply with Google’s intrusive interstitial guidelines

HTTPS and Security

• Every page must be served over HTTPS. No exceptions
• Ensure your SSL/TLS certificate is valid, not expired, and covers all subdomains you use
• Implement HTTP Strict Transport Security (HSTS) headers
• Redirect all HTTP URLs to their HTTPS equivalents with 301 redirects
• Audit for mixed content (HTTPS pages loading HTTP resources)
• Keep your CMS, plugins, and server software updated to patch security vulnerabilities

Structured Data and Schema Markup

Structured data helps search engines understand your content and can unlock rich results (review stars, FAQ dropdowns, product details, event listings) that dramatically improve click-through rates.

Checklist:

• Implement relevant schema types for your content: LocalBusiness, Organization, Article, FAQ, Product, Service, BreadcrumbList, and others as applicable
• Validate your structured data using Google’s Rich Results Test and Schema Markup Validator
• Monitor the Enhancements reports in Google Search Console for structured data errors and warnings
• Use JSON-LD format (Google’s recommended approach) rather than Microdata or RDFa
• Don’t mark up content that isn’t visible to users — this violates Google’s guidelines
• Keep structured data synchronized with on-page content — if your schema says your business hours are 9-5 but your page says 8-6, that’s a problem

The February 2026 core update placed increased emphasis on content quality signals, and properly implemented structured data contributes to how Google understands and trusts your content.

Redirect Management

Poor redirect implementation is one of the most common technical SEO problems, especially on sites that have been through redesigns or CMS migrations.

Checklist:

• Use 301 (permanent) redirects for pages that have permanently moved
• Use 302 (temporary) redirects only for genuinely temporary situations
• Avoid redirect chains (page A redirects to page B redirects to page C). Every redirect should point directly to the final destination
• Avoid redirect loops (page A redirects to page B redirects to page A)
• After a site migration, audit for broken redirects using a crawl tool like Screaming Frog
• Preserve link equity by redirecting old URLs to the most relevant new URLs, not dumping everything to the homepage
• Monitor 404 errors in Google Search Console and implement redirects for high-traffic 404 pages

Log File Analysis

Server log analysis reveals how search engine bots actually interact with your site, not how you think they do.

• Review server logs to identify which pages Googlebot crawls most and least frequently
• Identify pages that Googlebot is crawling that shouldn’t be crawled (resource waste)
• Identify important pages that Googlebot is crawling infrequently (priority issues)
• Monitor for crawl errors and unusual response codes
• Tools like Screaming Frog Log Analyzer, Botify, or custom scripts can process log files at scale

JavaScript Rendering and SEO

If your site relies on JavaScript to render content:

• Test how Googlebot sees your pages using Google Search Console’s URL Inspection tool and the “View Rendered Page” feature
• Understand that Google renders JavaScript in a two-phase process: crawl, then render. There can be a delay of hours to days between crawling and rendering
• Critical content should not depend on JavaScript to be visible. Server-side rendering or static generation is always preferable for SEO
• Ensure JavaScript-generated internal links are standard <a href> elements that Googlebot can follow
• Monitor the JavaScript Console Errors report in Search Console for rendering failures

Tools for Technical SEO Auditing

No single tool covers everything. Build your technical SEO toolkit from these categories:

• Google Search Console. Free, authoritative data on how Google sees your site. Check it weekly at minimum
• PageSpeed Insights / Lighthouse. Core Web Vitals measurement and recommendations
• Screaming Frog SEO Spider. The standard crawl tool for identifying technical issues at scale
• Chrome DevTools. Essential for diagnosing performance, rendering, and network issues
• Ahrefs / Semrush Site Audit. Automated technical SEO auditing with historical tracking
• Web Vitals Chrome Extension. Real-time Core Web Vitals measurement as you browse your site

Building a Technical SEO Maintenance Routine

Technical SEO isn’t a one-time project. It requires ongoing attention.

Weekly: Check Google Search Console for new crawl errors, indexing issues, and Core Web Vitals regressions.

Monthly: Run a full site crawl with Screaming Frog or equivalent. Review and fix new broken links, redirect chains, missing meta tags, and duplicate content.

Quarterly: Comprehensive Core Web Vitals audit with field data analysis. Review structured data for accuracy. Audit mobile usability. Check for new pages that need to be added to (or removed from) your sitemap.

After every site change: Any time you launch new pages, change your URL structure, update your CMS, or add new third-party scripts, run a targeted technical audit of the affected areas.

Prioritization: What to Fix First

If your technical audit reveals a long list of issues (and it probably will), prioritize this way:

1. Anything preventing indexation. Broken robots.txt, noindex tags on important pages, server errors.
2. Core Web Vitals failures. These directly impact rankings and user experience.
3. Crawl errors on high-value pages. Fix issues affecting your most important content first.
4. Redirect problems. Chains, loops, and incorrect redirect types.
5. Structured data errors. These affect rich results but not core rankings.
6. Minor optimization. Image compression, CSS cleanup, and other incremental improvements.

---

Technical SEO can feel overwhelming, but most sites have a manageable number of critical issues. Fixing the fundamentals often produces measurable ranking improvements within weeks. At Ariel Digital, we perform thorough technical SEO audits for Houston-area businesses and provide clear, prioritized action plans. If your site isn’t performing the way it should, call us at 281-949-8240 to find out what’s holding it back.