Search Console still lists 1,200 indexed URLs. The new sitemap has 180.
That gap is where organic traffic dies, and it dies before anyone touches DNS. A website rebuild seo job is not a design sprint with a redirect tab added after sign-off. It is an inventory, then a crawl and staging problem, then a cutover. We run it in that order because the reverse order is how money pages vanish from the index.
The next useful thing is not another mockup review. It is a list of every URL that currently earns impressions, and a written decision for each one.
The inventory comes before design sign-off
We pull three lists and we refuse to merge them until the overlaps are visible.
Search Console coverage and performance, sixteen months if the property has it. A full crawl of the live host, including parameters, PDFs, attachments, and URLs the CMS still serves after the nav stopped linking them. Analytics landing pages with sessions, including the campaign leftovers nobody put in the deck.
Those three lists never match. That mismatch is the work. Blog pagination Google still indexes, retired product filters, location pages from a franchise experiment, PDF spec sheets that rank for model numbers - they sit in Search Console whether the new information architecture admits they exist or not.
We tag every URL: keep 1:1, consolidate onto a stronger URL, drop with a 410 or a reasoned 301, or hold for copy. Drop is a decision. If a URL has impressions and a query we still care about, it does not collapse into a homepage catch-all.
New website seo work starts on this sheet because a template cannot protect a URL nobody listed. Design can keep moving. The IA cannot be called final until this list has an owner.
Staging that does not leak into the index
Staging is where rebuilds bleed. A preview subdomain with no authentication, a copied robots.txt that says Allow, a canonical that already names itself on the staging host - Googlebot does not wait for the launch email.
We put staging behind basic auth or an IP allowlist first. X-Robots-Tag noindex on every staging response as well. Canonicals on staging never treat the preview host as the indexable one, and they never point at production URLs while the HTML is still a draft. A canonical from unfinished staging onto a live money URL can attach thin or broken content to the address we are trying to keep.
Live robots.txt and staging robots.txt are two files. Mix them on launch night and the index learns the wrong host. We also check that the new CMS has not emitted a sitemap of staging URLs and pinged it.
If Google already crawled the preview, we use removals for that host and we wait. We do not launch on top of an indexed theme demo. If the marketing lead already shared staging in Slack without auth, we assume it was crawled and we verify before arguing about colour.
Redirect maps that cover every live URL
A redirect map is not the pages the designer kept. It is a row for every URL in the inventory.
301 for a permanent move. 302 only when the move is genuinely temporary, which on a rebuild it almost never is. Chains are a defect. If A used to go to B and B now goes to C, A goes to C in one hop. We test that against the map with request logs, not by clicking the new nav.
We do not 301 everything to the homepage. That is a soft 404 with a green status code. The queries those URLs ranked for do not transfer, because the destination does not answer them.
Trailing slashes, case, and www versus apex need explicit rules, not leftover server defaults. If the live site mixed `/Page` and `/page`, we pick one and 301 the other before the new CMS invents a third. Query strings from old faceted nav go on the map even when the new filters use a different pattern.
PDFs, image URLs that rank, `.html` aliases, and print views go on the map. If we cannot host the file, we still name a destination. Silence is a 404, and a 404 on a ranking asset is traffic we chose to lose.
This is the core of our technical SEO services Philippines work on a rebuild: crawl, indexation, redirects, and the staging rules that keep the live index intact until cutover. Front-end can ship components in parallel. They cannot skip the map.
Canonicals after the information architecture changes
When the IA collapses four category URLs into one hub, the canonical is an instruction, not a badge in the `<head>`.
We set self-referencing canonicals on the winner. Losers 301. Canonical alone is a hint. A 301 is a move. We only run both when a URL must still exist for a short window, and we put an end date on that window.
Parameter URLs from the old faceted nav linger. If the new site still generates them, we noindex or canonical them in the template on purpose. Hoping Google will “figure it out” is how filter URLs come back six weeks after launch.
Pagination, if it still exists, gets one rule written down. Rel next/prev is gone from Google’s playbook. We do not rebuild it. We decide whether paginated pages are indexable, and we bake that into the template before anyone pastes content.
Duplicate templates - the same H1 on twenty location pages with three words swapped - will look like a new-site problem even when it was an old-site problem. Rebuild is the moment we stop shipping that pattern, or we accept the index will treat them as one page with extras.
Metadata that travels with the page, not the template
CMS rebuilds love a single title pattern. `%title% | Brand`. That pattern wipes years of query-matched titles in one import.
We export current titles, meta descriptions, H1s, and the query each URL actually earns impressions for. Then we map them onto the new URL. If the new theme truncates at 60 characters and the old title was working at 68, the theme loses.
New pages get new metadata. Old pages that move 1:1 keep what was earning impressions unless we have a reason tied to the query. Brand consistency is not a reason when the old title still matches a commercial search.
Open Graph and schema get the same pass. A rebuild that drops Product, Article, or FAQ schema because the new theme skipped the plugin is an on-page regression. We check rendered HTML, not the CMS field that says the module is on.
This mapping is the on page SEO services Philippines half of a rebuild: titles, headings, internal links, and the copy that has to land on the right URL the night we switch. It lives in a sheet beside the redirect map, not in the CMS after launch.
URL structure we will not have to unwind later
New paths feel free. They are not. Every changed slug is a redirect we now maintain for years, and every redirect is a hop that can be misconfigured later by someone who never saw this project.
We keep a URL when the page intent is the same. We change a URL when the IA is genuinely different and the old path would mislead. Vanity is not a reason. Folder depth is not a reason unless crawl and humans both suffer. `/services/technical-seo/` to `/what-we-do/tech/` is a rebrand, not an SEO improvement.
Hyphens, encoding, ASCII, and lowercase are crawl rules. We follow the Google URL structure docs when we freeze the new patterns, because mixed case, spaces, and underscore-versus-hyphen habits from an old CMS get recrawled as separate URLs if the new stack emits them.
Dates in blog slugs, uppercase category names, and leftover session IDs all come back as duplicates. We freeze the pattern on staging and we crawl staging for accidental variants before anyone calls the IA done.
If the rebuild also wants a domain change, that is a different job: both properties verified in Search Console, change of address, 1:1 host-level redirects, and a longer watch. Same-domain rebuild is already enough risk. We do not bundle a new TLD because the brand deck likes it.
On-page work that survives the rebuild
Internal links in body copy are the ones the new nav will not save. We crawl the live site for in-content anchors that point at URLs we are moving. Those links get rewritten in the content. Leaving them to hop through 301s forever is how we inherit a chain we then have to explain in six months.
Heading order breaks when a theme wraps every block in an H2. We check templates with real copy, not lorem. If the H1 disappeared into a hero component, we put it back in the HTML, not only in the design file.
Thin category pages that ranked because they had ten unique paragraphs will fall over if the new CMS renders a filter grid and two sentences. Rebuild is when we write the copy or we drop the URL. Serving the grid and hoping is how category traffic falls off a week after launch.
Images: new filenames, stripped alt text, lazy-load that never paints the LCP image. We carry alt text in the migration. We do not rename every file for cleanliness unless we also 301 the old image URLs that still rank in image search.
JavaScript-rendered rebuilds - Next, Nuxt, a headless front on top of the old CMS - need a rendered crawl, not a view-source crawl. If the H1, the internal links, or the product data only appear after hydration, we fix that before cutover. Google can render. It does not owe us a clean render on the first pass of a new stack.
Cutover, sitemaps and the first 14 days
Launch is a sequence, not a Friday deploy.
Final crawl of staging against the redirect map. Status codes, chains, loops, and 404s that should have been 301s. We submit nothing from staging. The production sitemap is built from the keep-and-consolidate list, not from every URL the CMS can emit.
At cutover: production robots.txt allows the paths we care about, staging stays blocked, XML sitemap lists only the URLs we want indexed, lastmod is honest. We send the new sitemap in Search Console the same hour the host switch completes.
We watch coverage and 404 reports, not a rank tracker screenshot. Indexed URL count should move toward the new sitemap size without a collapse in impressions on the URLs we kept 1:1. A spike in 404s means the map missed a path. We fix those the same day.
The old host stays able to 301 for as long as the contract allows. Turning it off the night of launch, before Googlebot has recrawled the heavy URLs, is how equity turns into NXDOMAIN. Log files for the first fortnight show what Googlebot actually requested. If it is still hitting old paths, the 301s had better fire. If it is hitting staging, we failed the leak test.
URL Inspection on a sample of money pages the morning after: rendered HTML, canonical Google chose, last crawl. If Google chose a canonical we did not intend, we fix the tag and the 301, not the copy on the blog.
What we need before we scope the audit
Search Console access on the live property. A current crawl if one exists. The proposed sitemap or IA, even if it is still a spreadsheet. A staging URL we can authenticate to. If the rebuild only lives in Figma, we still start from the live URL list, not the frames.
We need three answers up front: is the CMS changing, is the domain changing, and has anyone already pushed staging without noindex. Those three answers change the sequence. A headless rebuild with an already-indexed preview is a different first week from a same-CMS theme swap that has never been crawled.
We also need a freeze point. If slugs and copy keep moving after we lock the redirect map, the map is fiction. The marketing lead owns that freeze, or it does not exist. Other vendors can keep polishing components. They do not get to rename `/services/` the night before cutover.
Robots, canonicals, metadata fields, status codes, and the sitemap are not theme options. They are the job. If the front-end vendor cannot expose them, we say so before anyone books a launch window.
The next useful step
If the inventory gap is real - hundreds of live URLs and a new IA that does not account for them - do not set a launch date until the map exists.
Export Search Console pages. Run the crawl. Mark keep, consolidate, or drop. That sheet is the next useful thing. It takes a few days, not a quarter, and it tells you whether this rebuild is a 1:1 move with a new skin or a consolidation that will drop URLs on purpose.
When the sheet shows risk you do not want to carry alone, request a scoped audit. We will say whether this is an SEO-first cutover we can sequence, or a redesign that still needs the map before anyone touches DNS. If it is not a fit, we will say that too.
