Tooling, CI/CD & DX

Train

Tooling & delivery

The build and delivery toolchain a senior Nuxt engineer owns — Vite and Rolldown in Nuxt, linting, formatting and type checking as CI gates, package management and monorepos, CI/CD pipelines, and the developer-experience and debugging tools that make a team fast.
Vite guideNuxt commandspnpmGitHub Actions

Senior engineers are expected to own the toolchain: why the build is slow, why CI is red, why types pass locally and fail in the pipeline, how a new hire gets to a running app in ten minutes. Interviewers probe this with "walk me through your CI", "how do you keep the bundle small", "how would you set up a monorepo". This section covers the 2026 toolchain around Nuxt 4 with enough depth to answer and enough pointers to verify.

Know

  • Vite 8 on Rolldown is Nuxt's default builder: one Rust bundler for dev and production, Oxc for transforms and minification, import.meta.glob, environment API. Nuxt configures it; you tune through vite options and nuxt analyze.
  • Lint, format, type check are CI gates, not editor conveniences: @nuxt/eslint with flat config and stylistic rules, vue-tsc through nuxt typecheck (TypeScript 6 until vue-tsc supports the TS 7 API), and optional Oxlint or Biome for speed.
  • Package management: pnpm as the default (strict, content-addressable store, workspaces, catalogs), lockfiles committed, --frozen-lockfile in CI, minimumReleaseAge-style install delays and provenance as supply-chain defences.
  • CI/CD: a pipeline that installs from cache, lints, type checks, tests in parallel, builds once, runs end-to-end against the build, produces preview deployments per pull request, and deploys with migrations first and rollback ready.
  • Developer experience: Nuxt DevTools, source maps and breakpoints in Vue and Nitro code, nuxi commands, .env handling, nuxt.config per environment, reproducible environments, and debugging strategies from hydration mismatches to memory leaks.

How the pages fit

PageCovers
Vite and the buildRolldown, how Nuxt builds client and server, chunks and analysis, env handling, build performance
Linting, formatting and types in CI@nuxt/eslint flat config, stylistic, vue-tsc/TS 7 status, Oxlint, Biome, pre-commit versus CI
Package management and monorepospnpm, lockfiles, catalogs, workspaces, Turborepo, publishing, supply-chain hygiene
CI/CD pipelinesThe stages, caching, parallelism, preview deploys, releases, rollbacks, secrets
Developer experience and debuggingDevTools, debugging SSR and Nitro, environments, onboarding, scripts and generators

How it works

A package.json scripts block that encodes the gates the pipeline runs, so local and CI agree:

package.json (scripts)
{
  "scripts": {
    "dev": "nuxt dev",
    "build": "nuxt build",
    "generate": "nuxt generate",
    "preview": "nuxt preview",
    "lint": "eslint .",
    "lint:fix": "eslint . --fix",
    "typecheck": "nuxt typecheck",
    "test": "vitest run",
    "test:e2e": "playwright test",
    "check": "pnpm lint && pnpm typecheck && pnpm test",
    "postinstall": "nuxt prepare"
  }
}
Gotcha· Tooling that only works on one laptop

If the build depends on a global CLI, an unpinned Node version or a .env someone emailed around, onboarding takes days and CI disagrees with local runs. Pin Node in package.json engines and .nvmrc, use Corepack or packageManager for pnpm, keep .env.example in the repo, and make pnpm check the one command that mirrors CI.

Exercise

Exercise
  • Time a fresh clone to a running dev server on your current project; list every manual step and remove as many as you can.
  • Run pnpm check locally and compare with the CI configuration; make them identical.

Be able to say

Be able to say· What does your ideal toolchain for a Nuxt project look like?

"Nuxt 4 on Vite 8 with Rolldown for the build, pnpm with a committed lockfile and frozen installs in CI, @nuxt/eslint flat config with stylistic rules replacing Prettier, nuxt typecheck with vue-tsc, Vitest with the Nuxt environment for unit and component tests and Playwright for end-to-end. One pnpm check command mirrors the pipeline. CI installs from cache, runs lint, types and tests in parallel, builds once, runs Playwright against the build, deploys a preview per pull request, and releases with migrations first and a rollback path. Nuxt DevTools and source maps for debugging, .env.example and pinned Node and pnpm versions so a new hire runs the app in ten minutes."

Pages in this section

  1. 01Vite and the buildHow Nuxt builds with Vite 8 and Rolldown — dev server versus production, the client and server builds, Nitro's second bundling step, chunking and manual chunks, analysing bundles, environment variables at build versus runtime, source maps, build performance and the migration from Vite 7.
  2. 02Linting, formatting and types in CIESLint 10 flat config through @nuxt/eslint with stylistic rules instead of Prettier, Vue and TypeScript rule sets worth enabling, type checking with vue-tsc via nuxt typecheck and the TypeScript 7 situation, Oxlint and Biome as fast complements, editor integration, pre-commit hooks versus CI gates, and treating warnings as failures.
  3. 03Package management and monorepospnpm as the default package manager — the content-addressable store, strict node_modules, lockfiles and frozen installs, catalogs, overrides and patches, workspaces and Turborepo task graphs, consuming Nuxt layers and internal packages, publishing with changesets and provenance, Node version management with Corepack, and supply-chain hygiene.
  4. 04CI/CD pipelinesDesigning a pipeline for a Nuxt app — stages and their order, caching installs and build outputs, parallel jobs and sharded tests, building once and testing the artifact, preview deployments per pull request, environment promotion, release strategies and rollbacks, secrets and OIDC, flaky-test policy, and the metrics that tell you the pipeline is healthy.
  5. 05Developer experience and debuggingNuxt DevTools and what it reveals, debugging SSR and Nitro code with breakpoints, source maps and the Node inspector, HMR and dev-server troubleshooting, environment files and per-environment config, reproducible local environments, onboarding in ten minutes, scripts and generators, and a debugging method for the classic Nuxt failures.

Your notes

Open in Notes

Nothing yet. Notes filed here show up on every page of this section.

Decision records and trade-offs

Writing architecture decision records, running lightweight RFCs, evaluating libraries and services, build versus buy, reversible versus one-way decisions, planning migrations as strangler moves, managing technical debt with a budget, and communicating trade-offs to product and leadership.

Vite and the build

How Nuxt builds with Vite 8 and Rolldown — dev server versus production, the client and server builds, Nitro's second bundling step, chunking and manual chunks, analysing bundles, environment variables at build versus runtime, source maps, build performance and the migration from Vite 7.