Case study · AI + SaaS Products
Rebuilding a website as search infrastructure
A redesign can look excellent and still be invisible to search. A website is not only a visual artifact: it is the infrastructure search engines and AI systems crawl, index, and interpret, and the work is rebuilding that foundation for crawlability, speed, structure, and machine-readability, not just the look.
- Client-rendered content
- Duplicate URLs, no canonical
- Stale or missing sitemap
- Templated metadata
- No structured data
- Client
- a B2B services and e-commerce company
- Problem
- A pretty site that search engines cannot crawl, index, or interpret, so it is effectively invisible.
- Approach
- Rebuild for crawlability, indexation, speed, clean IA, canonicalization, metadata, schema, and internal linking.
The problem
A redesign can look excellent and still be invisible to search. Pages render client-side with nothing for a crawler to read, important content sits behind scripts, canonical tags are missing or wrong so duplicate URLs split signal, the sitemap is stale, metadata is templated identically across pages, and there is no structured data. The site is a brochure a person can admire and a machine cannot parse.
Treating a website as a visual artifact misses that it is also infrastructure: the thing search engines and AI systems crawl, index, and interpret. If that layer is broken, no amount of content or design earns visibility.
The reality behind the problem
A redesign is the natural moment to fix search, and teams assume a better-looking site must perform better. It usually does not move the needle, because the things that make a site findable, server-rendered content, clean canonicalization, an honest sitemap, structured data, live underneath the visual layer and a redesign rarely touches them. The new site looks modern and stays just as invisible.
The harder truth is that the infrastructure problems are the ones nobody sees in a browser. Duplicate URLs splitting ranking signal, content that only appears after client-side execution, metadata templated identically across pages: none of it shows up in a design review, so it survives the rebuild unless the rebuild is scoped as search engineering rather than decoration.
What was assumed
The redesign will improve our search presence because it looks better.
What Stallwart asked
Can a crawler reach, read, and correctly interpret every page that matters?
The desired outcome
The target is not a better-looking site. It is a site a crawler can reach, read, and correctly interpret, so content and design finally have a foundation that earns visibility.
- Content that matters is server-rendered, so a crawler reads it without executing scripts.
- Canonical URLs collapse duplicates onto one namespace, so ranking signal concentrates instead of splitting.
- The sitemap reflects real content with honest lastmod dates, not a stale or generated guess.
- Metadata is unique and intent-led per page, not templated identically across the site.
- Structured data states what each page is, so search and AI systems parse it directly.
- Internal links route authority to the pages meant to rank and map the topic graph for crawlers.
The system we designed
This rebuild treats the site as search infrastructure. Content that matters is server-rendered so a crawler reads it without executing scripts, the information architecture maps to how topics and intents relate, canonical URLs collapse duplicates onto one namespace so ranking signal concentrates, and the sitemap reflects real content with honest lastmod dates. Metadata is unique and intent-led per page, and page speed is engineered rather than hoped for.
Structured data (JSON-LD) and descriptive internal linking make the site machine-readable and route authority to the pages meant to rank. Landing-page structure is built for both search intent and conversion. Stallwart builds its own site on these foundations: server-rendered content, a data-driven sitemap with real lastmod, canonical www enforcement, and structured data on every page.
How it works
- 01
Make the site crawlable and indexable first
Server-render the content that matters, fix canonicalization so duplicates stop splitting signal, and ship an honest sitemap. Until a crawler can reach and read the pages, nothing else about SEO applies.
- 02
Engineer speed and structure, do not hope for them
Page speed and a clean information architecture are build decisions, not afterthoughts. Both affect how search systems crawl and rank, and how users convert once they arrive.
- 03
Make it machine-readable and well-linked
Structured data states what each page is, and descriptive internal links route authority and map the topic graph for crawlers and AI retrieval alike.
The infrastructure
From a brochure a machine cannot read to a crawlable surface.
Before
- Client-rendered content
- Duplicate URLs, no canonical
- Stale or missing sitemap
- Templated metadata
- No structured data
Looks good, invisible to search: client-only rendering, split signal, no schema.
After
- Server-rendered content
- Canonical, one namespace
- Data-driven sitemap, real lastmod
- Unique, intent-led metadata
- Structured data + internal links
Built as infrastructure: crawlable, consolidated, machine-readable.
Architecture
What sits underneath.
Underneath the rebuild are four layers a search system reads, each engineered rather than inherited from the old site.
Rendering and crawlability layer
Content that needs to be found is server-rendered so a crawler reads it without executing scripts, and important content is kept out from behind interactions that a retriever never triggers.
Canonicalization and routing layer
Canonical URLs collapse duplicate and parameterized paths onto one namespace, and routing enforces a single host, so ranking signal concentrates instead of splitting across near-identical URLs.
Sitemap and metadata layer
The sitemap is generated from real content with honest lastmod dates, and metadata is unique and intent-led per page, so a crawler gets an accurate map and a distinct description of every page.
Structured-data and linking layer
JSON-LD structured data states what each page is, and descriptive internal links route authority and map the topic graph, so the site stays legible to both search crawlers and AI retrieval.
The hard parts
Where the engineering judgment was.
Server-render content that needs to be found
If important content only exists after client-side execution, a crawler or AI retriever may never see it. Server rendering makes the content a first-class, readable surface.
The trade-off
More engineering than a purely client-rendered site, which is the cost of being indexable.
Treat the rebuild as infrastructure, not decoration
Crawlability, canonicalization, speed, and schema decide visibility. A redesign that skips them is a new coat of paint on an invisible site.
The trade-off
Design and search engineering have to be planned together, not handed off in sequence.
Reliability & guardrails
How it avoids the wrong call.
The guardrails keep the infrastructure honest, so a crawler never hits a contradiction or a dead end.
One URL per thing
Canonical tags and host enforcement keep a single authoritative URL for each page, because duplicate and parameterized paths split ranking signal and make an engine pick the wrong one to index.
A sitemap that tells the truth
The sitemap is generated from the real content with accurate lastmod dates, so a crawler is pointed at pages that exist and told honestly when they changed, rather than chasing a stale list.
Content a crawler can actually reach
Server rendering and sensible status codes make the important content readable without script execution, so a crawler or AI retriever is not left guessing at an empty shell.
Schema validated, not assumed
Structured data is checked against its schema so a broken or incomplete definition is caught before it ships, rather than quietly feeding an engine a wrong statement about the page.
Productionization
What turns it from a demo into software.
What keeps the infrastructure correct as the site grows, rather than correct at launch and broken a quarter later.
Sitemap generated from source
The sitemap is built from the site's own content at build time, so it tracks pages as they are added or removed instead of drifting into a hand-maintained list that goes stale.
Canonical and redirect rules in the build
Canonicalization and host enforcement are codified rather than set by hand per page, so new routes inherit the right rules and do not reintroduce duplicate URLs.
Structured-data validation on ship
Schema is validated as part of the build, so an incomplete or malformed entity definition fails the pipeline instead of reaching an engine that reads it wrong.
Performance held as a budget
Page speed is treated as a build budget measured on each change, so a regression is caught in the pipeline rather than discovered later in crawl and ranking behavior.
What changed
The change is in what the site is to a machine. Instead of a brochure a person can admire and a crawler cannot parse, it is a readable surface: content that renders server-side, one URL per page, an honest sitemap, and structured data that states what each page is. The infrastructure that decides visibility is finally built, not hoped for.
Design and content now sit on a foundation that can carry them. The rebuild does not promise a ranking, which depends on competition and relevance no engineering controls, but it removes the technical reasons a site stays invisible, so the work above it can finally register.
- Content renders server-side, so a crawler reads it without executing scripts.
- Duplicate URLs collapse onto one canonical namespace, concentrating ranking signal.
- The sitemap and metadata describe the real site, honestly and per page.
- Structured data and internal links make the site legible to search and AI retrieval.
Ownership & handover
What you receive, and keep.
At handover, the rebuilt infrastructure and the rules that keep it correct are yours.
- The server-rendered site and the rendering decisions behind each page type.
- The canonicalization, host-enforcement, and redirect rules, codified in the build.
- The data-driven sitemap generation and the metadata conventions per page.
- The structured-data templates and the internal-linking model for the topic graph.
- Runbooks for adding pages, validating schema, and holding the performance budget.
What we learned
The insight that generalizes: a website is infrastructure before it is a design. Crawlability, canonicalization, an honest sitemap, and structured data decide whether anything above them can be found, so they belong in the rebuild from the start, not bolted on after the visuals are signed off. Make the site legible to a machine first, and content and design finally have a surface that works.
This work connects to
- AI + SaaS Products
- Technical SEO
- Website rebuild and web engineering
- Crawlability, indexation, canonicalization
- Structured data and internal linking
Frequently asked
What is technical SEO?
Technical SEO is the engineering that makes a website crawlable, indexable, and interpretable by search engines and AI systems: server rendering, canonical URLs, sitemaps, page speed, information architecture, metadata, structured data, and internal linking. It is the foundation content and design sit on.
Why does a website rebuild affect search visibility?
Because a site is the surface search engines and AI systems crawl. A rebuild can fix crawlability, consolidate duplicate URLs with canonicalization, improve speed and architecture, and add structured data, all of which change how, and whether, the site can be indexed and understood.
Can a good-looking site still be invisible to search?
Yes. A site can be visually polished and still unreadable to crawlers if content is client-rendered only, canonicalization is broken, the sitemap is stale, and there is no structured data. Visibility depends on the infrastructure layer, not the visual layer.
Will a rebuild hurt my existing rankings?
Not if it is handled as search engineering. A rebuild preserves equity by mapping old URLs to new ones with correct redirects, keeping canonical signals intact, and submitting an accurate sitemap, so ranking signal carries over instead of being dropped. The risk comes from rebuilds that change URLs without that migration, not from rebuilding itself.
Does Stallwart do this on its own site?
Yes, and it is publicly verifiable. Stallwart's own site is built on these foundations: server-rendered content, a data-driven sitemap with real lastmod dates, canonical host enforcement, and structured data on every page. The approach it applies in a rebuild is the one it runs on itself, visible in the site's own markup and sitemap.
Is your redesign invisible to the systems that rank it?
We treat a website as search infrastructure. Bring the site and we will scope the rebuild that makes it crawlable, fast, and machine-readable.
Last updated: October 13, 2026