Running Nuxt?

Nuxt app hydrating wrong or stuck on Nuxt 2? We bring it back.

Nuxt made SSR for Vue approachable, and then Nuxt 3 rebuilt the whole thing on Nitro and Vue 3, which left a lot of Nuxt 2 codebases stranded on an end-of-life runtime. We finish those migrations, we clean up hydration mismatches that only show up under production traffic, and we get Nitro server routes behaving on whichever host you landed on.

  • Since 2015Fixing technology
  • FreeEstimates
  • US teamReal engineers

nuxt-build.log

still failing

What it is

Nuxt at a glance

Nuxt is the full-stack framework for Vue, started in 2016 by Alexandre and Sebastien Chopin. It wraps Vue with file-based routing, server-side rendering, static generation, auto-imports, a modules ecosystem and sensible defaults. If Vue is the engine, Nuxt is the car around it.

Nuxt 3, released stable in 2022, rebuilt the framework on Vue 3, Vite and Nitro, its own portable server engine. Nitro compiles to many targets: Node, Vercel, Netlify, Cloudflare, Deno Deploy, AWS Lambda, Azure and plain static output. Nuxt 2, which ran on Vue 2 and Webpack, reached end of life on December 31, 2024, which means a lot of production sites are now running on an unsupported stack and need migrating.

Type
Full-stack Vue meta-framework
First released
2016 (Nuxt 1), 2022 (Nuxt 3 stable)
License
MIT
Maintained by
NuxtLabs and the Nuxt core team
Typically used for
SaaS front ends, content sites, e-commerce storefronts, SSR dashboards, static marketing sites

The honest version

Nuxt pros and cons

No technology is all upside. This is where Nuxt earns its place and where it tends to cause trouble.

Where Nuxt is strong

  • Batteries-included full-stackRouting, data fetching, server routes, middleware, auto-imports and a modules ecosystem all live in one framework, so you are not stitching together six packages to get started.
  • Nitro targets many hostsThe same Nuxt app can ship to Node, Vercel, Netlify, Cloudflare Workers, Deno Deploy or a static bucket with only a preset change, which keeps vendor lock-in low.
  • Hybrid rendering is per-routeSSR, SSG, ISR and client-only can be mixed within one project through `routeRules`, so marketing pages prerender and dashboards render on request without separate codebases.
  • Auto-imports reduce ceremonyComposables, components and utilities are imported automatically once they land in the convention directories, so files stay focused on logic rather than import management.
  • Strong modules ecosystemNuxt Content, Nuxt Image, Nuxt UI, Nuxt Auth and dozens of integrations are first-party enough to feel supported, which saves writing glue code.
  • DevTools built inThe in-app Nuxt DevTools panel gives route, component, module, server and payload introspection without extra setup, which helps when debugging SSR behavior.

Where Nuxt bites

  • Nuxt 2 to Nuxt 3 is a real migrationVuex to Pinia, Vue 2 to Vue 3 (Composition API, slots, reactivity), Webpack to Vite, and plugin, middleware and module APIs all change. For non-trivial codebases this is weeks of work, not days.
  • Hydration mismatches are commonAny non-deterministic data (date formatting, randomness, timestamps) between server and client renders prints a mismatch warning and can silently corrupt UI state.
  • Nitro serverless surprisesFunction size limits, cold starts on Workers, subtle Node vs edge runtime differences, and dependencies that only work on one preset all tend to appear on the first production deploy.
  • Auto-imports obscure where code livesFor developers new to the project, tracing where a composable or component is defined requires IDE support, because the import statement is missing from the source file.
  • Data fetching has sharp edges`useFetch`, `useAsyncData`, `$fetch` and server-only helpers each behave differently on SSR vs client, and the wrong choice shows up as double fetches, missing data or payload bloat.
  • Module quality is unevenFirst-party modules are generally solid, but the long tail of community modules varies widely in maintenance, and the ones that break on a Nuxt bump are rarely the critical ones.

Sound familiar?

Common Nuxt problems we fix

The Nuxt problems that bring people to us, and what you have once each one is fixed.

Nuxt 2 EOL · Vue 2 EOL

The project is stranded on Nuxt 2

A production Nuxt 2 app with Vue 2 that is now out of support, picking up security advisories nobody is patching, and modules that will not update further on the old major.

Running on Nuxt 3+ with support

Hydration node mismatch at <div class="card">

Hydration mismatches in production only

Dates rendered in a different timezone server-side, data fetched only on client, or a `v-if` on a condition that is true on the server and false in the browser.

Markup stable across both renders

Nitro output 142.8 MB, limit 50 MB

Serverless deploys get rejected

