Web DevelopmentProfessional services

Building a Website With SEO Designed In

SEO retrofitted is remedial work. Here is what it looks like when the structure is right from day one.

This is an implementation example, not a client case study. It describes how this work is actually carried out — the method, the sequence and the reasoning. No client is named and no result is claimed, because inventing either would make it worthless as evidence.

SEO considerations built into a website's templates and content model

SEO added after launch is repair work. Some of it genuinely is ongoing — content, links, iteration on real data. But the structural half is several times cheaper during the build, and a site built without it starts with a ceiling on what any later SEO work can achieve.

Project type
New build with SEO structure designed in
Sector
Professional services

The challenge

The default outcome of a normal build is a site that looks right and is structurally arbitrary: headings chosen by size, URLs invented per page, schema added by a plugin that guesses, internal links added by whoever remembered. Each is individually minor and collectively caps the site.

The objective

A site where the structural SEO work is finished at launch, so later effort goes into content and authority rather than into fixing the foundations.

Approach

Treat crawlability, semantics and internal linking as build requirements with the same status as browser support — things the build is not finished without, rather than things to look at later.

Implementation

Semantic structure

One H1 per template, describing the page. H2s for sections, H3s beneath. Heading level chosen by meaning, never by how large the text should look — that is what CSS is for.

Landmarks used properly: main, nav, article, aside. These help screen readers and crawlers for the same reason.

URLs decided before build

Short, descriptive, lowercase, two levels maximum, consistent on trailing slashes. Decided once so the site never needs a redirect on day one.

Internal linking in the templates

Breadcrumbs, related content and cluster links generated from the content model. The important consequence: coverage is complete by construction. Nothing is orphaned because someone forgot.

Navigation built as real anchors present in the server-rendered HTML — not buttons, not menus that only mount on hover. A crawler does not hover, and a menu that only exists after a mouse enters it contributes nothing to discovery.

Schema generated from content

Service, Article, BreadcrumbList and FAQPage all built from the same fields that render the page, so markup and visible content cannot disagree.

Explicitly excluded: any review or rating markup not backed by reviews visible on that page. That is a structured-data policy violation and a manual-action risk, and it is easy to ship by accident when a theme adds it unasked.

Rendering

Content present in the initial HTML rather than injected by JavaScript. Rendering is a separate, queued stage for Googlebot, so content that requires JavaScript is indexed more slowly and less reliably.

Performance as a build target

Core Web Vitals thresholds treated as acceptance criteria, measured on a mid-range mobile profile.

Launch checks

Sitemap generated from live data — not baked at build time from a source that might be unavailable. Canonicals self-referencing. One canonical host with 301s from the rest. Nothing accidentally noindexed.

Technology

  • Next.js
  • WordPress
  • JSON-LD
  • Google Search Console
  • Screaming Frog

Decisions worth explaining

Sitemap generated per request, not at build time

A build-time sitemap depends on data being available during the build. When it is not, the failure is silent and the sitemap ships incomplete. This exact failure cost this site eighteen URLs for three months.

No review schema without visible reviews

Unsupported rating markup is one of the more common causes of a structured-data manual action, and the code path is removed entirely rather than left as a discipline someone has to remember.

Navigation as real anchors, submenus hidden with CSS

Conditionally-mounted menus mean their links do not exist in the HTML. Hiding with CSS keeps them crawlable while behaving identically for users.

What it produces

A site launched with its structural SEO complete: crawlable, semantically coherent, internally linked by construction, and emitting schema that matches its own content. What that produces in search depends on content and competition, and is not claimed here.

What it teaches

  • Structural SEO is cheap during a build and expensive afterwards. The gap is the entire argument for doing it early.
  • Silent failures are the dangerous ones. A sitemap that quietly loses URLs looks completely normal.
  • If a crawler has to hover, click or wait for JavaScript to find your links, it will not find them.
  • Schema that contradicts the page is worse than no schema at all.

Related services

Related guides

Worked examples

All case studies