NEXSUM_LABS
  1. Home
  2. Work
  3. A legal-tech content platform fixed its indexation problem on Nuxt
Book a call

[ Case study ]

Legal technologyNuxt 3NitroHeadless CMSCloudflare

A legal-tech content platform fixed its indexation problem on Nuxt

Search consoles showed 39% of the platform's guide pages excluded from the index. The Nuxt app rendered client-side for content routes, so crawlers saw shell pages, and the editorial team had no way to tell which of their 400 guides Google had actually met.

CLIENT a legal-technology content platform — FOCUS Move content routes to server rendering

Nuxt DevelopmentWeb DevelopmentNuxt DevelopmentLegal technologyRepresentative example
Client
a legal-technology content platform
Industry
Legal technology
Engagement
6 weeks — systems pod — engineer
Service
Web Development / Nuxt Development
Headline outcome
Indexed guide pages as a share of submitted URLs, over the 8 weeks after rollout: 61% → 94%, read from Search Console coverage report

Representative examplesEvery case study in this library is an illustrative composite of the kind of engagement we deliver — written to show our method and standards, not to name clients.

Where they started

Search earns this platform's revenue: hundreds of practical legal guides for small-business owners, written and shipped daily by a small editorial team. Discovery is the business model — a guide Google never indexes earns nothing. The codebase is a Nuxt app maintained by one part-time developer. The editorial operation was mature and fast; the rendering architecture underneath it had quietly decided that most of the library stayed invisible.

What it was costing

Search consoles showed 39% of the platform's guide pages excluded from the index. The Nuxt app rendered client-side for content routes, so crawlers saw shell pages, and the editorial team had no way to tell which of their 400 guides Google had actually met.

What they could see

  • Search Console showed roughly four in ten guide pages excluded from the index, and the list grew every week.
  • Editors published daily with no way to tell whether Google ever met a given guide.
  • A guide's page source showed shell markup; the words arrived only after JavaScript ran.
  • Fresh guides sat unindexed for weeks while syndicated copies of the same text ranked elsewhere.

The constraints we worked inside

  • The content team published daily; rendering changes could not pause the editorial calendar.
  • The existing headless CMS and its preview workflow had to keep working.
  • The fix had to be verifiable — the client wanted index coverage, not a redesign.

What had been tried before

The developer added a prerender hook that served static HTML to crawler user-agents.
Two versions of every page drifted apart as content changed daily, and the crawler occasionally received the stale copy — the fix created its own inconsistency.
The editorial team audited index coverage manually with site queries and recrawl requests.
The audit took days, expired immediately as publishing continued, and couldn't distinguish a rendering problem from a content problem.

What we proposed

We proposed moving the guide routes to server rendering with per-route caching, repairing the crawl surface — sitemaps, canonicals, and internal links rebuilt around the real content hierarchy — and verifying progress weekly against the excluded-pages report in Search Console. Rendering would be the only intervention: no redesign, no editorial process change, and the CMS preview flow untouched, because the client's test was index coverage and nothing else. The fix had to be legible: each week's report read as a line item against a decision list.

Just as important is what we ruled out, and why:

  • Full static generation with scheduled rebuildsDaily publishing across hundreds of guides would have made the build the editor's bottleneck and broken the CMS preview workflow.
  • A separate prerendered copy served only to botsTwo sources of truth for content that changes daily had already failed once; drift would have been worse than the shell pages.
  • A redesign to earn better rankingsThe brief was verifiable index coverage; design changes would have muddied the measurement and delayed the fix.

How the work ran

01Move content routes to server rendering

Guides switched to SSR with per-route caching, so crawlers receive real content while the editorial preview flow stays untouched.

02Repair the crawl surface

Sitemaps, canonicals, and internal links were rebuilt around the actual content hierarchy, with the excluded-page report as the acceptance metric.

03Verify in search consoles weekly

Each week closed with a coverage review, so regressions were caught while the cause was still findable.

Delivered by the systems pod — engineer over 6 weeks, with working increments reviewed with the client every week.

The stack, and the reasoning

Nuxt 3
The codebase and the part-time developer are Nuxt; server rendering arrived as a configuration and routing change, not a rewrite into a foreign framework.
Nitro
Per-route caching rules let guide pages serve cached HTML while editorial previews bypass it — one server, two audiences, no stale content for either.
Headless CMS
The daily publishing calendar and its preview workflow kept working untouched; rendering was the intervention, content systems were not.
Cloudflare
Crawler bursts after the rollout hammered the origin; edge caching and bot traffic rules absorbed the spikes before they reached the CMS.

What went wrong

Obstacle

Once guides rendered on the server, Googlebot's crawl rate spiked and the CMS-backed origin slowed under the burst; editorial previews got sluggish within days.

Handled: Nitro route caching plus Cloudflare bot rules absorbed the spikes, and editorial previews moved to a path that bypasses the cache; the two audiences stopped competing.

Obstacle

Legacy guides carried canonical tags pointing at old URL patterns, so some pages cannibalized each other even after the rendering fix landed.

Handled: We regenerated canonicals from the content hierarchy and requested reindexing in small batches, reading the excluded-pages report weekly so each change had an attributable effect.

How we worked together

Cadence
Weekly index-coverage review every Wednesday morning, reading the Search Console report line by line; the rest of the week ran asynchronously in a shared tracker.
Client side
The content lead owned the editorial calendar and attended the weekly review; a part-time developer maintained the repo and reviewed our pull requests.
Decisions
Rendering and caching decisions were ours to propose and document; anything touching editorial workflow needed the content lead's sign-off before merging.
They provided
Search Console and analytics access, the CMS workspace with its preview hooks, server logs for the crawl analysis, and a week of publish-calendar slack.

What changed

The headline: indexed guide pages as a share of submitted urls, over the 8 weeks after rollout61% → 94%, read from Search Console coverage report. A second check: organic entrances to guide pages, same period vs prior year at +2.4×.

The content team publishes without wondering whether Google will ever meet the page. The weekly coverage review became a ten-minute ritual the content lead runs alone, and did-it-get-indexed stopped being a question asked across the office. Editors noticed old guides picking up fresh organic entrances and began updating dormant ones — a behavior that never existed while half the library was invisible to search.

The result was read from Search Console coverage report against the pre-engagement baseline over the stated window, with a guardrail check on organic entrances to guide pages, same period vs prior year. Where platform-reported numbers and business outcomes differ, this record says which layer it is quoting.

What they own now

  • The SSR configuration with per-route caching rules, documented in the repo readme.
  • A weekly coverage-report checklist the content lead runs alone in ten minutes.
  • The canonical and sitemap generators tied to the content hierarchy, with examples.
  • Cloudflare rules for bot traffic, with the reasoning written next to each rule.
  • A log-file analysis script to catch crawler starvation before it shows in rankings.

What we would do differently

We would have run the log-file analysis first — three days of logs would have told us the crawler was starving before we guessed at rendering.

Web DevelopmentNuxt DevelopmentLegal technologyNuxt 3

Next case study

A nine-school education group went from nine WordPress installs to one admin