The pre-launch SEO checklist: what to check before you go live

The most expensive SEO mistakes do not announce themselves. A site launches, everyone celebrates, and three weeks later someone notices traffic never arrived, because a single line in a file is quietly telling Google to stay away.

This is why a pre-launch SEO checklist exists. Not to slow the launch down, but to catch the handful of settings that look harmless on staging and turn into disasters the moment they hit production. Most of them take seconds to fix before launch and weeks to recover from after.

Here is what to check before a site goes live, ordered by how much damage each item can do if you miss it.

What is a pre-launch SEO checklist, and why does it matter?

A pre-launch SEO checklist is a fixed set of technical and on-page checks you run on a site before it goes live, to confirm search engines can crawl it, index it, and understand it correctly from day one.

It matters because launch is the exact moment the highest-risk settings change hands. Staging configurations meant to keep a site hidden get pushed to production. Placeholder content that was fine internally becomes public. Redirects from the old site either work or silently break.

The stakes are not evenly spread. A missing meta description costs you a few clicks. A site-wide noindex costs you every ranking you have, and you may not notice for weeks because nothing visibly breaks. The page loads. The design looks right. Google just never shows up.

That imbalance is the whole reason to work from a checklist instead of memory. You are not trying to catch everything. You are trying to guarantee that the three or four launch-critical items are correct before anyone can be harmed by them, then working down to the smaller stuff.

The indexability checks that decide whether Google can see you

Start here, always. Indexability is the category where a single mistake blocks the entire site.

These checks come before anything about titles or content. If Google cannot crawl and index your pages, nothing else on the list matters.

Before launch, is your site accidentally telling Google to stay away?

The single most common launch disaster is a blocking directive left over from staging. Development sites are usually protected with a site-wide noindex tag, a Disallow: / in robots.txt, or an X-Robots-Tag header, all of which are correct on staging and catastrophic on production. When a deploy copies those settings across, the live site launches invisible to search.

Check three places before launch:

• The robots.txt file. Confirm it does not contain Disallow: /, which blocks the whole site. Pull up the production robots.txt directly and read it. Do not assume the deploy handled it.
• The robots meta tag. View the rendered source of your key templates (homepage, a product page, a blog post) and confirm none carry noindex. Check the templates, not just one page, because a stray tag often lives in a shared header.
• The X-Robots-Tag HTTP header. This one is invisible in the HTML, so people miss it constantly. Inspect the response headers, since a noindex here does the same damage as the meta tag.

There is a subtle trap worth understanding, because it produces the worst of both worlds. If you try to hide a page by both disallowing it in robots.txt and adding a noindex tag, the two directives fight each other, and robots.txt wins in the way you least want. Google explains in its documentation on blocking indexing with noindex that a page blocked in robots.txt cannot be crawled, which means Googlebot never reads the noindex rule, so the page can still end up indexed through external links. The fix is order of operations: allow crawling, let Google see the noindex, and only add a robots.txt block later if you want to save crawl budget once the page is already gone.

Do your canonical tags point to the live domain?

Canonical tags are the second indexability landmine, and staging is almost always the culprit. A canonical tag tells Google which URL is the authoritative version of a page. When a site is built on a staging domain, canonicals frequently get hardcoded to that staging URL, so every production page ends up pointing at an address the public cannot reach.

Check that canonicals resolve to the production domain, use HTTPS, and are self-referencing on each page. One wrong base URL in a template can canonicalize your entire site to a dev address, which tells Google your real pages are duplicates of something it cannot see.

Technical checks: redirects, sitemaps, and duplicate URLs

Once you know Google can index the site, the next tier is making sure it crawls efficiently and does not trip over duplicate or dead URLs.

These are the checks that separate a clean launch from one that leaks authority through avoidable errors. Work through this list before go-live:

1. Redirect the old URLs. If you are replacing an existing site, every old URL that had traffic or backlinks needs a 301 redirect to its closest equivalent. Skipping this throws away the ranking equity you spent years building. Map the old URLs to new ones and test that each redirect returns a 301, not a 302 or a 404.
2. Hunt down internal links to redirects. Internal links should point straight at final URLs, not at pages that redirect. A chain of redirects wastes crawl budget and slows users down. Fix the source links to hit the destination directly.
3. Set one canonical URL format and enforce it. Pick HTTPS, pick www or non-www, pick trailing slash or not, then redirect every other variant to it. Serving both example.com/page and example.com/page/ creates duplicate URLs that split your signals.
4. Confirm HTTPS everywhere. The whole site should load over HTTPS with no mixed-content warnings and no HTTP pages left crawlable. Force HTTP to redirect to HTTPS site-wide.
5. Generate and submit a clean XML sitemap. It should list only indexable, canonical, 200-status URLs. No redirects, no noindex pages, no 404s. Reference it in robots.txt and submit it in Search Console.
6. Check for soft 404s. A soft 404 is a page that shows an error message to users but returns a 200 status code to crawlers, so Google treats a broken page as real content. Empty category pages and missing products are the usual offenders.

That redirect and duplicate-URL work is tedious to do by hand across a whole site, which is exactly why it gets rushed at launch. Running the site through a crawler that flags broken links, redirect chains, and duplicate titles in one pass turns an afternoon of spot-checking into a single report. Crawlpit Monster's broken link and redirect checks surface these before they reach production, including on staging and password-protected builds that cloud crawlers cannot reach.

On-page checks: titles, meta, headings, and leftover placeholder text

With crawling and indexing sorted, the on-page layer is about making sure each page is understandable and free of the embarrassing leftovers that survive from the build.

None of these will sink a launch on their own. Together, they are the difference between a site that looks finished and one that looks abandoned.

Run a full crawl and confirm every indexable page has a unique title tag and a unique meta description, that none are missing or duplicated, and that each page has exactly one H1 that matches its purpose. If you are unsure what "correct" looks like there, our piece on why heading structure matters for rankings covers the rules in full.

Then hunt for the placeholder text that hides in production more often than anyone admits: lorem ipsum in a footer, a "Coming soon" heading nobody swapped out, a test blog post titled "asdf," or an image alt attribute that still reads "image1." Check that images have real alt text and explicit dimensions, and that your Open Graph tags render a proper title and image when a page is shared.

What should you check in the first hour after launch?

The first hour after go-live is when you verify that production behaves the way staging promised.

Re-check the production robots.txt and the rendered source of your homepage, because the deploy itself can reintroduce a block, and confirming it live is the only way to be sure. Then verify the site in Google Search Console, submit the sitemap, and run a live URL through the URL Inspection tool to confirm Google can crawl and index it.

Do not wait a week to look. A blocking directive caught in the first hour is a non-event. The same directive caught next month has already cost you a month of lost indexing and any early rankings you would have earned. For a fast gut-check on a single important page, the free browser tools confirm its indexability and on-page basics in seconds without waiting for a full crawl.

Launch with a checklist, not crossed fingers

A good launch is boring, and that is the goal. Nothing dramatic happens because every quiet killer was caught while it was still cheap to fix. The pattern to remember is simple: indexability first, because those mistakes hide your whole site, then the technical and on-page checks that protect your rankings and your credibility. Run the full pre-launch SEO checklist once and you will never again ship a site that is secretly invisible to search.

The fastest way to work the whole list at once is to crawl the site before it goes live. Point Crawlpit Monster at your staging build and let the on-page and technical audit flag the stray noindex tags, broken redirects, duplicate titles, and placeholder text in a single report, so launch day is a formality instead of a gamble. It runs on your own machine, reaches staging and password-protected sites, and is free for up to 100 pages.