Skip to content
ROI Synth

Technical SEO services for coded websites

Technical SEO is the engineering half of SEO: making sure search engines can reach, render, understand and index the pages your coded website serves. This page explains the technical work in depth — crawling, rendering, indexing, canonicals, redirects, structured data and performance. The work itself is delivered inside the SEO offer, which plans technical, structural, content and measurement work as one monthly programme.

$200starting price · per month

Part of the SEO offer

Who Technical SEO is for

Not sure whether this is the right offer? Contact us with your website and we will say plainly.

  • Developers and founders who own a Next.js, React or similar code-first site
  • Teams whose pages render for users but index inconsistently in Search Console
  • Businesses preparing a redesign or migration and needing the technical plan first
  • Sites with faceted filters, parameter URLs or internal search creating thousands of near-duplicates
  • Anyone who has received a generic technical audit and wants the fixes actually shipped

What this work fixes

Pages render but do not index
Client-side rendering, conflicting directives and duplicate signals keep finished pages out of the index.
One template bug, hundreds of affected URLs
A canonical or metadata rule implemented once multiplies across every page generated from that template.
Crawl budget is spent on noise
Parameters, filters and soft errors absorb crawls that should reach the pages that earn money.
Redirects and canonicals disagree
Mixed signals between sitemaps, redirects and canonical tags leave search engines to guess.
Performance is a guess
Slow first paint and layout shift are discussed from feelings rather than field data.

What you receive

  • Technical audit of templates

    Crawl, rendering and indexation reviewed per template, with findings that name the affected code and URLs.

  • Indexation rules

    A deliberate index or no-index decision per template, with conflicting signals resolved.

  • Canonical and redirect implementation

    Rules shipped in the code and validated with status-code checks.

  • Structured data from content

    JSON-LD generated from typed page data, so it cannot drift from what visitors read.

  • Performance work with field data

    Diagnosis from Core Web Vitals field data, with fixes for images, scripts and rendering.

How the work runs

  1. Crawl and collect

    Crawl the site with rendering where needed, and pull indexing, coverage and performance data for the same period.

  2. Analyse by template

    Group findings by page template, because most technical problems are template problems that affect many URLs at once.

  3. Fix in the code

    Ship the fixes in the templates and rules — canonicals, metadata, redirects, structured data, rendering — not in a document.

  4. Verify and report

    Re-crawl after shipping and confirm indexation changes in Search Console over the following weeks.

Crawling, rendering, indexing: the three gates

A search engine must pass your page through three gates before it can matter. Crawling means the page is reachable: correct links, no accidental blocks, no status-code surprises. Rendering means the complete content exists in the HTML the crawler receives — on coded sites the usual fix is server-side rendering or static generation instead of a client-only shell. Indexing means the page carries one consistent signal about its identity: one canonical, one title, one place in the sitemap. Most technical SEO work is simply running each template through these three gates and fixing where it fails — and verifying afterwards, in Search Console's coverage data, that the fix actually took.

Templates are where the bugs live

A generic audit lists thousands of affected URLs and implies thousands of fixes. On a coded site the real unit is the template: one component generates every service page, another every blog post. Fix the template and every URL it generates is fixed at once. That is why this work is done in the repository — the canonical rule lives beside the component that renders the page, so the two cannot drift apart — and why the SEO offer treats technical, structural and content work as one programme rather than a separate sprint. The follow-up crawls and the coverage report are then read per template, so one stubborn page type never hides inside an otherwise healthy average.

What technical SEO cannot do

Technical work removes obstacles; it does not create demand or relevance. A perfectly crawlable page with thin content still ranks nowhere, and no technical fix guarantees a position, an indexation date or a ranking improvement. Google's own documentation — including its SEO Starter Guide — describes these fundamentals as necessary conditions, not levers. We follow that guidance, ship the fixes with evidence, and report the indexation changes in your Search Console as they develop.

Migrations and redesigns

The highest-risk technical moments for a coded site are migrations and redesigns: a new framework, a new domain, or a rebuilt information architecture can quietly discard everything the site had earned. The technical work for those moments is a redirect map that covers every current URL, templates that preserve metadata and structured data rules, staging checks before go-live, and post-launch monitoring of indexation and crawl errors for the weeks that follow. Done in the repository, with the redirects beside the routes they serve, a migration becomes a reviewable change instead of a gamble.

