A migration can change the addresses of pages, campaigns and downloads that still receive visits from search results and links on other sites. Redirect mapping records what each of those old addresses should do on the new site.
Build the map before implementation, so content owners can review the destinations and developers can test the agreed decisions.
Why do redirects matter during a migration?
An old URL can still receive visits from search results, bookmarks and links on other sites. If the page moves, the redirect gives those visitors a route to its replacement. Without it, a working link becomes an error page.
Google confirms that 301 and other permanent redirects do not cause a loss in PageRank. That does not promise unchanged rankings after a migration: the replacement content and the rest of the site still matter.
Permanent is the operative word. Googlebot follows a temporary redirect (302 or 307) too, but the indexing pipeline does not take it as a signal that the target should be canonical, so Google generally keeps showing the old URL in search results.
Every migration we run through the Essential Launch Framework includes a redirect strategy as part of Phase 1, before any design or development work begins. We treat it as a first-class deliverable rather than a last-minute checklist item.
How do you build a redirect map?
Build and approve the map before implementing the new routes, then use it to test them.
Step 1: Build the URL inventory
Crawl the current site beyond its navigation. Include posts, campaign pages, downloads, images and archive pages. Combine the crawl with the CMS export, existing sitemaps, analytics landing pages, server logs and backlink records. A crawl that follows internal links cannot find an old campaign URL that nothing on the site links to anymore.
Keep URLs that already redirect or return an error in the inventory. An old redirect may need a new destination, and an existing 404 with incoming links needs a deliberate decision. Deduplicate identical addresses, but preserve differences in hosts, paths and query strings until you have checked what each returns.
Step 2: Add evidence and a decision to every row
Start with these columns. Use full URLs so a domain or protocol change remains visible.
| Column | What to record |
|---|---|
| Old URL | The complete address, including any query string that changes the content |
| Current HTTP status | What it returns today, plus its current destination if it already redirects |
| Impressions and clicks | Search Console figures with the date range, so rows are comparable |
| Backlinks | Linking pages or referring domains, with the source and date checked |
| New URL | The final production address of the relevant replacement, or blank if none exists |
| Decision and response | Keep at 200, move with 301, or remove with 404/410; mark undecided rows explicitly |
| Notes and review | Why this destination fits, who approved it, and any exception to a pattern rule |
Prioritise rows with search traffic, enquiries or valuable incoming links for manual review. Missing data is not the same as zero: mark an unavailable backlink export as unknown. Use a date range that includes your busy season when judging seasonal pages. A quiet month alone is a poor reason to discard a page.
Give every row a decision:
- Keep the address if the page stays there; it needs no migration redirect.
- Redirect a moved page to its direct replacement.
- Map merged pages to the consolidated page that covers their content.
- Review removed content for a relevant replacement or an explicit 404/410 response.
When there is no obvious destination, read the old page and the proposed replacement side by side. Would someone following the old link find the information they came for? The closest equivalent must answer that question. A shared category name alone is not enough. If no relevant replacement exists, record a 404 or 410 decision; Google’s site-move guidance covers error responses for content not carried over. Never fill an unresolved row with the homepage.

