Vue Roadmap: Learn Vue 3 Step by Step in 6 Months
8 min read ยท 2026-10-08
A good vue roadmap goes in this order: solid JavaScript first, then Vue 3 templates and reactivity, then single file components with the Composition API, then Vue Router and Pinia, then TypeScript and testing, and finally Nuxt for full stack apps. With steady practice, that path takes about five to six months, and every phase ends with a project you can show.
This guide gives you the full plan, with a duration, concrete steps and a milestone for each phase. It also explains where the official Vue project roadmap lives today, how to shorten the plan if you already know another framework, and how to tell when you are ready for real Vue work.
The roadmap at a glance
Goal: Build, test and deploy production ready Vue 3 applications with the Composition API and the official ecosystem. Duration: 5 to 6 months
JavaScript Prerequisites (Weeks 1 to 3)
Lock in the JavaScript and web basics that Vue builds on.
- Practice semantic HTML, CSS Flexbox and responsive layouts.
- Use arrow functions, destructuring, spread syntax and array methods without looking them up.
- Write ES modules and handle async code with promises and async and await.
- Install Node.js and VS Code with the official Vue extension.
Milestone: A small vanilla JavaScript app that fetches and filters data from a public API.
Vue Fundamentals (Weeks 4 to 7)
Understand templates, reactivity and basic components.
- Scaffold a project with create-vue and Vite, then read through its folder structure.
- Use template syntax: interpolation, v-bind, v-on, v-if, v-show and v-for with keys.
- Create reactive state with ref and reactive, and know when to use each.
- Derive values with computed and react to changes with watch and watchEffect.
- Bind form inputs with v-model, including checkboxes, selects and modifiers.
Milestone: A single page budget or habit tracker with reactive state, computed totals and forms.
Components and Composables (Weeks 8 to 11)
Structure apps from reusable components and reusable logic.
- Write single file components with script setup, a template and scoped styles.
- Pass data down with defineProps and send events up with defineEmits.
- Use default and named slots to build flexible layout components.
- Extract stateful logic into composables such as useFetch or useLocalStorage.
- Use provide and inject for deeply nested dependencies, and lifecycle hooks like onMounted.
Milestone: A small component library (buttons, modal, tabs, data table) reused across several pages.
Routing and State (Weeks 12 to 15)
Build multi page apps with shared state.
- Add Vue Router with nested routes, dynamic params and lazy loaded views.
- Protect pages with navigation guards for logged in users.
- Manage shared state with Pinia stores written in the setup store syntax.
- Fetch and cache server data with TanStack Query for Vue or your own composable.
Milestone: A multi page dashboard with login, protected routes and user state in Pinia.
Quality and Tooling (Weeks 16 to 19)
Write typed, tested and maintainable Vue code.
- Add TypeScript to props, emits, refs and Pinia stores.
- Run vue-tsc for type checking and ESLint with eslint-plugin-vue.
- Write component tests with Vitest and Vue Test Utils.
- Add end to end tests for key user flows with Playwright or Cypress.
- Debug state and performance with Vue DevTools.
Milestone: The same dashboard, fully typed, with unit and end to end tests passing in CI.
Nuxt and Capstone (Weeks 20 to 24)
Build a full stack, search friendly app with Nuxt.
- Learn Nuxt file based routing, layouts and auto imports.
- Fetch data with useFetch and useAsyncData on the server and the client.
- Build API endpoints in the Nuxt server directory with Nitro.
- Set SEO metadata, pick a rendering mode and deploy to Netlify, Vercel or a Node host.
Milestone: A deployed Nuxt app with server routes, a database and a README that explains your choices.
Where to find the official Vue roadmap
Some people searching for a Vue roadmap want the plans of the Vue project itself, not a learning path. The official GitHub repository vuejs/roadmap was archived by its owner on Jan 2, 2019. It is read-only now, so its content is no longer current. The page says: "Please refer to the Roadmap Project Board for the latest roadmap."
For a learner, the takeaway is simple. Treat the archived repository as history, not as a guide to what Vue looks like today. Build your skills on the current stable version of Vue 3, and use the learning plan above to do it in order.
How to adapt this roadmap to your starting point
The six month plan assumes you study a few hours most days and start with basic JavaScript. Your starting point changes the plan more than anything else, so adjust it before you begin, not halfway through.
Write your adjusted dates next to each phase. You can check a milestone that has a date. You cannot check a vague goal like "get better at Vue".
- New to JavaScript: double Phase 1 to six weeks. Vue hides very little of JavaScript, and weak basics cause most later bugs.
- Comfortable with JavaScript, new to frameworks: follow the plan as written.
- Coming from React: compress Phases 2 and 3 into about three weeks. Focus on template syntax, ref versus reactive and slots, which have no exact React equivalent.
- Coming from Vue 2: skip Phase 1, go straight to script setup, Pinia and the Vite based tooling, then spend extra time on TypeScript.
- Only a few hours a week: keep the phase order but stretch each phase, and never skip the milestone project.
Composition API or Options API
Vue 3 supports two ways of writing components. The Options API groups code by option type: data, methods, computed and watch. The Composition API, usually written with script setup, groups code by feature and makes it natural to reuse logic through composables. Both are fully supported, and many older tutorials and codebases use the Options API.
If you start now, learn the Composition API with script setup first. It works better with TypeScript, scales well in larger apps and is the style most current Vue 3 code uses. Learn enough of the Options API to read it, because you will meet it in Vue 2 projects, older forum answers and some company codebases.
Understanding Vue reactivity
Vue tracks which reactive values each part of the interface reads, and it updates only what depends on data that changed. ref wraps any value and is read with .value in script, but it unwraps automatically in templates. reactive makes an object deeply reactive, but it loses reactivity if you destructure it or replace the whole object.
Most beginner bugs come from breaking reactivity by accident. The usual causes are destructuring props or a reactive object, replacing a reactive object entirely, or forgetting .value in script. Many developers use ref for everything to keep behavior consistent, and reach for toRefs or storeToRefs when they need to destructure.
- ref: works for primitives and objects; use .value in script.
- reactive: objects only; do not destructure or reassign it.
- computed: cached derived values; keep side effects out.
- watch: runs side effects when specific sources change.
Projects to build at each stage
Pick projects that force you to use each new concept. Early projects should stress reactivity and forms. Mid level projects need several components, composables and routing. Advanced projects bring in Pinia, TypeScript, tests and server data. Keep every project on GitHub with a README and a live deployment.
At the end, rebuild one early project with everything you learned. Turning a single file tracker into a typed, routed, tested app with Pinia shows your growth clearly. It also gives you a real refactoring story for interviews or client calls.
- Beginner: quiz app, recipe filter, budget tracker.
- Intermediate: Kanban board with drag and drop, weather dashboard built on composables.
- Advanced: logged in dashboard with Pinia and Vue Router, typed and tested.
- Full stack: Nuxt blog or booking app with server routes and a database.
Learning resources by type
The official Vue documentation at vuejs.org is the main resource. You can switch every example between the Composition API and the Options API, and it includes an interactive tutorial. Read the Essentials and Components sections fully, then Reusability and Scaling Up as you move through the phases.
Use the Vue SFC Playground to test ideas without any setup. The official docs for Vue Router, Pinia and Nuxt are just as complete. Vue Mastery and Vue School offer structured video courses if you prefer guided lessons. Reading the VueUse source code shows how experienced developers write composables.
- Docs: vuejs.org, router.vuejs.org, pinia.vuejs.org, nuxt.com.
- Practice: SFC Playground and Frontend Mentor designs.
- Utilities: VueUse for real world composable patterns.
- Debugging: the Vue DevTools browser extension.
How to know you are ready
You are ready for professional Vue work when you can design a component tree and choose between local state, props, provide and inject or Pinia. You can write composables that keep logic clean, and you avoid the common reactivity traps without thinking about them. You can also debug with Vue DevTools and write tests that check real behavior.
A good final test: build a feature from a written spec with no tutorial, such as a filterable product list with filters synced to the URL and a cart in Pinia. If you finish it with types and tests and can explain each choice, you are ready for junior Vue roles or freelance Vue and Nuxt projects.
Common mistakes to avoid
- Mixing Vue 2 and Vue 3 tutorials creates confusion, so check that every resource targets Vue 3 and the Composition API.
- Destructuring reactive objects or props breaks reactivity, so use toRefs or read the properties directly.
- Putting side effects inside computed properties causes bugs that are hard to find, so move them into watch or event handlers.
- Storing everything in Pinia overcomplicates small features, so keep state local until several components need it.
- Using v-if and v-for on the same element causes precedence problems, so wrap the list in a template tag instead.
- Skipping keys in v-for lists leads to rendering glitches, so always bind a stable, unique key.
Frequently asked questions
Is there an official Vue roadmap?
The Vue project had an official roadmap repository on GitHub, vuejs/roadmap. Its page shows it was archived on Jan 2, 2019, and it tells readers to "refer to the Roadmap Project Board for the latest roadmap". That repository covers the plans for the framework itself, not how to learn it. If you want a learning path, a phased plan like the one above takes you from JavaScript basics to Nuxt in order.
How long does it take to learn Vue.js?
With solid JavaScript, you can build simple Vue apps in two to three weeks. Getting comfortable with components, composables, Vue Router, Pinia, TypeScript, testing and Nuxt takes about five to six months of steady practice, which is the pace of the plan above.
Is Vue easier to learn than React?
Many developers find Vue easier to start with, because its templates look like HTML and its ecosystem has official libraries for routing and state. React leaves more of those choices to you. Concepts like components, props and reactive state carry over between the two.
Should I learn Vuex or Pinia?
Learn Pinia. It is the officially recommended state library for Vue 3, with a simpler API and better TypeScript support. Vuex is in maintenance mode and mostly shows up in older Vue 2 codebases. Pinia's stores, state, getters and actions make Vuex easy to pick up if a team still uses it.
When should I learn Nuxt?
Learn Nuxt once Vue components, the Composition API and Vue Router feel natural. Nuxt adds file based routing, server rendering, data fetching and server routes, which make much more sense on top of solid Vue basics. It is especially useful for content sites, pages built for search and full stack apps.