Performance as part of the technical work

Performance is measured, not claimed. The technical side covers the controllable causes of slow pages: server-rendered output instead of client-only shells, images delivered at the size each layout needs, scripts kept lean and loaded without blocking the content, and caching where it helps repeat visitors. Then the measurement comes from field data — Core Web Vitals in Search Console, and your own analytics — so the work is judged by what real visitors experience, not by a lab score on a fast machine. That measurement is reported honestly, including where it still falls short and why, so the next month's scope is driven by the biggest remaining gap.

Technical problems that hide on coded sites

Technical SEO is the part of SEO that decides whether search engines can reach, render and index your pages at all. On page-builder sites the platform makes most of those decisions for you. On a custom-coded site, your team made them — often without knowing they were SEO decisions. A routing choice, a data-fetching pattern or a middleware rule can quietly remove hundreds of pages from search.

These are issues we regularly find on Next.js, React and other JavaScript-heavy sites. Each is invisible in a browser and obvious in the right tool.

  • Pages that render their main content only in the browser, leaving the server response close to empty.
  • A catch-all route that returns a friendly "not found" page with a 200 status, so search engines index thousands of empty URLs.
  • Middleware or locale detection that redirects crawlers differently from visitors.
  • Canonical tags built from the request URL, so every tracking parameter creates a new canonical page.
  • Preview and staging deployments that are publicly reachable and indexable.
  • Images and scripts that block the main content from appearing quickly on mid-range phones.

How we diagnose before we change anything

A technical review on a coded site looks at three layers: what the server returns, what the browser builds from it, and what the search engine reports it has done with it. Comparing the three is where the real problems show up.

  • Raw HTML versus rendered page

    We fetch each template the way a crawler first sees it and compare it with the fully rendered result, to see what depends on JavaScript.

  • Status codes and redirects

    Every route type checked for the right status: real pages 200, moved pages 301 or 308, missing pages 404 or 410 — never a soft 404.

  • Indexing evidence

    Search Console's page indexing report, grouped by template, tells us which page types are excluded and why.

  • Field performance

    Core Web Vitals from real visitors where available, because lab scores alone can be misleading on fast developer machines.

  • Crawl paths

    Internal links, sitemaps and pagination checked to confirm every important page can be found without a search box.

The output is a list of fixes ranked by impact and effort, each with the evidence that justified it and the template it affects. Google's SEO Starter Guide and its documentation on JavaScript and page indexing shape the standards we apply.

Typical fixes, and where they live in the code

Because the problems are in the code, so are the fixes. Most land in a small number of shared files, which is why technical SEO on a coded site can be both efficient and durable.

Common technical fixes on coded websites
ProblemUsual fixWhere it lives
Same title on every pagePer-route metadata generated from page dataLayout and route metadata functions
Content only in the browserServer or static rendering for indexable contentData fetching in page components
Soft 404sReturn a real 404 for unknown slugsDynamic route handlers
Parameter duplicatesCanonicals built from clean paths; parameter rulesMetadata helper and middleware
Stale sitemapSitemap generated from the content sourceSitemap route
Indexable previewsNoindex header for non-production hostsFramework or hosting configuration

How long technical work takes

Technical SEO is delivered within the SEO offer, so it follows the same monthly rhythm. The first month is weighted heavily towards diagnosis and the highest-impact fixes; later months shift towards prevention and the remaining smaller items.

On a small coded site, the review and first fixes usually fit within the first month. Larger sites with many templates, locales or rendering modes take longer, and the written scope says what will be covered in which month. Fixes go live as they are merged; search engines then need time to recrawl, so indexing changes typically show over the following weeks rather than days.

How technical progress is shown

Technical work is easy to measure honestly because most of it is binary: the status code is right or it is not; the canonical is clean or it is not. Each fix is listed with a before-and-after check. Over the following weeks, the report follows the indexing of affected templates in Search Console and the field performance data where enough visits exist.

What we do not do is attribute every ranking movement to a technical fix. Technical work removes obstacles. Whether pages then rank depends on their content, competition and demand — which is why technical SEO sits inside the wider SEO programme rather than being sold alone.

