52 technical SEO checks for Next.js and Astro sites in 2026 — from crawlability and Core Web Vitals to AI readiness and schema markup.
width and height props on next/image components silently degrades LCP scores. Check every image component.Technical SEO is the foundation every other ranking factor depends on. You can produce the best content in your niche, earn links from authoritative domains, and invest heavily in schema markup — and still rank poorly if your site has crawl errors, duplicate content from inconsistent canonicals, or Core Web Vitals failures. This checklist gives you 52 specific checks organized into 8 categories, with framework-specific guidance for both Next.js and Astro. Work through it top to bottom, fix what you find, then re-run an automated audit to confirm your score.
The checklist is structured so each check tells you what to look for, how to fix it if it fails, and which framework it applies to. Checks marked "Next.js and Astro" apply to any modern JavaScript site. Checks marked "Next.js only" or "Astro only" are framework-specific and can be skipped if you are on the other stack. Use the scoring guide at the end to benchmark your results and prioritize your fix queue.
These eight checks determine whether search engines and AI crawlers can reach and index your pages. Problems here affect every page on your site simultaneously.
Check 1: robots.txt allows Googlebot and all major AI crawlers
What to look for: Visit https://yourdomain.com/robots.txt and verify that GPTBot, ClaudeBot, ChatGPT-User, anthropic-ai, PerplexityBot, CCBot, Google-Extended, Amazonbot, meta-externalagent, and Bytespider are not blocked. The absence of an explicit rule means the bot is allowed by default, but explicit allow rules are better for auditability.
How to fix it: In Next.js, use app/robots.ts with explicit { userAgent: 'GPTBot', allow: '/' } rules for each crawler. See the complete robots.txt guide for AI crawlers for full configuration templates.
Applies to: Next.js and Astro.
Check 2: No important pages accidentally set to noindex
What to look for: Use a crawl tool (Screaming Frog, sitebulb, or the seo.yatna.ai audit) to find pages with <meta name="robots" content="noindex"> or X-Robots-Tag: noindex in HTTP headers. Cross-reference against your list of pages you want indexed.
How to fix it: Remove the noindex directive from the page's metadata. In Next.js App Router, check that no generateMetadata call returns { robots: { index: false } } for important pages.
Applies to: Next.js and Astro.
Check 3: No important pages blocked in robots.txt
What to look for: Check that your Disallow: rules in robots.txt do not accidentally cover URL patterns that include important content pages. Common mistakes: Disallow: /blog when you intended Disallow: /blog-admin, or Disallow: /? when you wanted to block only specific query parameters.
How to fix it: Use Google Search Console's robots.txt tester or test the URL pattern against your robots.txt manually. Update the Disallow rule to be more specific.
Applies to: Next.js and Astro.
Check 4: sitemap.xml exists and is submitted to Google Search Console
What to look for: Confirm https://yourdomain.com/sitemap.xml returns a valid XML sitemap. Then verify it is listed under Sitemaps in Google Search Console and shows a "Success" status with a recent last read date.
How to fix it: In Next.js, create app/sitemap.ts that returns a MetadataRoute.Sitemap array. In Astro, install and configure @astrojs/sitemap. Submit the sitemap URL in Google Search Console under Indexing → Sitemaps.
Applies to: Next.js and Astro.
Check 5: Sitemap includes all important pages (no orphan pages)
What to look for: Compare your sitemap URL count against the number of pages you expect to be indexed. Run a site crawl and identify any pages that are linked internally but absent from the sitemap — these are orphan pages that may be crawled infrequently.
How to fix it: Ensure your sitemap generation logic includes all published content. For Next.js dynamic routes, confirm that generateStaticParams or a database query is feeding all slugs into app/sitemap.ts.
Applies to: Next.js and Astro.
Check 6: Canonical tags present on all pages
What to look for: Check the <head> of every page type (homepage, blog index, blog post, product page, category page) for <link rel="canonical" href="...">. Every page should have one — either a self-referencing canonical or one pointing to the preferred URL if duplicates exist.
How to fix it: In Next.js App Router, set alternates: { canonical: url } inside generateMetadata. In Astro, add the canonical tag manually in your base layout component.
Applies to: Next.js and Astro.
Check 7: Canonical tags consistent between <head> and HTTP header
What to look for: Some hosting configurations emit a Link: <url>; rel="canonical" HTTP header that may conflict with the canonical tag in the HTML <head>. Use curl -I https://yourdomain.com/page to check response headers, then compare against the in-page tag.
How to fix it: Remove the duplicate HTTP header canonical if it conflicts, or align both to point to the same URL. Conflicting canonicals confuse Google's canonical selection algorithm.
Applies to: Next.js and Astro.
Check 8: No redirect chains longer than 2 hops
What to look for: A redirect chain occurs when URL A redirects to URL B which redirects to URL C. Chains longer than 2 hops dilute PageRank and slow crawlers. Use a crawl tool to find chains — look for 301/302 chains where the intermediate URL is not the final destination.
How to fix it: Update all internal links and external references to point directly to the final destination URL. Fix the redirect map so A → C directly, eliminating B.
Applies to: Next.js and Astro.
URL structure shapes how crawlers discover your pages and how PageRank flows through your site. These six checks are often overlooked because URL problems rarely surface as visible errors — your site works perfectly fine for users while silently wasting crawl budget and splitting link equity.
Check 9: URLs use lowercase letters and hyphens (not underscores)
What to look for: Google treats hyphens as word separators and underscores as word joiners. technical-seo-audit is three separate words; technical_seo_audit is treated as one. Inspect your URL slugs for underscore usage or mixed case.
How to fix it: Configure your CMS or routing layer to generate lowercase, hyphenated slugs. Set up 301 redirects from any legacy uppercase or underscore URLs to their corrected versions.
Applies to: Next.js and Astro.
Check 10: No parameter-based duplicate content
What to look for: URLs like ?sort=price, ?ref=newsletter, or ?page=1 often serve the same content as the canonical URL. Check whether these parameter variants are indexable and whether they have correct canonicals pointing to the clean URL.
How to fix it: Add <link rel="canonical"> on parameter URLs pointing to the base URL. For Next.js, configure redirects in next.config.ts or use middleware to normalize parameters before rendering.
Applies to: Next.js and Astro.
Check 11: Consistent trailing slash policy
What to look for: https://yourdomain.com/blog/ and https://yourdomain.com/blog are treated as separate URLs. If both resolve without a canonical relationship, you have a duplicate content issue. Check both versions — do they both return 200, or does one redirect to the other?
How to fix it: In next.config.ts, set trailingSlash: true or trailingSlash: false to enforce a consistent policy. Ensure your sitemap, internal links, and canonical tags all use the same form.
Applies to: Next.js and Astro.
Check 12: Site hierarchy reflected in URL structure
What to look for: Flat URL structures (/category/post-slug) make crawling efficient and signal topical hierarchy. Deep nested structures (/section/subsection/category/post-slug) increase crawl depth and can reduce the frequency of recrawls for pages at depth 4 or deeper.
How to fix it: Reorganize your URL structure to keep important content within 3 clicks of the homepage. Update your sitemap and internal linking accordingly, and set up 301 redirects from old deep URLs.
Applies to: Next.js and Astro.
Check 13: No soft 404s (pages returning HTTP 200 with "not found" content)
What to look for: A soft 404 occurs when a page that should return a 404 status instead returns a 200 with content like "Page not found" or an empty template. This wastes crawl budget and may cause Googlebot to index meaningless pages. Spot-check deleted product pages, expired event pages, and old blog posts that were removed without a redirect.
How to fix it: Configure your server or Next.js middleware to return { notFound: true } (Pages Router) or call notFound() (App Router) for missing dynamic routes, which triggers a proper 404 response.
Applies to: Next.js and Astro.
Check 14: No redirect loops
What to look for: A redirect loop occurs when URL A redirects to URL B, which redirects back to URL A (or any cycle). Browsers and crawlers both abort after detecting a loop. Use a crawl tool or curl -L -v to trace redirect chains and look for cycles.
How to fix it: Audit your redirect rules in next.config.ts, your CDN/Nginx configuration, and any middleware. Map out the full redirect chain for any redirecting URL and break any cycle by pointing to the final destination directly.
Applies to: Next.js and Astro.
Meta tags are the first signals Google reads when evaluating a page for indexing and ranking. Problems here do not just affect one page — templating errors in your meta tag generation can replicate the same bad title or missing description across hundreds of pages simultaneously. These eight checks are quick to run and high-impact to fix.
Check 15: Every page has a unique title tag (max 70 characters)
What to look for: Crawl your site and export all title tags. Look for duplicates, titles over 70 characters (which get truncated in SERPs), and pages with missing or templated titles that did not interpolate dynamic content.
How to fix it: In Next.js App Router, ensure generateMetadata returns a unique title for every route. In Astro, pass the title as a prop to your base layout and ensure no two templates produce the same default value.
Applies to: Next.js and Astro.
Check 16: Every page has a unique meta description (145–155 characters)
What to look for: Meta descriptions do not directly influence rankings but heavily influence click-through rate. A missing meta description causes Google to auto-generate one from page content, which is often poorly targeted. Check for duplicates and overly short descriptions (under 100 chars).
How to fix it: Write unique meta descriptions for every page type. For blog posts, the excerpt field makes an ideal source. Target 145–155 characters to maximize the visible snippet length without truncation.
Applies to: Next.js and Astro.
Check 17: H1 is present and matches the target keyword
What to look for: Every page should have exactly one H1 that includes the primary target keyword, ideally near the beginning of the H1 text. Check that templated pages (category archives, tag pages) are not all sharing the same H1 formula.
How to fix it: Add the H1 if missing, or revise it to include the target keyword naturally. Do not force an exact-match keyword into an H1 where it reads unnaturally — partial matches and close variants work.
Applies to: Next.js and Astro.
Check 18: Only one H1 per page
What to look for: Multiple H1 tags on a single page dilute the heading signal. This often happens with CMS templates where both a page hero component and the article component render their own H1. Use browser dev tools or a crawl report to find pages with H1 count > 1.
How to fix it: Change secondary H1 elements to H2. In component-based frameworks, make the heading level a prop so the same component can render as H1 or H2 depending on context.
Applies to: Next.js and Astro.
Check 19: OG image is 1200×630px on every page
What to look for: Social sharing previews for Twitter/X, LinkedIn, and Facebook all require the OG image to be exactly 1200×630px (2:1 ratio). Check your OG images using a social preview tool or inspect the image dimensions directly.
How to fix it: Resize all OG images to 1200×630px with a centered crop. For dynamic OG images in Next.js, use the app/opengraph-image.tsx API which renders at the correct dimensions automatically.
Applies to: Next.js and Astro.
Check 20: Full OG tag set present on every page
What to look for: All four core OG tags must be present: og:title, og:description, og:image, and og:url. Missing any one of these degrades social sharing previews and reduces click-through from social platforms.
How to fix it: In Next.js, include openGraph: { title, description, images, url } in every generateMetadata return value. In Astro, add the four OG meta tags to your base layout with dynamic values passed as props.
Applies to: Next.js and Astro.
Check 21: Twitter card meta tags present
What to look for: Twitter/X uses its own meta tag set (twitter:card, twitter:title, twitter:description, twitter:image) separate from OG tags. Check that all four are present on every page and that twitter:card is set to summary_large_image for pages with a 1200×630 OG image.
How to fix it: In Next.js, include twitter: { card: 'summary_large_image', title, description, images } in generateMetadata. In Astro, add the Twitter meta tags to your base layout alongside the OG tags.
Applies to: Next.js and Astro.
Check 22: hreflang tags correct for multi-language sites
What to look for: If your site serves content in more than one language, every language variant of each page must include hreflang tags pointing to all other language variants, including a self-referencing tag. Missing hreflang tags cause Google to treat language variants as duplicate content.
How to fix it: Add alternates: { languages: { 'en-US': url_en, 'fr-FR': url_fr } } inside generateMetadata in Next.js. Ensure every page in the set references every other page, and that the x-default variant is declared.
Applies to: Next.js and Astro (only relevant if the site is multi-language).
Check 23: LCP < 2.5 seconds
What to look for: Largest Contentful Paint measures how long it takes for the largest visible element (usually a hero image or H1) to render. Measure with PageSpeed Insights, Chrome DevTools Lighthouse, or the Chrome User Experience Report (CrUX) in Google Search Console.
How to fix it: The most common LCP causes are unoptimized hero images, render-blocking resources, and slow server response times. See Core Web Vitals 2026 guide for a full optimization sequence.
Applies to: Next.js and Astro.
Check 24: INP < 200ms
What to look for: Interaction to Next Paint replaced FID as a Core Web Vital in March 2024 and measures the delay between a user interaction (click, tap, keypress) and the next visual update. Poor INP is usually caused by long JavaScript tasks on the main thread. Measure using Chrome DevTools Performance panel or the Web Vitals extension.
How to fix it: Break up long tasks using scheduler.yield() or requestIdleCallback. Defer non-critical JavaScript. In Next.js, ensure Server Components are used wherever possible to reduce client-side JS.
Applies to: Next.js and Astro.
Check 25: CLS < 0.1
What to look for: Cumulative Layout Shift measures unexpected visual shifts during page load. Common causes: images without dimensions, dynamically injected ads or banners above the fold, late-loading fonts that cause text reflow, and embeds without reserved space.
How to fix it: Add width and height attributes to all images. Reserve space for dynamic content with CSS min-height. Use font-display: swap or optional to control font loading behavior.
Applies to: Next.js and Astro.
Check 26: Above-the-fold images use priority or fetchpriority="high"
What to look for: The hero image and any image visible in the initial viewport without scrolling should be loaded with the highest priority. In Next.js, check that <Image priority /> is set on the hero image. In Astro (which uses native <img>), check for fetchpriority="high" and the absence of loading="lazy".
How to fix it: Add priority prop to the first <Image> in every page template in Next.js. In Astro, add fetchpriority="high" and ensure loading="lazy" is not set on above-fold images.
Applies to: Next.js and Astro.
Check 27: Images below the fold use loading="lazy"
What to look for: Lazy loading defers the download of off-screen images until the user scrolls near them, reducing initial page weight and improving LCP. Verify that images in blog post bodies, testimonial sections, and footer areas use lazy loading.
How to fix it: In Next.js, <Image> is lazy by default unless priority is set — no action needed. In Astro, add loading="lazy" explicitly to all below-fold <img> tags.
Applies to: Next.js and Astro.
Check 28: next/image uses correct width and height props
What to look for: This is the most common Next.js-specific LCP regression. When next/image is missing explicit width and height props (or when they are set incorrectly), Next.js generates multiple srcset entries at incorrect sizes. The browser then wastes time downloading a wrong-sized image before selecting the correct one, which directly delays LCP. Use Lighthouse to check for "Properly sized images" warnings and inspect the srcset attribute on your hero image.
How to fix it: Set explicit width and height props matching the intrinsic dimensions of the image. For responsive images that fill a container, use fill prop combined with a positioned parent element — do not use width={0} or height={0} workarounds.
Applies to: Next.js only.
Check 29: JavaScript bundle is code-split
What to look for: A monolithic JavaScript bundle — one large JS file loaded on every page — slows initial load time and increases the time before a page becomes interactive. Use the Next.js Bundle Analyzer (@next/bundle-analyzer) or Chrome DevTools Coverage panel to identify large, un-split bundles.
How to fix it: In Next.js App Router, Server Components automatically reduce client JS. Use dynamic imports (next/dynamic) for heavy client-side components. In Astro, islands architecture already enforces component-level splitting — verify that no island is importing a large shared dependency unnecessarily.
Applies to: Next.js and Astro.
Check 30: Fonts preloaded via <link rel="preload"> or Next.js font optimization
What to look for: Web fonts that are not preloaded cause text to render invisibly (FOIT) or with a fallback font (FOUT) until the font file downloads. This contributes to CLS and poor perceived performance. Check the <head> for <link rel="preload" as="font"> or confirm that next/font is used in Next.js.
How to fix it: In Next.js, replace manual @font-face declarations with next/font/google or next/font/local. In Astro, add a <link rel="preload" as="font" type="font/woff2" crossorigin> tag in your base layout for each font file.
Applies to: Next.js and Astro.
Schema markup is the highest-leverage investment for both traditional rich results and AI search visibility. Google uses structured data to understand what your content is, who authored it, and whether it is trustworthy — the same signals that AI systems use to decide whether to cite your pages. A site with complete, validated schema consistently outperforms an identical site without it in AI citation frequency.
Check 31: Organization schema in site-wide layout
What to look for: Organization schema establishes your brand identity for Google's Knowledge Graph. Check the homepage <head> for a JSON-LD block with @type: "Organization", including name, url, logo, and sameAs links to social profiles.
How to fix it: Add a JSON-LD Organization schema block to your root layout component. In Next.js, include it as a <Script type="application/ld+json"> in app/layout.tsx. This renders on every page without duplication.
Applies to: Next.js and Astro.
Check 32: Article schema on all blog posts
What to look for: Every blog post should have Article (or BlogPosting) schema with at minimum: headline, author (as a Person object), datePublished, dateModified, and image. Check a sample of blog post pages for the JSON-LD block.
How to fix it: Add Article schema generation to your blog post template. Pull values from frontmatter: slug → URL, title → headline, date → datePublished, author slug → author name and social links.
Applies to: Next.js and Astro.
Check 33: Author in Article schema has sameAs links to social profiles
What to look for: The author property inside Article schema should be a full Person object with name, url (author page), and sameAs (array of social profile URLs — LinkedIn, Twitter/X, GitHub). This is an E-E-A-T signal — it lets Google connect the author's identity to verifiable online presence.
How to fix it: Define a central author registry (e.g., data/authors.ts) with each author's social links. Reference this in your schema generation logic so Article schema always includes populated sameAs.
Applies to: Next.js and Astro.
Check 34: FAQPage schema on pages with Q&A sections
What to look for: Pages with FAQ sections, Q&A content, or clearly structured question-and-answer blocks are eligible for FAQ rich results. Check that pages with these sections include a FAQPage JSON-LD block listing all questions and answers.
How to fix it: Add FAQPage schema to your page template wherever FAQ content is rendered. Each question should be a Question object with name (the question) and acceptedAnswer.text (the answer text).
Applies to: Next.js and Astro.
Check 35: BreadcrumbList schema on all inner pages
What to look for: BreadcrumbList schema enables breadcrumb rich results in SERPs and helps Google understand your site hierarchy. Check inner pages (blog posts, product pages, category pages) for a BreadcrumbList JSON-LD block reflecting their position in the site structure.
How to fix it: Generate BreadcrumbList schema dynamically from the page URL path. For a blog post at /seo-academy/post-slug, the breadcrumb list should be: Home → SEO Academy → Post Title.
Applies to: Next.js and Astro.
Check 36: SoftwareApplication schema on product or tool pages
What to look for: If your site includes product landing pages, tool pages, or SaaS pricing pages, SoftwareApplication schema is the correct type. Check for @type: "SoftwareApplication" with name, applicationCategory, operatingSystem, offers, and aggregateRating.
How to fix it: Add SoftwareApplication JSON-LD to your product/tool page template. The offers block should include pricing information. The aggregateRating block (if you have reviews) enables star rating rich results.
Applies to: Next.js and Astro.
Check 37: No schema validation errors
What to look for: Malformed JSON-LD — missing required properties, incorrect value types, or invalid @context declarations — will prevent rich results from appearing. Test every schema type you implement with the Google Rich Results Test (search.google.com/test/rich-results).
How to fix it: Fix any errors reported by the Rich Results Test. Common issues: datePublished not in ISO 8601 format, image missing required dimensions in ImageObject, and sameAs containing malformed URLs.
Applies to: Next.js and Astro.
Check 38: JSON-LD preferred over microdata
What to look for: JSON-LD and microdata both implement schema.org markup, but JSON-LD is Google's recommended approach because it is decoupled from your HTML structure. Check that your schema is implemented as <script type="application/ld+json"> blocks, not as itemscope/itemprop attributes on HTML elements.
How to fix it: Convert any microdata schema to JSON-LD equivalents. JSON-LD is easier to maintain, test, and update without touching your page HTML.
Applies to: Next.js and Astro.
AI search readiness is the newest category on this checklist and the fastest-moving. ChatGPT, Claude, and Perplexity now collectively drive a measurable share of referral traffic for content and SaaS sites. The sites that rank well in AI-generated answers in 2026 are not the sites with the most links — they are the sites that made it easy for AI crawlers to access, understand, and trust their content. These six checks are the minimum viable AI readiness configuration.
Check 39: robots.txt individually verifies each AI crawler
What to look for: This extends Check 1 with per-crawler verification. Read your robots.txt and confirm each of the ten major AI crawlers is addressed individually with an explicit rule — do not rely on wildcard Allow: / to cover them, as this is harder to audit and may be overridden by preceding Disallow rules.
How to fix it: List each AI crawler user-agent explicitly with its intended Allow or Disallow directive. Use the robots.txt checker tool to validate all ten crawlers in one pass.
Applies to: Next.js and Astro.
Check 40: /llms.txt present and accurate
What to look for: The llms.txt standard (proposed 2024, widely adopted 2025) provides a structured summary of your site for AI systems. Check that https://yourdomain.com/llms.txt exists, returns a 200 status, describes your site in one paragraph, and lists your most important pages with one-line descriptions.
How to fix it: Create an llms.txt file in your public/ directory. See the complete llms.txt guide for the format and examples. In Next.js, you can also generate it dynamically via a route handler.
Applies to: Next.js and Astro.
Check 41: Key pages have answer-first content structure
What to look for: AI systems — and featured snippets — favor pages that answer the target question in the first 1–2 paragraphs, before supporting detail. Review your most important landing pages: does the first paragraph directly answer the primary query, or does it begin with background context and build slowly to the answer?
How to fix it: Restructure key pages to lead with the direct answer (2–3 sentences), then follow with supporting evidence, context, and detail. This format is sometimes called the "inverted pyramid" or "BLUF" (bottom line up front).
Applies to: Next.js and Astro.
Check 42: Author pages exist with full credentials and LinkedIn link
What to look for: Author pages are a core E-E-A-T signal. Each named author on your site should have a dedicated author page with: full name, photo, professional bio (2–3 sentences), areas of expertise, and at minimum a LinkedIn profile link. The author schema on blog posts should link to this page via the url property.
How to fix it: Create an author page route (e.g., /authors/[slug]) that renders from an author registry. Ensure each author's social links, title, and expertise description are populated. Link Article schema author.url to the author page.
Applies to: Next.js and Astro.
Check 43: Named data claims with sources (no anonymous statistics)
What to look for: AI systems and Google's quality raters both penalize content that makes unattributed statistical claims ("Studies show 70% of users...") without a source. Scan your content for percentage claims, benchmark figures, and research findings — each should have an inline citation or linked source.
How to fix it: Add inline citations for every statistical claim. Link to the primary source (not an intermediary article). If you cannot find the original source for a statistic, remove or reframe the claim.
Applies to: Next.js and Astro.
Check 44: Key Takeaway or Summary block on long-form content
What to look for: Long-form content (1,500+ words) should open with a Key Takeaways block — a bulleted summary of the 4–6 most important points. This serves as the answer-first element for AI retrieval, improves dwell time for human readers, and is frequently pulled into AI Overviews and featured snippets.
How to fix it: Add a Key Takeaways section immediately after the H1 on all long-form pages. Each bullet should be a complete, standalone statement — not a fragment — so it can be surfaced in isolation by AI systems.
Applies to: Next.js and Astro.
These five checks are unique to Next.js App Router and address the most common technical SEO mistakes specific to the framework. They go beyond generic SEO guidance — you will not find these in a traditional SEO audit tool. If you are running Next.js in production, all five should be verified on every major deployment.
Check 45: output: 'standalone' configured for Docker deployments
What to look for: If you are deploying Next.js in a Docker container, output: 'standalone' in next.config.ts is required. It generates a self-contained server.js file with all dependencies bundled, dramatically reducing image size. Without it, the container requires the full node_modules directory.
How to fix it: Add output: 'standalone' to your next.config.ts nextConfig object. Ensure your Dockerfile copies from .next/standalone rather than the entire project root.
Applies to: Next.js only.
Check 46: generateMetadata used for dynamic OG images and meta
What to look for: Static export const metadata = { ... } objects work for pages with fixed metadata, but dynamic routes (blog posts, product pages, user profiles) require generateMetadata to interpolate per-page values. Check that dynamic route pages use generateMetadata — static metadata objects on dynamic routes produce identical meta tags across all URLs, which is a major duplicate content signal.
How to fix it: Replace export const metadata with export async function generateMetadata({ params }) on all dynamic route pages. Fetch the page content inside this function to populate title, description, OG image, and canonical URL.
Applies to: Next.js only.
Check 47: app/sitemap.ts generates sitemap dynamically
What to look for: A static public/sitemap.xml file requires manual updates every time a new page is published. Confirm that your sitemap is generated from app/sitemap.ts (or app/sitemap.xml.ts) using Next.js's MetadataRoute.Sitemap API. This ensures the sitemap is always current.
How to fix it: Create app/sitemap.ts that fetches all content slugs (from the filesystem or a CMS) and returns them as sitemap entries. Delete public/sitemap.xml if it exists to prevent conflicting responses.
Applies to: Next.js only.
Check 48: app/robots.ts generates robots.txt dynamically
What to look for: Same principle as Check 47 — a static public/robots.txt is a maintenance liability. Confirm that app/robots.ts is present and that no public/robots.txt file exists alongside it (Next.js will serve the static file in preference to the dynamic route in some configurations).
How to fix it: Create app/robots.ts returning a MetadataRoute.Robots object. Delete public/robots.txt. Verify the output at https://yourdomain.com/robots.txt after deployment.
Applies to: Next.js only.
Check 49: next/image used for all images (no raw <img> tags)
What to look for: Raw <img> tags bypass Next.js image optimization: automatic WebP/AVIF conversion, responsive srcset generation, lazy loading, and the priority queue management. Search your component files for <img tags that are not <Image from next/image.
How to fix it: Replace all <img> tags with <Image> from next/image. The only exception is external images where you cannot predict dimensions — for these, add the external hostname to images.remotePatterns in next.config.ts and still use <Image>.
Applies to: Next.js only.
Astro's architecture — static-first with optional islands — gives it a natural performance advantage over fully client-rendered frameworks. But that advantage can be erased quickly if islands are used carelessly above the fold, or if the built-in integrations for sitemap generation are not configured correctly. These three checks are the Astro-specific issues that appear most frequently in real audits.
Check 50: @astrojs/sitemap integration enabled and configured
What to look for: Astro does not generate a sitemap by default. Check astro.config.mjs for import sitemap from '@astrojs/sitemap' and integrations: [sitemap()]. Also verify that site is set in the Astro config (the sitemap integration requires it to generate absolute URLs).
How to fix it: Install @astrojs/sitemap with npm install @astrojs/sitemap, add it to the integrations array in astro.config.mjs, and set site: 'https://yourdomain.com'. Submit the generated /sitemap-index.xml to Google Search Console.
Applies to: Astro only.
Check 51: <ViewTransitions> not breaking canonical tag rendering
What to look for: Astro's <ViewTransitions> component enables smooth page transitions by partially replacing the DOM on navigation rather than doing a full page reload. In some configurations, this causes the <head> to not fully update between pages — including canonical tags, OG tags, and schema — resulting in stale metadata from the previous page being active on the new page.
How to fix it: After enabling <ViewTransitions>, inspect the <head> using browser DevTools while navigating between pages and confirm the canonical URL updates correctly. If it does not, ensure your canonical tag component is outside any element marked with transition:persist.
Applies to: Astro only.
Check 52: Island components not blocking LCP
What to look for: Astro's islands architecture renders interactive components client-side via client:load, client:idle, or client:visible directives. Any island rendered above the fold with client:load that imports a large JavaScript dependency will delay the browser's ability to render the page, potentially pushing LCP past 2.5 seconds. Inspect your above-fold components: are any of them Astro islands?
How to fix it: Convert above-fold interactive components to use as little JavaScript as possible. Use client:visible instead of client:load if the component does not need to be interactive before the user sees it. For decorative animations above the fold, consider a pure CSS approach rather than a JavaScript island.
Applies to: Astro only.
Count how many of the 52 checks your site passes and use the table below to interpret your score.
| Score | Rating | What It Means |
|---|---|---|
| 48–52 | Excellent | Automated SEO tools will score your site 90+. You have no systematic issues — focus on content and link building. |
| 40–47 | Good | A few categories need attention. Identify which category has the most failures and fix those first. |
| 30–39 | Needs Work | Multiple systematic issues. Prioritize crawlability and performance checks — these affect every page. |
| < 30 | Critical | Foundational technical problems that are actively suppressing your rankings. Start with Category 1 and Category 4. |
How to prioritize fixes: Crawlability failures (Category 1) affect every page simultaneously — fix those first. Performance failures (Category 4) directly impact rankings via Core Web Vitals — fix those second. Schema failures (Category 5) affect rich results eligibility but do not suppress base rankings — fix those after the first two categories are clean.
How often should I run a technical SEO audit?
Run a full 52-check audit quarterly at minimum. For fast-moving sites — e-commerce with frequent product changes, SaaS with weekly deployments, or content sites publishing daily — run a partial audit (Category 1 and Category 4) monthly. Set up automated monitoring for the highest-impact items: sitemap freshness, robots.txt changes, Core Web Vitals, and schema validation errors. These four categories change most often and degrade quietly without visible signals.
Is this checklist relevant if I use the Next.js Pages Router instead of App Router?
Most checks apply equally. The framework-specific guidance in Categories 6–7 (robots.ts, sitemap.ts, generateMetadata) references App Router APIs. For Pages Router, the equivalents are: getServerSideProps or getStaticProps returning notFound: true, next-sitemap package for sitemap generation, a static public/robots.txt, and getStaticProps-based metadata passed to <Head> via next/head. The check intent is the same — only the implementation differs.
Do these checks apply to Astro sites using SSR mode or only static output?
All 52 checks apply regardless of Astro rendering mode (static, SSR, hybrid). The canonical tag, sitemap, and ViewTransitions checks (50–52) are relevant to both. In SSR mode, the canonical tag challenge is more acute because the same component tree renders for every request — verify that server-rendered canonical URLs reflect the actual request URL, not a hardcoded base URL from build time.
What score do I need to rank on page one?
There is no direct score-to-ranking conversion because technical SEO is one input among many — content quality, domain authority, and query intent all matter. What the score predicts is whether technical issues are actively holding you back. A site scoring below 30 is almost certainly being suppressed by technical problems. A site scoring 48+ has no technical ceiling — its ranking will be determined by content and authority. For competitive SaaS keywords, a clean technical foundation combined with strong E-E-A-T signals (Checks 42–44) and correct schema (Checks 31–38) is what separates page-one results from page-two results.
Can I run these 52 checks automatically instead of manually?
Yes. The seo.yatna.ai automated audit runs a subset of these checks programmatically — including crawlability, meta tag completeness, Core Web Vitals, schema validation, and AI crawler configuration — and scores your site across the six weighted categories (E-E-A-T, Technical SEO, On-Page SEO, Schema, Performance, AI Readiness). The manual checks on this list — soft 404 spot-checking, content structure review, data source attribution — require human judgment and are not automatable.
You now have a complete technical SEO audit checklist for your Next.js or Astro site. The fastest way to find out where your site currently stands on the automatable checks is to run a free audit at seo.yatna.ai.
The audit crawls your site, tests your robots.txt configuration against all ten major AI crawlers, validates your schema markup, measures Core Web Vitals from real user data, and scores your site across six weighted categories. You will get a full report with prioritized fixes — not a generic list, but specific issues on specific pages.
For the AI crawler configuration check in particular, the robots checker tool tests your live robots.txt against every crawler in this checklist and flags any that are inadvertently blocked. It takes under ten seconds and is the single highest-leverage fix most sites can make for AI search visibility.
If you want to go deeper on AI readiness beyond this checklist, the AI Search Readiness Audit Guide covers E-E-A-T signals, llms.txt implementation, citation-optimized content structure, and the full framework for getting cited in ChatGPT, Claude, and Perplexity answers.
About the Author
Ishan Sharma
Head of SEO & AI Search Strategy
Ishan Sharma is Head of SEO & AI Search Strategy at seo.yatna.ai. With over 10 years of technical SEO experience across SaaS, e-commerce, and media brands, he specialises in schema markup, Core Web Vitals, and the emerging discipline of Generative Engine Optimisation (GEO). Ishan has audited over 2,000 websites and writes extensively about how structured data and AI readiness signals determine which sites get cited by ChatGPT, Perplexity, and Claude. He is a contributor to Search Engine Journal and speaks regularly at BrightonSEO.