Skip to main content
AIDevOps
  • Learn
  • Learning Paths
  • Practice
  • Open Source
  • Books
  • Engineering

    AI DevOpsThe full map of building and operating AI servicesLLMOpsLLM deployment Β· evaluation Β· observabilityHands-on ProjectsBuild AI Agent projects

    Knowledge

    DocsTechnical documentationBlogEngineering articlesPloggerDevelopment log feed

    Validate

    Certification3-level skills certification Β· coming soon
AI Models
LlamaTutorial|MistralTutorial|GemmaTutorial|DeepSeekTutorial|QwenTutorial
🎨 Frontend
Frontend Intro & RoadmapJavaScriptTypeScript|ReactNext.js|VueNuxt|Electron
πŸ€– AI Applied Development
Applied AI Intro & RoadmapHugging FaceLangChainLlamaIndexLLMOps|LangGraphMCPMulti-AgentAgent Evaluation
🧠 AI Core
AI Intro & RoadmapML FundamentalsLLM Fundamentals|Python AIC++|PyTorchTensorFlowJAX
🧠 AI Agent Development
Finance AI AgentLLM API ServerStock Investing AgentAIOps AI AgentEducation AI AgentCoding AI Agent
🌱 Spring Cloud
Spring Intro & RoadmapSpring Cloud GatewaySpring BootJava|Spring AISpring SecuritySpring BatchSpring JPA
🐳 DevOps
DevOps Intro & RoadmapLinuxDockerCI/CD|Kubernetes BasicsK8s AdvancedPrometheusGrafana
🧱 Infrastructure
Infrastructure Intro & RoadmapNginxRedis
☁️ Cloud
Cloud Intro & RoadmapAWSGCPAzureNCPCloudflare
πŸ“± Mobile
Mobile Intro & RoadmapKotlinAndroidFlutter
βš™οΈ Backend
Backend Intro & RoadmapPython BasicsFastAPIDjangoFlask|CGoGinNode.js
πŸ’Ύ Database
DB Intro & RoadmapCore SQLOracleMySQLPostgreSQL|MongoDBVector DB
πŸ§ͺ Testing
k6JMeternGrinder
AIDevOps

Engineering AI. From Code to Production.
An engineering learning platform for building and operating AI and AI Agents

Learn

  • All Guides
  • Learning Paths
  • AI Tutorial
  • Practice
  • Books

Resources

  • AI DevOps
  • LLMOps
  • Hands-on Projects
  • Docs
  • Blog
  • Plogger
  • Open Source
  • Certification (coming soon)

Start Here

  • AI Core Roadmap
  • AI Applied Development Roadmap
  • Spring Cloud Roadmap
  • DevOps Roadmap
  • Infrastructure Roadmap

Β 

  • Cloud Roadmap
  • Frontend Roadmap
  • Mobile Roadmap
  • Backend Roadmap
  • Database Roadmap
Β© 2026 AIDevOps. All rights reserved.
Terms of ServicePrivacy PolicySitemaptestforge.kr
  1. Home
  2. Learn
  3. Frontend
  4. Nuxt.js
Guide to the Vue framework

πŸ’‘ Nuxt.js Complete Guide

Visitors

The full-stack SSR framework built on Vue 3. Learn file-based routing, the Nitro server, useFetch, SEO optimization, and deployment to Vercel.

  • Intermediate
  • Updated Oct 10, 2026
  • ~3 min read
  • 9 sections
  • 8 code examples
  • Web IDE lab included
πŸ’‘

Nuxt.js Web IDE

Run code in the browser with nothing to install and learn through step-by-step examples.

Open the Web IDE β†’
Vue SSR/SSGNitro server APIsSEO optimizationVercel deployment

Contents

0 / 12
  1. How to use this guide
  2. Architecture diagrams
  3. What is Nuxt.js?
  4. File-based routing
  5. useFetch / useAsyncData
  6. Nitro server API routes
  7. SEO & Meta
  8. Deployment
  9. Nuxt.js design
  10. Operating standards
  11. Verification strategy
  12. Frequently asked questions