Questions developers ask about technical SEO

Technical SEO is usually discussed with developers as well as managers. These are the questions engineering teams tend to raise.

  • "Will you rewrite our architecture?"

    No. Fixes are targeted changes in the files responsible, reviewed by your team. Larger changes are proposed with reasons, never imposed.

  • "Do you follow our conventions?"

    Yes. We follow your branching, linting, testing and review practices, and keep changes small enough to review quickly.

  • "Can SEO checks run in CI?"

    Often, yes. Simple checks for metadata, status codes, sitemaps and structured data can run alongside your existing tests.

  • "What if a fix conflicts with product work?"

    Priorities are agreed with you. We explain the search impact so the trade-off is an informed decision.

Catching regressions before they cost you

Technical SEO problems are rarely fixed once and forgotten. Every release can reintroduce them: a refactor that drops metadata from a route, a dependency upgrade that changes rendering, a new feature that creates parameter URLs. On busy codebases, the question is not whether a regression will happen but how quickly it is noticed.

Inside the SEO offer we monitor in three ways. Follow-up crawls after significant releases compare templates with their last known good state. Search Console's indexing and enhancement reports are reviewed for sudden changes in excluded pages or markup errors. And where your workflow allows, automated checks in your build or test suite fail fast when a page loses its title, returns the wrong status or emits invalid structured data. Together they turn technical SEO from a one-off project into a quiet, continuous safeguard.

What technical SEO leaves behind

Technical work inside the SEO offer produces visible changes and lasting safeguards. You receive findings grouped by template with the evidence behind each, fixes implemented in your repository and listed in the progress sheet with before-and-after checks, and a short set of development notes describing the indexing, metadata and rendering rules new page types should follow.

Where your workflow supports it, you also receive automated checks — for titles, status codes, sitemaps and structured data — that run with your existing tests. Those checks are often the most valuable deliverable of all, because they keep the site healthy long after the original problems have been forgotten.

A note on JavaScript and search engines

Google can render JavaScript, but rendering may happen later than the first crawl, and other search engines and AI crawlers vary in how much JavaScript they process. Content that matters for search — headings, main text, links, prices, structured data — is safest in the initial HTML response. On frameworks with server rendering or static generation, that is usually a small change in how each template fetches its data.

Which package includes technical SEO

Technical SEO is part of SEO, from $200 per month, and of All-in-One SEO + AEO + GEO, from $300 per month. There is no separate technical-only price, because fixing crawling and indexing without improving the pages that are then indexed rarely pays off on its own.

If the technical problems are structural — a framework that cannot render server-side, a hosted builder that controls your URLs — the Next.js + TypeScript Website Build from $1,000 one time is often cheaper than working around the platform month after month. Try the free website audit for a quick automated look at one page before you get in touch.

What technical SEO is, in plain terms

Technical SEO is the engineering work that makes a website's pages reachable, renderable, understandable and indexable: crawling, rendering, canonicals, redirects, sitemaps, robots rules, structured data and performance. On coded websites it is implemented in the templates and shipped through the repository. It is part of the SEO offer on this site, not a separately priced product — and it is verified in the coverage data of your own Search Console, so progress is measured, not claimed.

Measured with

  • Indexed pages per template before and after fixes
  • Crawl errors, redirect chains and canonical conflicts in follow-up crawls
  • Core Web Vitals field data for affected templates
  • Search Console coverage states over the following weeks

Honest limits

  • Canonical tags are hints, not directives; search engines can choose differently
  • Indexation changes depend on recrawling, which no one controls
  • A clean technical foundation does not by itself improve rankings

What Technical SEO costs

Published starting prices in US dollars. The exact figure for your site is agreed in a written scope before any work or billing starts.

SEO

$200per month, starting price

Ongoing search engine optimization for coded websites: crawlability, site structure, content and measurement, implemented on your site.

  • Technical implementation in your templates and pages
  • Keyword and search-intent mapping for your services
  • Landing pages, content and internal links in scope
  • Metadata, canonicals, sitemaps and structured data
  • Search Console and analytics reporting