A node module included for a single server route, images shipped into the bundle, or a preset that is inlining dependencies it should have externalized.

Bundle fits the host's limits

useFetch double-fetched 3.2x on client

Data is being fetched twice

`useFetch` on both server and client without a shared key, `$fetch` in a `setup` without SSR awareness, or a watcher refetching on reactive changes that should not have triggered.

One fetch per render, as intended

A composable called outside Nuxt instance

Composables fail outside setup()

A `useRuntimeConfig` or `useState` call inside a plain utility that runs outside a component's setup, or inside an async boundary that lost its context.

Composables only where they belong

Pinia store accessed during SSR

State leaks between users on SSR

A store written to at module scope on the server, or a singleton-like pattern that is fine in dev and leaks between concurrent requests under real traffic.

Per-request state, no cross-contamination

upstream timeout at /api/checkout

Nitro server routes are slow or timing out

H3 handlers blocking on external APIs, missing timeout and retry handling, or edge runtimes hitting Node APIs that are simulated rather than native.

Server routes fast and bounded

What we do

Nuxt help, from migration to monitoring

Hand us one failing route, or the whole Nuxt codebase.

Nuxt 2 to 3 migration
Vue 2 to Vue 3, Vuex to Pinia, Webpack to Vite, modules to current versions, and a rendered site that behaves the same at the end of it.
Rescue
A Nuxt build failing on CI, a route that times out in production, or hydration warnings that only appear under real traffic. We find the real cause, not the obvious one.
Performance and SSR tuning
Route rules, caching, payload trimming, image handling and server fetch patterns reviewed against your actual Core Web Vitals and TTFB.
Nitro and adapter work
Choosing the right preset for Node, Vercel, Netlify or Cloudflare, with function sizes and runtime differences actually understood before you commit to a host.
Agency handover
A Nuxt site built by someone else, now in your repo, your hosting and your DNS, with documentation a new engineer can start from.
Managed Tech
Framework and module upgrades, build pipeline health, performance watch, and an engineer on the end of a phone when a Nitro release moves something that broke your deploy.

How it works

From first message to fixed

  1. Look Free estimate

    Tell us what's going wrong. We look at it, then tell you plainly what's wrong and what it will cost.

  2. Fix

    We fix the cause, not the symptom. If something is down, getting it back up comes first.

  3. Harden

    Backups, monitoring, updates and access, so the same problem can't quietly come back.

  4. Hand back or stay on

    You get a plain-language write-up. Or we stay on for hosting, upkeep and new work.

Often found together

Running Nuxt alongside something else?

We work on the whole stack, so the problem can be wherever it actually is.

Questions

Nuxt questions

Something else? Call+1 737 727 7327

Our Nuxt 2 site is still running, do we really need to migrate?

Yes, at a predictable pace. Nuxt 2 and Vue 2 both reached end of life at the end of 2024, which means security fixes stop flowing, modules you depend on gradually drop support, and the hiring pool for Vue 2 is thinning. The migration to Nuxt 3 is not an afternoon, but it is a routine project with known milestones and we would rather plan it with you than rescue it in a panic later.

Why does our Nuxt app show hydration mismatches in production?

Almost always because server-rendered HTML and client-rendered HTML disagree on something non-deterministic: a date formatted with the server's locale, a random ID, data fetched client-side that was not present server-side, or a feature flag read from a cookie on one side only. We reproduce it against production data, make the output deterministic, and move the warnings back to zero.

Can you take over a Nuxt project from a previous team?

Yes, that is a frequent engagement. We inventory modules, Nuxt and Vue versions, pin or upgrade them, bring hosting and environment variables under your accounts, and leave you with a repo and runbook any engineer can continue from.

Should we pick Nuxt or Next.js?

If your team writes Vue, or you already own a Vue codebase, Nuxt is the natural choice and the Nuxt 3 story is mature. If you are starting fresh and your team knows React better, Next.js has a larger ecosystem and hiring pool. We will tell you which one fits based on your team, not based on which is trendier this quarter.

Which deployment target makes sense for Nuxt?

Marketing and content sites go well on Vercel or Netlify with ISR or prerender. Apps with long server work or non-standard Node needs go well on Node hosting. Cloudflare Workers is excellent for globally distributed reads but trips on Node APIs some modules assume. We match the preset to how the app actually behaves.

How much does Nuxt help cost?

The quote is free. Send a short note about the Nuxt version and the symptom, and we respond with a price before anyone touches your code.

Free estimate

Nuxt site giving you trouble?

Tell us what you're running and what's going wrong. A person reads it and comes back with an estimate.

  • No charge to find out what it will take
  • If it's urgent, say so

Replies come from a person. By sending, you authorize us to email you back. No marketing.