The post-deploy SEO checklist: what to verify in the first hour after a release

Verify status codes, noindex, robots.txt, canonicals, redirects and sitemaps in the first hour after a deploy, before Google re-crawls the damage.

In the first hour after a release, check eight things in this order: status codes on key URLs, meta robots and X-Robots-Tag, the robots.txt diff, canonicals, redirect chains, sitemap reachability, title and H1 on each template, and staging headers leaking into production. A sitewide noindex, a blocking robots.txt, or canonicals pointing at staging cannot wait. A missing title on one low-value page can.

Work from a list prepared before the deploy: the homepage, one URL per template (product, category, article, landing page), top organic landing pages, and any URL the release changed. Every check below runs against that list. If a template fails, assume every page on that template fails until proven otherwise.

1. Do key URLs still return the right status code?

Start here because a status code is the gate for everything else. A page returning 404, 500, or an unexpected 200 for a soft 404 cannot be indexed correctly no matter what its tags say.

Check the final status after redirects, not just the first response:

curl -s -o /dev/null -w "%{http_code} %{url_effective}\n" -L https://example.com/
curl -s -o /dev/null -w "%{http_code} %{url_effective}\n" -L https://example.com/key-page/

Run this for every URL on your list. You want 200 for live pages, one intentional 301/302 for moved pages, and a genuine 404/410 for removed pages. Watch for a route that now 500s, a catch-all returning 200 with a “not found” template (a soft 404), and a section returning 403 after a new firewall or CDN rule shipped.

2. Is there a noindex in meta robots or X-Robots-Tag?

Next, confirm the pages that return 200 are allowed into the index. A noindex can live in two places, and you must check both.

In the HTML head, look for a meta robots tag:

curl -s https://example.com/ | grep -i -o '<meta[^>]*robots[^>]*>'

In the response headers, look for X-Robots-Tag:

curl -s -I https://example.com/ | grep -i x-robots-tag

Either directive alone excludes the page. The header version is the one deploys smuggle in, because staging protection is often set at server, CDN, or framework level and never appears in view-source. Use a tool that reads both: the indexability checker reports meta robots and X-Robots-Tag together, and the X-Robots-Tag checker isolates the header.

The usual cause is staging configuration promoted to production: a failed environment check, an app left in staging mode, or a copied header rule. Fix the source of the promotion, not the individual page. Recovery is covered in accidentally noindexed your site: find and fix it fast.

3. Did robots.txt change?

Fetch live robots.txt and diff it against the pre-deploy version. If you have no saved copy, save one now for the next release; do not reconstruct expectations from staging, which should block everything and is the wrong reference.

curl -s https://example.com/robots.txt > robots-after.txt
diff robots-before.txt robots-after.txt

Any new Disallow is a finding until explained. Rule out a blanket Disallow: / from staging, a disallow covering a newly launched section, and a Sitemap: line pointing at staging. A disallow blocks crawling rather than indexing directly, but a blocked page cannot be re-crawled or refreshed, so blocked key pages effectively disappear over time.

Test specific URLs against the live file with the robots.txt tester rather than reading the rules by eye, especially when user-agent groups overlap. For a larger sample of URLs at once, the bulk checker saves checking pages one by one.

4. Do canonicals point at the live, correct URL?

After indexability, check where each page says its canonical version lives. A canonical pointing at staging, the old domain, or the homepage credits a different URL than the one shipped.

curl -s https://example.com/key-page/ | grep -i -o '<link[^>]*canonical[^>]*>'

On each template sample, confirm the canonical is absolute, uses the production host and correct protocol, returns 200, and matches the page’s own URL where self-referencing is expected. Typical failures: an environment variable still set to staging, so every canonical names staging.example.com; canonicals collapsing to the homepage when a template variable fails; and canonicals pointing at URLs that now redirect.

Canonicals are hints, not directives, so one wrong canonical rarely kills a page in an hour. The same wrong canonical across a whole template, left for weeks, quietly moves credit to the wrong URLs.

5. Do redirects land in one hop, on the right page?

If the release moved or renamed URLs, test the old URLs explicitly. Do not sample from internal links. They were probably updated and will not reveal a broken redirect map.

