Just Fucking Use Nuxt.

Stop assembling your router, server, rendering strategy, and deployment pipeline by hand.
Build the Vue app you actually came here to build.

Your Vue project is becoming a pile of decisions.

Which router?
Which state setup?
SSR, SSG, SPA, or edge?
API server or separate backend?
SEO, data fetching, image handling, deployment?
Which five plugins will quietly become infrastructure?

Nuxt handles the boring decisions so you can focus on building.

What the fuck is Nuxt?

Nuxt is Vue with the boring, necessary parts already connected: routing, rendering, server endpoints, data fetching, SEO, TypeScript support, and deployment.

You still write Vue. You just stop rebuilding the framework around it.

Zero configuration

Start with Vue or TypeScript. Nuxt wires up the fundamentals so you can start building instead of configuring.

Rendering modes

Render on the server, client, or at build time. Pick the right approach for each route, not the whole app.

Routing and layouts

Create a file for a page, then compose layouts around it. The router is ready when your next screen is.

Data fetching

Fetch data with composables that work across rendering modes, caching, and navigation without extra ceremony.

Error handling

Catch failures with framework-aware handlers and build useful error pages without starting from scratch.

Transitions

Add smooth page and layout transitions when they improve the experience, not as a separate integration project.

Assets and style

Optimize images, fonts, and scripts with first-class support that keeps production performance in view.

SEO and metadata

Ship crawlable HTML and manage typed metadata in the same place you build your pages.

Modular by design

Add capabilities through Nuxt modules that follow the same conventions as the framework itself.

Middleware

Protect routes and run shared logic before rendering, with clear rules that stay close to your app.

Type-safe by default

Use generated types and TypeScript support throughout the project, from routes to runtime configuration.

Stop assembling a framework.

Vue gives you an excellent view layer. A production application needs more than a view layer, so the same integration checklist appears in project after project.

Nuxt turns that checklist into conventions you can understand at a glance.

Starting from Vue	With Nuxt conventions	Example
Install and configure a router	Create a page	`app/pages/about.vue`
Choose a pattern for server data	Use an SSR-aware composable	`useFetch('/api/products')`
Create and connect a separate API project	Add a server handler	`server/api/orders.post.ts`
Stitch together SEO tooling	Define typed metadata	`useSeoMeta({ title })`
Commit to one rendering strategy	Choose what each route needs	`routeRules: { '/blog/**': { swr: 3600 } }`
Rework the output for each host	Build portable Nitro output	`nuxt build`

Create a page. You have a route. No router ceremony, no extra wiring.

app/pages/products.vue

<script setup lang="ts">
const { data: products } = await useFetch('/api/products')
</script>

<template>
  <ProductGrid :products="products ?? []" />
</template>

Need an endpoint? Put it beside the app that calls it.

server/api/orders.post.ts

export default defineEventHandler(async (event) => {
  const order = await readBody(event)
  return { accepted: true, order }
})

Need a route to behave differently? Say so, once.

nuxt.config.ts

export default defineNuxtConfig({
  routeRules: {
    '/blog/**': { swr: 3600 },
    '/admin/**': { ssr: false },
  },
})

Nuxt does not make your application simple. It stops the setup from becoming an application of its own.

Nuxt Modules are fucking goated.

Nuxt covers the foundation. Modules add the good stuff without making every integration a side quest. They plug into the framework, and it just works.

Nuxt UI

A polished, accessible component library built on Tailwind CSS. Make the interface feel finished without rebuilding a design system before lunch.

Nuxt SEO

The complete SEO toolkit for Nuxt: metadata, sitemaps, structured data, and more. Help search engines find and understand your app without assembling a dozen packages.

Nuxt Tailwind CSS

Bring Tailwind into Nuxt with sensible defaults, config discovery, and minimal production CSS. Utility-first styling, minus the integration busywork.

VueUse

A collection of battle-tested Vue composables with Nuxt-friendly auto-imports. Reach for browser APIs, reactive utilities, and common UI behavior without writing each helper from scratch.

Nuxt MCP Toolkit

Create type-safe MCP tools, resources, prompts, and interactive apps directly in your Nuxt project. Your app can finally talk to AI clients without a second server.

NuxtHub

Add a database, KV, blob storage, and caching to your Nuxt app. Build full-stack features without collecting cloud services like Pokémon cards.

Pinia

The Vue store that is actually pleasant to use, with Nuxt-aware setup and auto-imported stores. Reach for it when state deserves a real home.

evlog

Emit one structured, context-rich event per request instead of a panic-inducing trail of console logs. Debug production with evidence, not vibes.

Nuxt is already in production.

Nuxt is not a clever experiment waiting for a real-world test. It is already doing the work for global brands, technology companies, and public organizations around the world.

Global brands

Public websites serving international audiences at serious scale.

Technology companies

Production websites from developer tools and software businesses.

Public organizations

Public-interest organizations where reliability and reach are not optional.

Louis Vuitton
Armani
The North Face
GitLab
Directus
n8n
NASA JPL
Croix-Rouge française
Explore France

“But isn’t Nuxt overkill?”

For a tiny static page with no application behavior, use HTML. Seriously. Nuxt is a framework, not a personality test.

But when you need routes, shared UI, real data, forms, SEO, authentication, server logic, or a growing team, the foundation starts demanding its own backlog.

Nuxt is not a pile of features you must use on day one. It is Vue with a path forward.

Start with a single page. Run it as a client-rendered app if that is all it needs to be.
Add a route when there is another screen. Create a file in app/pages/, and Nuxt supplies the router.
Add server code when the app needs it. Put a handler in server/api/, beside the frontend that calls it.
Add rendering where it earns its keep. Pre-render a landing page, server-render content that needs SEO, and keep dashboards on the client.

You scale the application, not the setup. Same project. Same Vue components. More capability only when it solves a real problem.

When should you use Nuxt?

If you are building a Vue application rather than a one-off document, stop treating the same plumbing as a rite of passage. Just use Nuxt.

Stop configuring. Start shipping.

Nuxt isn't perfect. Nothing is. But it gives you routing, rendering, server endpoints, data fetching, SEO, and deployment in one coherent codebase. Stop stitching together the foundation before you can ship the product.

Just fucking use Nuxt.

Get started