Build a pre-launch SEO QA: crawls, parity, coverage, and CWV checks.
- User
Build a pre-launch SEO QA: crawls, parity, coverage, and CWV checks.
Assistant
The user wants a guide or a process for a "Pre-launch SEO QA" focusing on four specific areas:
- Crawls: Can search engines access the site?
- Parity: Is the new site the same (or better) than the old one (if migrating)? Or does it match the staging/design specs?
- Coverage: Are all important pages indexed? Is the sitemap correct?
- CWV (Core Web Vitals): Is the site fast and stable?
I need to structure this as a checklist or a comprehensive guide that an SEO professional or developer could use before flipping the switch on a new website.
Target Audience: SEOs, Developers, Project Managers. Tone: Professional, actionable, technical but accessible.
Structure:
- Introduction: Why this is important (prevent traffic loss, ensure indexation).
- Phase 1: Crawl Accessibility (The "Can they get in?" phase):
- Robots.txt (crucial for staging vs. live).
- Meta robots (noindex).
- Server response codes (200, 404, 301).
- Rendering (JS).
- Redirect maps (if a migration).
- Phase 2: Parity & Integrity (The "Did we break anything?" phase):
- Internal linking structure.
- Canonical tags (self-referencing).
- Hreflang (if international).
- Structured Data (Schema).
- Content parity (migration specific).
- Phase 3: Coverage & Indexation (The "Are we showing up?" phase):
- XML Sitemaps.
- Orphan pages.
- Pagination.
- Search Console setup.
- Phase 4: Core Web Vitals (CWV) (The "User Experience" phase):
- LCP (Largest Contentful Paint).
- INP (Interaction to Next Paint) - Note: INP replaced FID.
- CLS (Cumulative Layout Shift).
- Mobile responsiveness.
- Tools: List of what to use (Screaming Frog, PageSpeed Insights, etc.).
Drafting the Content - Key considerations:
- Crawls: Emphasize checking the staging environment using tools like Screaming Frog. Mention the danger of blocking CSS/JS.
- Parity: This is usually about migrations. I should clarify if it's a brand new site vs. a migration, but usually "parity" implies comparing Old vs. New or Design vs. Build. I'll focus on structural parity (headers, canonicals) and migration parity.
- Coverage: Focus on the sitemap and crawl depth.
- CWV: Need to mention INP as it's the new metric.
- Format: A table or bulleted list works best for a checklist.
Refining the Steps:
-
Step 1: Crawl Access.
- Check Robots.txt on Staging (ensure it allows bots after launch, but blocks before launch).
- Check for Noindex tags on staging.
- Log file analysis (if possible, but rare on staging). stick to simulated crawls.
- JavaScript Rendering: Essential for modern stacks (React, Vue, etc.).
-
Step 2: Parity.
- Metadata: Title tags, Meta descriptions.
- Headers: H1, H2.
- Redirects: 1:1 mapping from old to new.
-
Step 3: Coverage.
- Sitemap.xml existence and accuracy.
- Crawl depth (3 clicks rule).
- Faceted navigation (is it handled?).
-
Step 4: CWV.
- Run Lighthouse on key templates (Home, Product, Blog).
- Image compression.
- CLS culprits (ads, fonts, images without dimensions).
Self-Correction during drafting:
- Initial thought: Just list tools. Correction: Explain what to check with those tools.
- Initial thought: Treat it like a migration only. Correction: Pre-launch applies to new builds too. I will frame it generally but note migration specifics where relevant (especially under Parity).
Final Polish: Use clear headings, checkboxes, and bold text for emphasis. Add a "Tools Stack" section at the end.
Let's build the output.
- Title: The Pre-Launch SEO QA Checklist.
- Categories: Crawlability, Parity (Migration/Structure), Coverage, CWV.
- Detail: Specific metrics and tags to look for.
(Self-Correction on CWV): Make sure to emphasize Mobile CWV, as that's what Google uses for indexing.
(Self-Correction on Parity): Mention "Content Parity" - ensuring the text content exists on the new page as it did on the old one, not just the URL structure.
Let's write it out. This is a comprehensive framework for a Pre-Launch SEO Quality Assurance (QA) Audit. This process assumes you are working on a staging environment (development site) before the site goes live.
You can perform these checks using a combination of Screaming Frog SEO Spider, Sitebulb (or similar crawler), Google Search Console, and PageSpeed Insights.
Phase 1: Crawl Accessibility (Can Googlebot read the site?)
Goal: Ensure the site is technically open and indexable.
1. Robots.txt & Meta Robots
- Robots.txt Status: Ensure the staging
robots.txtis updated for launch. It should not block CSS, JS, or critical image folders. - Meta Robots Tags: Crawl the site and filter by
Meta Robots.- Ensure no pages have
content="noindex,nofollow"unless specifically intended (e.g., thank you pages, internal search results). - Common Failure: The dev team forgets to remove the "noindex" tag used to hide the staging server from public search results.
- Ensure no pages have
2. XML Sitemap
- Existence: Is there an XML sitemap at
/sitemap.xml? - Parity: Does the sitemap match the crawl? (The sitemap shouldn't contain pages that 404, and shouldn't be missing important pages).
- Search Console: Upload the sitemap to GSC immediately upon launch (or via a temporary DNS verification on staging if possible).
3. Rendering (JavaScript SEO)
- The Test: Use Screaming Frog's "JavaScript Rendering" mode or use Google's Rich Results Test / URL Inspection Tool.
- The Check: Does the DOM (what Google sees) match the Source Code? If the site uses React/Vue/Angular, ensure the content loads without user interaction (Lazy loading SEO is tricky).
4. Response Codes
- Filter for 404s (Not Found): Fix broken internal links.
- Filter for 500s (Server Errors): These kill crawl budget and trust.
- Filter for Redirects (301/302): Ensure 302s (temporary) are not used for permanent structural changes.
Phase 2: Parity & Integrity (Did we break anything?)
Goal: Ensure the new site matches the old site (or the design specs) in terms of SEO value.
1. Redirect Mapping (Critical for Migrations)
- The Check: Run a list of all URLs from the Old Site against the New Site.
- Outcome: Every old URL must 301 redirect to a relevant new URL.
- Avoid Chains: Old Page A -> New Page B -> New Page C is bad. It should be A -> C.
- Avoid Soft 404s: Redirecting an old page to the new homepage (unless necessary) is a soft 404 and loses link equity.
2. Canonicalization
- Self-Referencing: Most pages should point to themselves.
- Cross-Domain: Ensure the staging URL is not the canonical target (e.g., ensure
canonicalpoints tohttps://example.comnothttps://staging.example.com). - HTTPS: Ensure canonicals use HTTPS (and www or non-www consistently).
3. Internal Linking
- Crawl Depth: Ensure important pages (Money Pages) are not buried more than 3-4 clicks deep from the homepage.
- Orphan Pages: Identify pages that exist in the sitemap but have zero internal links pointing to them.
- Anchor Text: ensure generic anchors like "Read More" or "Click Here" are minimized.
4. Schema Markup (Structured Data)
- Validation: Run key templates (Homepage, Product, Article) through the Google Rich Results Test.
- Critical Data: Check that
Price,Availability,ReviewCount, andAddressare rendering correctly.
Phase 3: Coverage & Content (Is everything there?)
Goal: Ensure Google can index the full scope of the business.
1. Index Bloat Prevention
- Pagination: Ensure paginated archives (
/page/2/,/page/3/) haverel="next"andrel="prev"(though Google ignores this now, others don't) or are set tonoindex,followto preserve crawl budget. - Parameter Handling: Check
?sort=,?filter=,?session_id=URLs. These should be blocked in robots.txt or canonicalized to the root URL to prevent duplicate content.
2. International SEO (Hreflang)
- If the site targets multiple languages, verify
hreflangtags. - The Check: Return tags must exist (If Page A links to Page B in Spanish, Page B must link back to Page A in English).
3. On-Page Elements
- Title Tags: Unique per page? Length (approx 60 chars)?
- Meta Descriptions: Unique per page? Includes CTA?
- H1 Tags: One per page? Matches the intent of the Title.
Phase 4: Core Web Vitals (CWV) & UX
Goal: Pass Google's speed and stability thresholds.
Use PageSpeed Insights (lab data) and Search Console (field data - after launch).
1. LCP (Largest Contentful Paint)
- Target: < 2.5 seconds.
- Common Fixes: Optimize server response time (TTFB), use a CDN, compress the main banner image (usually the LCP element), remove render-blocking resources (unused CSS/JS).
2. INP (Interaction to Next Paint)
- Target: < 200ms.
- Common Fixes: Heavy JavaScript execution. Ensure buttons and links react instantly to clicks.
3. CLS (Cumulative Layout Shift)
- Target: < 0.1.
- Common Fixes:
- Add
widthandheightattributes to all<img>tags. - Reserve space for Ad slots or dynamic banners.
- Ensure web fonts are loaded with
font-display: swaporoptionalto prevent the "invisible text flash" (FOIT/FOUT).
- Add
The Pre-Launch Checklist Tool Stack
If you are building a report for a team, structure the columns like this:
Area Check Status Priority Notes / URL Crawl Robots.txt allows bot access ✅ / ❌ Critical Block removed? Crawl SSL/HTTPS enforced ✅ / ❌ Critical No mixed content warnings? Parity Redirects (Old -> New) ✅ / ❌ Critical List of 404s to fix Parity Canonicals (Self-referencing) ✅ / ❌ High Check staging URLs removed Coverage XML Sitemap uploaded ✅ / ❌ High Coverage Schema Validation ✅ / ❌ Medium CWV CLS (Layout Shift) < 0.1 ✅ / ❌ High Check Mobile CWV Images optimized (WebP/AVIF) ✅ / ❌ Medium Recommended Tools for Execution:
- Screaming Frog SEO Spider: Best for Phases 1, 2, and 3 (Technical parity).
- Google Search Console: Best for Indexing and Sitemap submission.
- WebPageTest.org: Best for deep-dive Waterfall analysis for CWV.
- Detailed SEO Extension (Chrome): Quick spot checks for meta tags and headers.