Key takeaways
- Enterprise technical SEO works at template and rule level: one fix in rendering, canonicals or linking changes thousands of URLs at once.
- Rendering: Google processes JavaScript in three phases (crawling, rendering, indexing) and still calls server-side or pre-rendering “a great idea”. Check rendered HTML per template.
- Indexing: decide which URL types should be indexed, and consolidate the rest with redirects and canonicals, which Google ranks as strong signals.
- Internal links: Google “can’t reliably extract URLs from
<a>elements that don’t have an href attribute”, and every important page needs at least one link. - Monitor by page type with logs, Crawl Stats and the Page indexing report, so a regression shows up in days, not months.
Enterprise technical SEO is the part of SEO where one decision affects the most pages. On a large site, a change to how a template renders, how URLs are canonicalised or how navigation links are built can improve or damage thousands of pages in a single release. That is why the work is done at the level of templates and rules, not individual URLs.
I have worked on technical SEO for large sites for many of my 16+ years in the field. This article covers the three systems I check first on any large site (rendering, indexing and internal links) and how to monitor them so problems are caught early. Each point is backed by Google’s own documentation.
Why enterprise technical SEO is template work
On a site with hundreds of thousands of URLs, almost every page is produced by a handful of templates and a few URL rules. That changes how technical problems behave:
| On a small site | On a large site |
|---|---|
| A broken canonical affects one page | A canonical rule affects a whole page type |
| A missing link hides one page | A navigation change hides a whole section |
| Slow rendering is one bad experience | A rendering change can empty thousands of pages for Google |
| Fixes are page edits | Fixes are template or rule changes in a release |
So the method is the same each time: identify the page types, check each template’s rendered output, URL rules and links, then fix the template. If you want the broader role, see what an enterprise SEO consultant covers; for the audit method, see how to audit a very large site.
Rendering at scale
Google’s JavaScript SEO basics explains that it processes JavaScript web apps in “three main phases”: crawling, rendering and indexing. Content and links that only appear after JavaScript runs depend on the rendering step working for every page. Google’s own advice is that “server-side or pre-rendering is still a great idea”.
For each important template I check:
- Main content in the rendered HTML: titles, headings, body text and product data present after rendering, not only after a user clicks.
- Links in the rendered HTML: navigation, breadcrumbs, related items and pagination as real links.
- Status codes that match the content: a “not found” view should return a 404, not a 200 with an error message.
- Metadata set correctly: canonical tags and meta robots in the initial HTML or set reliably by the framework.
Google suggests checking with “the Rich Results Test or the URL Inspection Tool and look at the rendered HTML.” On a large site I do that for a sample of URLs per template, and again after every major front-end release. Our article on rendering problems on JavaScript sites goes into the common failures.
On a large site, a rendering bug isn’t one broken page. It is a whole page type that Google can’t read.
Indexing: decide what should be indexed
Large sites usually have far more URLs than pages worth indexing: filters, sort orders, internal search, tracking parameters, old campaign pages. Enterprise technical SEO starts with a clear rule for each URL type: index it, consolidate it, or keep it out of crawling.
Consolidate duplicates with strong signals
Google’s guide to canonical URLs lists its methods “in order of how strongly they can influence canonicalization”: a redirect is “A strong signal that the target of the redirect should become canonical”, rel=”canonical” is “A strong signal that the specified URL should become canonical”, and sitemap inclusion is “A weak signal”. It also makes clear that the final decision is Google’s: “Google will decide which pages (if any) are duplicates, based on similarity of content.”
At scale that means making all signals agree: the canonical tag, internal links, sitemaps and redirects should all point to the same preferred URL for each piece of content. Conflicting signals across templates are one of the most common problems I find.
Don’t use robots.txt to canonicalise
Google is explicit: “Don’t use the robots.txt file for canonicalization purposes.” It also warns that “Google may still index URLs that are disallowed in robots.txt without their content.” Robots.txt is for keeping crawlers away from URL spaces that waste crawling, such as unbounded filters, not for choosing which duplicate wins.
Noindex doesn’t save crawling
On large sites, teams often noindex URL types they don’t want and assume the problem is solved. Google’s crawl budget guide notes that it “will still request, but then drop the page”, so noindexed URLs still consume crawling. If a URL type shouldn’t exist for search at all, stop generating links to it, or block its crawling.
Indexing rules per URL type
- List every URL type and how many URLs it produces.
- Decide: index, consolidate (redirect or canonical), or block crawling.
- Make canonicals, internal links, sitemaps and redirects agree on the preferred URL.
- Keep sitemaps to indexable, canonical URLs only.
- Check each rule in the Page indexing report, using a sitemap per page type.
Internal links at scale
Links are how Google discovers and weighs pages on a large site, and they are almost entirely produced by templates: navigation, breadcrumbs, category listings, related items and pagination.
Google’s link best practices say it “can’t reliably extract URLs from <a> elements that don’t have an href attribute” and list patterns it doesn’t recommend, such as links built only with click handlers or framework-specific attributes. They also set a simple rule: “Every page you care about should have a link from at least one other page on your site.”
At scale I look for:
- Orphaned sections: page types that exist in sitemaps but get no internal links, often after a navigation redesign.
- Links only in scripts: menus or “load more” buttons that work for users but don’t produce real links.
- Deep pages with weak paths: products or listings many clicks from any category page.
- Links to non-canonical URLs: internal links pointing to parameter versions or redirected URLs, sending mixed signals.
- Anchor text: Google describes good anchor text as “descriptive, reasonably concise, and relevant”. Templates that produce generic “read more” or empty anchors waste a signal on every page.
Pagination and “load more”
Category and listing pages are where most product and article links live, so how they paginate decides how deep Google can reach. On large sites I check three things. Each page in a series should have its own URL that returns its own set of items. Each page should link to the next with a real link, even if users see a “load more” button or infinite scroll. And the first page shouldn’t be the only one that can be crawled, otherwise everything beyond the first screen of items depends on sitemaps alone.
When a listing template is rebuilt, this is one of the first things to break, and one of the last to be noticed, because users scrolling in a browser never see the problem.
Monitoring enterprise technical SEO
Because problems arrive with releases, monitoring matters as much as fixing. I set up three views, all split by page type:
- Server logs or Crawl Stats: what Googlebot requests, how often, and what status codes it gets, per URL type.
- Page indexing per sitemap: indexed and excluded counts for each page type, with the reasons.
- Rendered checks after releases: a small set of URLs per template rendered and compared with the last known good version.
When one of these moves, the page type tells you which template and which team to look at.
FAQ
What is enterprise technical SEO?
Technical SEO for large sites, done at template and rule level: how templates render, which URL types are indexed or consolidated, how internal links are built, and how releases are checked and monitored.
What are the most common technical SEO problems on large websites?
Content or links that only appear after JavaScript runs, conflicting canonical signals across templates, URL spaces from filters and parameters, orphaned sections after redesigns, and noindexed URL types that still consume crawling.
Should large sites use server-side rendering?
Google says server-side or pre-rendering “is still a great idea”. It isn’t required for Google to index JavaScript content, but it removes a whole class of rendering risk for important templates.
What does enterprise technical SEO consultancy include?
Usually a template-by-template review of rendering, indexing rules and internal links, written requirements for engineering teams, release checks, and monitoring by page type. I work on it by the hour, scoped to the number of templates and markets.
If a release has hurt your organic traffic, or you want technical SEO checked before the next one, tell me what changed and we can look at the templates together.
Eugen Platon · SEO consultant with 16+ years in SEO and digital marketing · free 10-minute first call