Step 3: Review and freeze the mapping before the build
Have the content owner review destination relevance and the developer review whether each rule can be implemented. Resolve blank decisions before approving the map. Record the reviewer and date, then freeze that version before the build starts so the new routes have an agreed basis.
Keep a change log after that approval. If an editor renames a planned page, update its incoming mappings and get the changed rows reviewed. Before launch, compare the original inventory with a fresh export to catch pages published during the build. Freezing the map sets a baseline; it does not make later URLs disappear.
Step 4: Turn patterns into rules without losing exceptions
If /blog/my-post becomes /articles/my-post, a pattern rule may cover the move. Keep the expected destination for each URL in the sheet so you can test the rule against it. Separate renamed slugs, merged posts and removed pages before applying a broad rule. Check that a catch-all cannot intercept an exception.
Review archive, tag and category pages as content in their own right. An old topic collection may match a new topic landing page. A dated archive with no replacement may need a removal decision. Do not send every collection to the main blog index just because both contain posts.
For pagination, compare what each page actually lists. /blog/page/4/ is not automatically equivalent to page four of the new blog if the page size or ordering changes. Preserve a relevant route through the older material, or record why that page has no equivalent. Test pagination rules at the beginning and end of each sequence, including an out-of-range page, so a broad redirect does not manufacture destinations that do not exist.
Step 5: Implement permanent server-side redirects
Ask whoever runs the hosting to implement the map as HTTP 301 redirects for permanent moves. Google also supports 308 and recommends permanent server-side redirects where possible. Inspect the actual response: a page that loads and then forwards the browser is not proof that the server returned a 301.
Keep the redirect configuration available independently of the old CMS. Confirm where it will run after that system is retired and who will maintain it.
Step 6: Test the complete map on staging
Run every old URL against the new site’s routing in staging, the private test environment, before launch. Have the developer route those requests through the same redirect rules intended for production. A preview that tests only new page paths leaves the redirects untested.
Save the requested URL, expected and actual responses, redirect hops, final URL and destination status beside the map. Check each result:
- A moved page reaches its agreed destination directly, and that destination returns 200.
- A removal returns the agreed 404 or 410.
- An unchanged page returns 200 at its existing address.
Then inspect destination content, especially merges and high-value pages. A 200 response can still serve the wrong article. Check each indexable destination’s canonical tag, which identifies its preferred URL, and the internal links pointing to it. They should use the final production address, consistent with Google’s canonicalization guidance.
Fix failed rows and rerun the whole list after rule changes. Keep staging protected, and separately check the intended production settings for accidental indexing blocks. Repeat the redirect test on the live hosts at launch; the staging result cannot prove the production configuration.
How does redirect mapping work for several thousand URLs?
The steps above hold at any size. What changes when you are migrating a site with several thousand old URLs is who decides each row, and how the result gets checked.
Which rows get a person, and which get a rule
| Rows | Who decides | How they are tested |
|---|---|---|
| Rows with search traffic, enquiries or incoming links | A person, row by row, as in Step 2 | Every row, and a person reads each destination |
| URLs that follow one pattern on both sites | A pattern rule, plus its listed exceptions | Every row, against the expected destination in the file |
| Old tags, dated archives and parameters with no traffic or links | A rule or an agreed removal | Every row, plus a sample a person reads for relevance |
| Rows no rule matches | A person | Not tested until a person decides; they stay marked undecided |
Rows with traffic, enquiries or links carry the SEO value of the old site, so they get a person’s decision however large the inventory is.
Cut the list into batches. Group the inventory by section of the site, such as the shop, the blog and the downloads, and give each batch an owner who knows that content. A batch shares its patterns, so a rule and its exceptions are reviewed together. Keep one file and treat a batch as a filter on it, never as a separate copy.
Know what a sample proves. Reading a random sample of rule-mapped rows tells you whether the rule sends pages to relevant destinations. It cannot prove that every row works, because a sample can miss the one exception the rule swallows. Relevance can be sampled. The response is tested on every row.
Keep the map as a file and the test as a run over it. One row per old URL, with fixed column names such as old_url, expected_status, expected_url, priority and note. A CSV export of the review spreadsheet is enough. The test is a script or crawler that requests each old URL against staging, follows each redirect itself, and writes four values back to the row:
| Recorded per row | What it shows |
|---|---|
| First response status | 301, 308, 200, 404 or 410, compared with the expected status |
| Hop count | How many redirects the request passed through before it stopped |
| Final URL | Where the request ended, compared with the expected URL |
| Final status | Whether the destination answers with 200 |
A moved row passes when it takes one hop to the expected URL and that URL returns 200. Removals and unchanged pages pass on the status the file expects. Read the result as the list of failed rows, sorted by priority. A count of redirects that exist says nothing about whether they reach the right pages. Give the run a hop limit, such as the ten hops Googlebot can follow, and mark a row failed when it reaches it: that is also how the run finds most redirect loops.
What changes when the host, protocol or language URLs change?
Choose the final host and protocol before approving destinations. For each moved page, cover HTTP and HTTPS plus www and non-www, including combinations such as http://www.example.com/old-page. Point each old variant straight to the final HTTPS URL in one hop, combining host and path changes. Do not make visitors pass through separate protocol, hostname and path redirects.
Google treats redirects as a strong canonicalization signal. Make canonical tags and internal links agree with that choice. A bare-domain test does not cover www. Ask the developer to test each host, including HTTPS connections before the redirect response.
For multilingual pages, add locale and counterpart references to the map’s notes. Map a German page to its German replacement when one exists; do not derive translated destinations by swapping a language prefix. Once the destinations are agreed, update hreflang annotations to those final addresses before switching on the redirects. Google’s localized-page guidance requires reciprocal links: check the new language versions together, with each set including the page itself. The hreflang and localized URL guide covers how the content model holds those relationships.
Which sitemap should you submit at launch?
Generate the new sitemap from the final URLs and compare it with the approved destinations. Exclude staging addresses and redirecting URLs from that new list. Fetch it in production after the redirects are active, then submit it in Search Console.
Google’s site-move instructions allow removing the old sitemap at that point. The same page’s monitoring steps also describe submitting both old and new lists to follow indexing progress. If you retain the old list for that purpose, keep it separate from the new sitemap. Redirect warnings on that old list are expected. Removing the old sitemap is a separate action from removing the redirects.
What are the most common redirect mistakes?
After running multiple migrations, we see the same mistakes repeatedly.
Blanket redirects to the homepage. Google warns that sending many old URLs to an irrelevant destination can be treated as a soft 404. A successful redirect response is not enough; check relevance against the map.
Redirect chains. A redirects to B, B to C, C to D. Googlebot can follow up to 10 hops, but Google advises a direct destination, or ideally no more than three hops if that is impossible. Each hop adds latency. Update old rules so A goes straight to D.
Redirect loops. A loop sends a request back to an address it has already passed, so it never reaches a page. Pattern rules can create one by accident: an exception for posts that stay under /blog/ sends /articles/old-name to /blog/old-name, and the catch-all for /blog/* sends it straight back to /articles/old-name. Mozilla’s documentation says the server often detects a redirection loop and answers with a 500 error; when it does not, the browser detects it and shows an error message instead of the page. Google’s page indexing report lists a redirect loop among the redirect errors it gives as reasons a page is not indexed. The staging run catches it: the row either hits the hop limit or ends on a 500, and never reaches its expected URL. Remove one of the two rules and rerun the whole list.
Forgetting query parameters. /products?category=shoes may show different content from /products. Record which parameters select content and which only carry tracking data. Test those cases separately, including combined parameters. Stripping every query string can turn a precise product destination into a generic listing; blindly preserving them can leave obsolete filters on the new URL.
Not handling trailing slashes. /about and /about/ are technically different URLs. If your old site used trailing slashes and your new site does not (or vice versa), you need redirects for both variants.
Ignoring non-HTML assets. PDFs, images, and downloadable files can have significant backlink profiles. If your old site hosts a whitepaper at /downloads/report-2024.pdf and other sites link to it, that URL needs a redirect too.
How long should redirects stay in place?
Google recommends keeping redirects for as long as possible, generally at least a year. Plan their ownership beyond launch, including the old domain and hosting configuration needed to serve them.
Keep useful redirects longer while external links and bookmarks still send visitors to them. Update links you control to the final addresses. Before retiring a rule, check usage and incoming links, then record the reason in the map.
Google says most pages on a small to medium-sized site can take a few weeks to move, with larger sites taking longer. That is not a deadline for removing redirects.
What should you monitor after launch?
Compare unexpected 404s and wrong destinations with the approved map. An intentional removal should not be treated as a missed redirect. Check incoming links to priority pages and compare search traffic with the pre-launch baseline. To check SEO after migrating, start with the priority rows from the map in Search Console’s page indexing report first: it lists redirect errors, among them a redirect loop and a redirect chain that was too long, as reasons a page is not indexed.
Google says search visibility may fluctuate temporarily during a move; a calendar date alone cannot diagnose a redirect failure. The first 30 days after a website migration covers the wider monitoring work. Keep the map with its test results so whoever investigates can distinguish an agreed removal from a broken move.
The redirect strategy is part of the migration strategy
Redirects are a core part of the migration strategy that should be planned, documented, and tested from the very beginning of the project, well before the week of launch.
At Essential Code, redirect mapping is a deliverable in Phase 1 of every migration we run. By the time we start building, the redirect strategy is already approved. By the time we launch, it has been tested against the full URL inventory.
Redirects are one part of the larger migration scope. The headless CMS migration guide covers what the full sequence looks like, from discovery through content architecture and build to go-live.
If you are planning a migration and have not started thinking about redirects yet, the first step is understanding what you are working with. A Headless Audit maps your current site, identifies the technical and content challenges, and gives you a clear picture of the migration scope, including the redirect work, before you commit to a full migration. Most of the migrations we run start on WordPress, and the redirect work there has its own set of gotchas, from /?p=123 query patterns to pretty permalinks. We cover those in detail on our WordPress to headless page.