curl -s -I -L https://example.com/old-page/ | grep -i -E "^HTTP|^location"

Check that the old URL redirects at all, lands on the relevant replacement rather than the homepage, arrives in one hop, and does not loop. Use the redirect checker to see the full chain when curl output gets hard to read.

Watch redirects the deploy may have rewritten: trailing-slash, www/non-www, HTTP-to-HTTPS, and locale rules. A release that regenerates rules from CMS or framework config can drop hand-added rules from earlier migrations. Chains matter less than failures: an extra hop wastes crawl budget, while a 404, loop, or homepage redirect for a page with backlinks loses equity now. See the site migration SEO monitoring playbook for the longer version.

6. Is the sitemap reachable and current?

Check that the sitemap exists where robots.txt and Search Console expect it, returns 200, and lists the URLs the release just shipped, not the ones it removed.

curl -s -o /dev/null -w "%{http_code}\n" https://example.com/sitemap.xml
curl -s https://example.com/sitemap.xml | head -c 1000

If the sitemap is an index file, spot-check two or three child sitemaps. Listed URLs should use the production host, return 200, and be indexable; a sitemap full of redirecting, blocked, or noindexed URLs contradicts itself. Confirm removed pages are gone. A stale sitemap alone does not deindex anything, but a sitemap returning 404 or listing staging URLs signals staging configuration in the deploy, so go back to checks two, three, and four.

7. Do titles and H1s survive on each template?

Only after the blocking checks pass, read the page as a visitor would. On one URL per template, confirm the title is present, unique, and not a placeholder, and that there is exactly one H1 matching the page’s purpose.

curl -s https://example.com/key-page/ | grep -i -o '<title>[^<]*</title>'
curl -s https://example.com/key-page/ | grep -i -o '<h1[^>]*>[^<]*</h1>'

Deploy failures here are template failures: a title rendered as the site name alone because a variable stopped resolving, titles duplicated across a section after a template overwrite, or an H1 changed in a redesign nobody flagged as an SEO change. One broken title is small; the same title across ten thousand product pages is not. Checking per template catches the pattern.

8. Are staging headers or staging behaviour leaking into production?

The last check is broader than any single tag: is production behaving like staging anywhere? These leaks cause half the failures above, so check for the leak directly, not just its symptoms.

Compare response headers between staging and production for the same path:

curl -s -I https://example.com/ | grep -i -E "x-robots-tag|x-environment|cache-control|set-cookie"
curl -s -I https://staging.example.com/ | grep -i -E "x-robots-tag|x-environment|cache-control|set-cookie"

On production you should not see staging environment headers, staging-only X-Robots-Tag: noindex rules, basic-auth challenges, or accidental sitewide Cache-Control: no-store. Click through logged out: staging banners, debug output, test payment modes, and staging API endpoints in production forms are the same kind of leak. Finally, confirm analytics and Search Console verification tags survived. A new template or tag-manager publish often removes them. WordPress-specific failure points are covered at /wordpress.

What cannot wait an hour, and what can wait a day?

Triage by reach and reversibility, not by how alarming a finding looks.

Cannot wait an hour:

  • noindex in meta robots or X-Robots-Tag on the homepage, key templates, or sitewide
  • A robots.txt Disallow covering the whole site or a key section
  • 404, 500, or 403 responses on key URLs or an entire template
  • Canonicals naming the staging host across a template or the whole site
  • Redirect loops, or old URLs with traffic and backlinks landing on 404s
  • Production behind basic auth, or serving staging headers and staging configuration

Can wait a day:

  • A missing or duplicated title on a single low-value page or a small section
  • A new two-hop redirect chain on URLs with little traffic or few backlinks
  • Sitemap tidying: removed pages still listed, new pages not yet added, lastmod dates wrong
  • One template’s H1 hierarchy changed in a way that needs a considered fix rather than a revert
  • Image, schema, or internal-link regressions that do not block crawling or indexing

The distinction is whether Google re-crawling tonight would record a damaging instruction. Noindex, blocks, errors, and wrong canonicals are instructions; a weak title is a missed opportunity. Fix instructions immediately, even if the fix is a rollback rather than a perfect repair.

