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. Vue
Complete guide to the frontend framework

πŸ’š Vue Complete Guide

Visitors

Build modern web applications with the Vue 3 Composition API. A complete guide covering the reactivity system, component communication, Pinia state management, and Nuxt.js integration.

  • Intermediate
  • Updated Oct 1, 2026
  • ~3 min read
  • 8 sections
  • 6 code examples
  • Web IDE lab included
πŸ’š

Vue Web IDE

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

Open the Web IDE β†’
SPANuxt.js SSRIncremental migrationAdmin dashboards

Contents

0 / 11
  1. How to use this guide
  2. Architecture diagrams
  3. Environment setup
  4. Composition API & reactivity
  5. Component communication (Props/Emit)
  6. Pinia state management
  7. Nuxt.js
  8. Vue design
  9. Operating standards
  10. Verification strategy
  11. Frequently asked questions
Contents 11 sections
  1. How to use this guide
  2. Architecture diagrams
  3. Environment setup
  4. Composition API & reactivity
  5. Component communication (Props/Emit)
  6. Pinia state management
  7. Nuxt.js
  8. Vue design
  9. Operating standards
  10. Verification strategy
  11. Frequently asked questions

How to use this guide

How to read it

Understanding Vue as a real-world workflow

Build modern web applications with the Vue 3 Composition API. A complete guide covering the reactivity system, component communication, Pinia state management, and Nuxt.js integration. 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.

SPANuxt.js SSRIncremental migrationAdmin dashboards

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 Vue.

Learning flow

Rendering diagram…

Architecture view

Rendering diagram…

Environment setup

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

create-vue is the official scaffolding tool that sets up a Vite-based project structure interactively. If you need server-side rendering (SSR), people often start with Nuxt 3, which layers file-based routing and SSR on top of Vue, rather than configuring Vue directly.
BASH
npm create vue@latest my-app
cd my-app && npm install && npm run dev

# Nuxt 3 (SSR)
npx nuxi@latest init my-nuxt-app

Composition API & reactivity

Here you look at Composition API & reactivity 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.

Whenever a value wrapped in `ref` changes, only the parts of the screen that use that value are redrawn automatically. `computed` is a cached value recalculated only when the values it depends on change, and `watch` runs side effects (API calls, logging, and so on) at the moment a value changes.
Counter.vueVUE
<script setup lang="ts">
import { ref, computed, watch } from 'vue';

const count = ref(0);
const doubled = computed(() => count.value * 2);

watch(count, (newVal) => {
  console.log('count changed:', newVal);
});

function increment() { count.value++; }
</script>

<template>
  <button @click="increment">Count: {{ count }} (x2: {{ doubled }})</button>
</template>

Tip

A ref has to be accessed through `.value`, but inside the template (<template>) Vue unwraps it automatically, so writing just `count` works β€” remember the rule that `.value` is added only inside the `<script>` block and you will not get confused.

Component communication (Props/Emit)

Here you look at Component communication (Props/Emit) 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.

Vue components are built on a one-way data flow: data goes down from parent to child through props, and events go up from child to parent through emit. Because a child never changes the state of its parent directly, it is easy to trace where and why data changed.
ChildInput.vueVUE
<script setup lang="ts">
const props = defineProps<{ modelValue: string }>();
const emit = defineEmits<{ 'update:modelValue': [value: string] }>();

function onInput(e: Event) {
  emit('update:modelValue', (e.target as HTMLInputElement).value);
}
</script>

<template>
  <input :value="props.modelValue" @input="onInput" />
</template>
Parent.vueVUE
<script setup>
import { ref } from 'vue';
const name = ref('');
</script>

<template>
  <!-- v-model is shorthand for :modelValue + @update:modelValue -->
  <ChildInput v-model="name" />
  <p>Input: {{ name }}</p>
</template>

Tip

If you try to modify a value received as a prop directly inside a child component, Vue shows a warning β€” props are always owned by the parent, so the child should only ask through emit, "please change it like this".

Pinia state management

Here you look at Pinia state management 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.

Use Pinia when several components need to share the same state without passing through several levels of a props/emit chain. A store is a single centralized reactive object, with roles divided into state (data), getters (computed values), and actions (logic that changes state).
stores/user.tsTYPESCRIPT
import { defineStore } from 'pinia';

export const useUserStore = defineStore('user', {
  state: () => ({ name: '', isLoggedIn: false }),
  getters: {
    greeting: (state) => `Hello, ${state.name}!`,
  },
  actions: {
    login(name: string) {
      this.name = name;
      this.isLoggedIn = true;
    },
    logout() {
      this.name = '';
      this.isLoggedIn = false;
    },
  },
});

Tip

If a value is only passed down about 2-3 levels of the component tree, Pinia is often unnecessary β€” first check whether props/emit or provide/inject is enough, and move only state that several screens really need to share into a store.

Nuxt.js

Here you look at Nuxt.js 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 3 is the Next.js of Vue. It provides file-based routing, SSR, and auto imports.
pages/index.vueVUE
<script setup>
const { data } = await useFetch('/api/posts');

useSeoMeta({
  title: 'My Blog',
  description: 'Blog powered by Nuxt 3',
});
</script>

<template>
  <div v-for="post in data" :key="post.id">
    <NuxtLink :to="`/posts/${post.id}`">{{ post.title }}</NuxtLink>
  </div>
</template>

Tip

The file-based routing, Nitro server, and deployment options of Nuxt itself are covered in more depth in the /learn/nuxt/ guide.

Vue practical design

Vue 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.

In Vue, separating domain logic into composables with the Composition API improves reuse and testing.
Decision pointQuestion to askPractical guideline
BoundariesWhich parts of the Vue 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.

Vue operating standards

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

Manage reactivity cost, watcher overuse, bundle size, and route-level code splitting.

Tip

  • composable boundary
  • watcher cost
  • route split
  • component tests

Vue verification strategy

Vue 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.

Test component events, slots, form validation, and async loading states.
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.

Vue: frequently asked questions

Should I use the Options API or the Composition API?

For a new project, the Composition API is recommended. Related logic stays together, is easy to extract into functions for reuse, and works well with TypeScript. The Options API remains supported, so there is no need to rewrite existing code in a hurry.

When do I use ref and when reactive?

ref can wrap a value of any type and is accessed with .value in script. reactive works only with objects and loses reactivity when you destructure it or reassign the whole thing. Because it has fewer traps, defaulting to ref is widely recommended.

Should I use Vuex or Pinia?

New projects use Pinia. It is the official state management library for Vue, changes state without mutations so the code is shorter, and its TypeScript inference is good. Vuex remains for maintaining existing projects.

← Previous guideNext.jsNext guide β†’Nuxt.js