Contents 12 sections
  1. How to use this guide
  2. Architecture diagrams
  3. What is Nuxt.js?
  4. File-based routing
  5. useFetch / useAsyncData
  6. Nitro server API routes
  7. SEO & Meta
  8. Deployment
  9. Nuxt.js design
  10. Operating standards
  11. Verification strategy
  12. Frequently asked questions

How to use this guide

How to read it

Understanding Nuxt.js as a real-world workflow

The full-stack SSR framework built on Vue 3. Learn file-based routing, the Nitro server, useFetch, SEO optimization, and deployment to Vercel. Rather than listing concepts, this guide is organized so you can follow the content in the order you have to make decisions on a real project.

Key perspective

Frontend / app development

Do not stop at drawing the screen: look at state, data requests, routing, accessibility, and the unit of deployment together.

Vue SSR/SSGNitro server APIsSEO optimizationVercel deployment

Architecture diagrams

To make what you read stick, it helps to capture the flow as a picture first. The two diagrams below are reference maps you can keep coming back to while learning Nuxt.js.

Learning flow

Rendering diagram…

Architecture view

Rendering diagram…

What is Nuxt.js?

When you first open Nuxt.js, the big picture matters more than individual commands. This section starts with the problems the concepts ahead were created to solve.

Nuxt is a full-stack framework that bundles file-based routing, server-side rendering, and an API server (Nitro) on top of Vue. The folder structure itself is the convention: adding a file to pages/ creates a route, and adding a file to server/api/ creates a backend endpoint, automatically.
BASH
npx nuxi@latest init my-app
cd my-app && npm run dev

# Structure
pages/      # file-based routing
server/api/ # Nitro server API
composables/# auto-imported composables
layouts/    # layouts

File-based routing

Here you look at File-based routing alongside real code. Rather than copying the example as-is, read it with an eye on the inputs, the outputs, and the parts most likely to change.

Nuxt turns the file structure of the `pages/` directory directly into routes. A file or folder name wrapped in square brackets (`[id]`) becomes a dynamic segment, and inside the component you read its value with `useRoute()`.
pages/ structure β†’ routesTEXT
pages/
  index.vue          β†’  /
  about.vue           β†’  /about
  users/
    index.vue          β†’  /users
    [id].vue            β†’  /users/:id
    [id]/
      settings.vue       β†’  /users/:id/settings
  [...slug].vue         β†’  /every other path (catch-all)
pages/users/[id].vueVUE
<script setup>
const route = useRoute();
const { data: user } = await useFetch(`/api/users/${route.params.id}`);
</script>

<template>
  <h1>{{ user?.name }}</h1>
</template>

Tip

The file name is the URL, so no separate router configuration file is needed β€” to add a page, just create a new .vue file under pages/.

useFetch / useAsyncData

Here you look at useFetch / useAsyncData alongside real code. Rather than copying the example as-is, read it with an eye on the inputs, the outputs, and the parts most likely to change.

useFetch fetches the data once on the server side and passes it straight to the client, so the same request is not sent again from the browser. It re-requests automatically when a reactive value in the watch option changes, so there is no need to write code that calls fetch again by hand every time userId changes.
VUE
<script setup>
const userId = ref(1);

// reactive params β†’ re-runs automatically when userId changes
const { data: user, pending, error } = useFetch(
  () => `/api/users/${userId.value}`,
  { watch: [userId] }
);
</script>

<template>
  <p v-if="pending">Loading...</p>
  <p v-else-if="error">An error occurred</p>
  <div v-else>{{ user?.name }}</div>
</template>

Nitro server API routes

Here you look at Nitro server API routes alongside real code. Rather than copying the example as-is, read it with an eye on the inputs, the outputs, and the parts most likely to change.

Creating a file under server/api/ makes it a backend endpoint in itself, so you can run the API in the same project as the frontend with no separate Express or NestJS server. A suffix in the file name such as .get.ts determines the HTTP method, so REST conventions are followed with no router configuration.
server/api/users/index.get.tsTYPESCRIPT
import { defineEventHandler, getQuery } from 'h3';