The six offers and their published starting prices (USD)
OfferStarting priceBillingBest for
SEO (this page)$200Per monthBusinesses that want steady search growth on a custom-coded website.
AEO$150Per monthBusinesses whose buyers ask specific questions before contacting.
GEO$200Per monthBusinesses that want to be described accurately by AI assistants.
All-in-One SEO + AEO + GEO$300Per monthBusinesses that want search, answers and AI visibility handled as one programme.
Local SEO$100Per monthBusinesses that serve customers in specific cities or regions.
Next.js + TypeScript Website Build$1,000One timeBusinesses held back by a slow, template-locked or hard-to-edit site.

Read how pricing works for what moves a quote away from the starting figure.

What you can hold us to

Commitments written into every scope, not marketing claims. You can check each one against what we deliver.

  1. We implement, not just advise

    Within the agreed scope we change templates, build pages, write content and fix technical issues on your website. Recommendations alone are not the deliverable.

  2. Built for coded websites

    The work targets custom-built sites — Next.js, TypeScript and other code-first stacks — where changes are made in templates, components and data, not page-builder panels.

  3. A written scope before work starts

    Deliverables, quantities, responsibilities and price are agreed in writing before work begins. Changes go through a written scope-change step.

  4. Monthly work, visible as it happens

    A shared progress sheet is updated every week with completed work, pages changed and evidence URLs. Only checked work is reported as complete.

  5. Measured in your own accounts

    Progress is reported from your Search Console and analytics, kept separate from the record of work done, so you can check every figure.

  6. No promises we cannot keep

    We never promise rankings, AI citations, traffic or leads. Written scopes list those as exclusions and say what the work can and cannot do.

See how we work and what we commit to, how offers are priced or contact us with your questions.

Questions buyers ask

Is technical SEO priced separately?

No. Technical work is delivered inside the SEO offer, which plans technical, structural, content and measurement work together from $200 per month.

How long does a technical audit take?

It depends on the site. A small coded site can be reviewed in days; a large one with many templates and markets takes longer. The audit is the first part of the agreed scope, not a standalone product.

Can you work directly in our repository?

Yes — that is where the fixes belong. Access and review responsibilities are agreed in writing before any change is made.

Will fixing technical issues improve our rankings?

Technical fixes remove obstacles; they do not guarantee ranking changes. They give your pages a fair chance, which is the honest reason to do them.

What is the difference between this page and the free audit tool?

The free audit tool runs automated checks on one page and explains what it finds. This work is the deeper, template-level review and the implementation of the fixes, inside the SEO offer.

Do we need JavaScript rendering?

Only when content genuinely requires it. On coded sites we usually prefer server-rendered or static pages, which is simpler and more reliable for crawlers and users.

How do you measure success?

Indexation per template in Search Console, clean follow-up crawls, field-data performance, and ultimately impressions and clicks on the affected pages.

What does Google say about these fundamentals?

Google's SEO Starter Guide covers crawlability, helpful content, metadata and links — we follow it and cite it where a decision needs an external reference.

Do you handle domain migrations?

Yes — the redirect map, the template checks and the post-launch monitoring are all part of the technical work inside the SEO offer. Migrations are planned in the code, not improvised after launch.

How often is the site re-crawled?

The baseline crawl happens at the start, and follow-up crawls run after each significant batch of fixes to confirm the problems actually disappeared. Search Console then shows the indexation changes as Google recrawls.

What does indexation management mean in practice?

A deliberate decision per template: which page types should be indexed, which should be consolidated, and which kept out — implemented as consistent rules across canonicals, robots directives, sitemaps and links, then monitored in Search Console so the index matches the intention.

Why is server-side rendering preferred for SEO?

Because the content then exists in the first HTML response, without a second step for JavaScript to fill it in. That makes pages faster for people and dependable for every kind of crawler, including those that do not run scripts at all.

Contact us about Technical SEO

Send a short enquiry and we will review your site, tell you plainly what is worth doing first, and confirm whether this offer fits.

Or read how offers are priced.

Fields marked with an asterisk are required.

Your website's situation, the services and markets you want to grow, and any deadlines. Up to 5,000 characters.

Your details are used only to respond to this general enquiry. See the privacy policy.