Search Console will not rescue your timing: its reports reflect what Google has already processed, so they confirm a bad deploy days later (see why Google Search Console won’t warn you in time). The live checks above are faster, and for releases you did not personally ship, ongoing monitoring catches the deploy you never heard about. Stillindexed monitors client sites every 15 to 30 minutes for noindex, robots.txt, canonical, redirect, sitemap, TLS, and domain-expiry changes, with alerts via Telegram and email; there is a 30-day free trial covering 3 sites with no card required, and plan details are on the pricing page. See the best SEO monitoring tools roundup for how that tooling category compares.

Copy-paste checklist

Copy this into your release ticket and work it top to bottom.

# Check How to verify fast Pass condition
1 Status codes on key URLs curl -s -o /dev/null -w "%{http_code}" -L <url> for homepage + one URL per template Live pages return 200; moved pages redirect once; removed pages return genuine 404/410
2 Meta robots curl -s <url> | grep -i robots or indexability checker No noindex on pages meant to rank
3 X-Robots-Tag header curl -s -I <url> | grep -i x-robots-tag No noindex in response headers
4 robots.txt diff curl -s /robots.txt and diff against pre-deploy copy No new unexplained Disallow; correct Sitemap: line
5 Canonicals curl -s <url> | grep -i canonical per template Canonicals use production host, return 200, self-reference where expected
6 Redirect chains curl -s -I -L <old-url> or redirect checker on old URLs One hop, correct destination, no loops, no blanket homepage redirects
7 Sitemap reachability curl -s -o /dev/null -w "%{http_code}" /sitemap.xml plus spot-check child sitemaps Returns 200, lists current production URLs, no staging or removed URLs
8 Title and H1 per template curl -s <url> | grep -i -o '<title>...' and <h1> check Unique, populated title and one correct H1 on every template
9 Staging header leaks Compare curl -s -I headers between staging and production No staging X-Robots-Tag, auth challenge, environment headers, or debug output in production
10 Analytics and verification tags View source on homepage and one template page Analytics tag and Search Console verification present and firing

If a row fails on one URL, re-run it across every template before fixing, because deploy failures repeat by template. Fix the cannot-wait failures, re-run the table once, and save before-and-after robots.txt and header output with the release notes as the next baseline.

Questions

What should I check first after deploying a website?
The first post-deploy check is whether key URLs return HTTP 200 and are indexable. A post-deploy check should confirm the homepage, key templates, and money pages return 200, carry no noindex directive in meta robots or X-Robots-Tag, and are not blocked by robots.txt. That order catches the failures that remove pages from search before cosmetic issues matter.
How do I check for noindex after a deploy?
A noindex check after a deploy must inspect both the HTML head and the response headers. Meta robots noindex appears in page source, while an X-Robots-Tag noindex header is set by the server, CDN, or framework and never appears in view-source. Checking only one location misses the other, and either directive alone is enough to exclude a URL from Google's index.
Why does robots.txt matter after a release?
Robots.txt matters after a release because a staging robots.txt file can be deployed to production and block crawling of the entire site. Comparing the live robots.txt file against the pre-deploy version reveals a new Disallow rule immediately. A robots.txt block prevents Googlebot from crawling affected URLs, so Google cannot discover that pages have been fixed until the block is removed.
What SEO problems can wait a day after a deploy?
Minor post-deploy issues that can wait a day include a single missing title on a low-value page, a short new redirect chain on an unimportant URL, and sitemap entries that need tidying. Post-deploy problems that cannot wait include sitewide noindex, a blocking robots.txt rule, broken status codes on key templates, and canonical tags pointing at staging. Triage depends on reach, not on how visible the flaw looks.
How long does a bad deploy take to affect rankings?
A bad deploy affects rankings on Google's crawl schedule, not on the deploy schedule. Google must re-crawl a URL, process a noindex directive, a canonical change, or a redirect, and then update the index. Frequently crawled homepages can change within hours, while deeper pages may take days or weeks. Search Console reports confirm the change after processing, which is why live checks matter sooner.