export default defineEventHandler(async (event) => {
    const { page = 1 } = getQuery(event);
    const users = await db.user.findMany({
        skip: (Number(page) - 1) * 20,
        take: 20,
    });
    return users;
});

SEO & Meta

Here you look at SEO & Meta alongside real code. Rather than copying the example as-is, read it with an eye on the inputs, the outputs, and the parts most likely to change.

useSeoMeta is a composable for declaring the title, description, Open Graph, and Twitter Card tags of each page in one go. Nuxt plants these values directly into the HTML head during server rendering, so search engines and social media crawlers can read the meta information without running JavaScript.
VUE
<script setup>
useSeoMeta({
    title: 'My Page',
    description: 'Page description',
    ogTitle: 'My Page',
    ogImage: '/og-image.png',
    twitterCard: 'summary_large_image',
});
</script>

Deployment

Here you look at Deployment alongside real code. Rather than copying the example as-is, read it with an eye on the inputs, the outputs, and the parts most likely to change.

Thanks to the Nitro engine, Nuxt can build the same codebase for several deployment targets. If `nitro.preset` is not set, Nuxt detects the deployment environment (Vercel, Netlify, and so on) automatically and uses the appropriate preset.
BASH
# Build as a default Node server (SSR)
npm run build
node .output/server/index.mjs

# Generate a fully static site (SSG)
npx nuxi generate
nuxt.config.tsTYPESCRIPT
export default defineNuxtConfig({
  nitro: {
    preset: 'vercel',   // 'node-server' | 'netlify' | 'cloudflare-pages' and so on
  },
});
Deployment targetCommandCharacteristics
Node server (SSR)npm run buildServer rendering on every request β€” suits real-time data
Static site (SSG)npx nuxi generatePre-generates every page as HTML at build time β€” suits blogs and the like
Vercel/Netlify/CloudflareSet nitro.presetOptimized automatically for the edge/serverless runtime of the platform

Nuxt.js practical design

Nuxt.js practical design is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

With Nuxt, decide the SSR/CSR/hybrid strategy per page. Auto imports and conventions are convenient, but manage them so boundaries do not blur.
Decision pointQuestion to askPractical guideline
BoundariesWhich parts of the Nuxt.js code are most likely to change?Separate input/output, configuration, external integrations, and the core rules.
StateWhere is state created and where does it go away?Make the owner and lifecycle of state visible in the code.
FailureWhat does the caller receive on failure?Decide the timeout, fallback, and error contract first.

Nuxt.js operating standards

This section covers Nuxt.js operating standards from a practical perspective. Instead of memorizing the concept, focus on the situations in which you would reach for it.

The Nitro server, route rules, payload size, caching, and image optimization affect production performance.

Tip

  • route rules
  • payload size
  • Nitro API
  • SEO metadata

Nuxt.js verification strategy

Nuxt.js verification strategy is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

Verify route rules, the server API, hydration, and SEO metadata.
Quality axisHow to verifyDefinition of done
CorrectnessAutomate the normal/failure cases.The core scenarios pass reproducibly.
Regression preventionWhen fixing a bug, leave the same case behind as a test.The same failure is not deployed again.
OperabilityCheck the logs, metrics, and alerts.There is a path for tracing the cause when a problem occurs.

Nuxt.js: frequently asked questions

What is the difference between Nuxt and Vue?

Vue is a framework for building screens, and Nuxt is a full-stack framework that adds file-based routing, server rendering, data fetching, and server APIs on top of Vue. It occupies the same place for Vue that Next.js does for React.

Why use useFetch and useAsyncData? Can I not just use fetch?

They pass data fetched during server rendering to the browser so the same request is not sent again. A plain fetch in a component sends the request twice, once on the server and once in the browser. For a request made once in response to a user action, such as a button click, use $fetch.

Where can I deploy a Nuxt app?

The server engine builds output for different runtimes, so you can deploy to a Node.js server, serverless platforms, or edge runtimes. A site that needs no server can be generated as static files and put on static hosting.

← Previous guideVueNext guide β†’Electron