Frontend Roadmap: 9-Month Plan to Your First Job
7 min read ยท 2026-10-31
A good frontend roadmap goes in this order: HTML and CSS, then JavaScript, Git, TypeScript, one framework, and finally testing, accessibility and performance. If you work on it steadily part time, plan on about 6 to 9 months to reach a junior level. Each phase ends with a project you can show.
Most frontend developer roadmaps online are long lists of topics with no order and no timing. This guide gives you phases with durations, concrete steps and a milestone for each one. You can use it to learn on your own, or as a training and migration plan if you lead a frontend team.
The roadmap at a glance
Goal: Go from your first HTML page to a junior frontend developer role, with one deployed project per phase. Duration: 6 to 9 months, part time
Browser Foundations (Weeks 1 to 4)
Learn how the browser turns HTML and CSS into a page that works on every screen.
- Structure pages with semantic HTML: headings, landmarks, forms and labels.
- Learn the CSS box model, the cascade, Flexbox and Grid.
- Make layouts responsive with media queries and fluid units.
- Check every page with the keyboard only and with browser DevTools.
- Deploy a static site to a free host.
Milestone: A responsive three-page site, live online, that you can fully use with the keyboard.
JavaScript Core (Weeks 5 to 8)
Write JavaScript you can debug without a tutorial open.
- Practice variables, functions, arrays, objects and control flow every day.
- Update the page through the DOM and handle events and forms.
- Fetch data from a public API with async and await, and handle errors.
- Use breakpoints and the console to find bugs instead of guessing.
Milestone: An interactive app that loads real API data, shows loading and error states, and has no console errors.
Professional Workflow and TypeScript (Weeks 9 to 12)
Work the way teams do, with version control, a build tool and types.
- Use Git daily: commits, branches, merges and pull requests on GitHub.
- Set up a project with Node.js, npm and a bundler such as Vite.
- Add a linter and a formatter so the code style stays the same.
- Move one JavaScript project to TypeScript and type its data and functions.
Milestone: A public repository with a clear README, clean commit history and a working TypeScript build.
One Framework, Learned Well (Months 4 and 5)
Build real interfaces with components and state in a single framework.
- Pick React, Angular, Vue or Svelte and stick with it for this phase.
- Learn components, props, local state and side effects.
- Add routing, forms and data fetching from an API.
- Organize folders, shared components and global state in a way a teammate can follow.
Milestone: A multi-page app with routing, forms and saved data, deployed and documented.
Quality: Testing, Accessibility, Performance (Month 6)
Make your work safe to change, usable by everyone and fast.
- Write unit tests for logic and component tests for what users actually do.
- Audit accessibility: focus order, labels, color contrast, screen reader names.
- Measure the three Core Web Vitals (LCP, INP, CLS) before you optimize anything.
- Fix the biggest issue the measurement shows, then measure again.
Milestone: Your framework app has tests for its main user flows and a before and after performance report.
Job Readiness (Months 7 to 9)
Turn your projects into proof and get ready for interviews.
- Keep three projects, each with a README that explains the problem, the choices and the tradeoffs.
- Practice JavaScript, CSS and framework questions out loud.
- Rebuild small UI components from scratch with a timer running.
- Apply to junior roles with a resume that links to live projects.
Milestone: Three polished projects online and your first technical interviews booked.
What a frontend developer does
A frontend developer builds the part of a website or app that people see and use: layout, buttons, forms, navigation and everything that reacts to a click. The job brings together design, code and what users need. Pages have to look right, work on every device, load fast and stay usable with a keyboard or a screen reader.
That's why the core skills go beyond one language. Core skills include HTML, CSS and JavaScript, accessibility, Git, responsive design, REST APIs, testing, browser developer tools and one framework. The roadmap above covers them in an order where each one builds on the one before.
Which framework to learn first: React, Angular, Vue or Svelte
The four frameworks most guides suggest are React, Angular, Vue and Svelte. Learn one well, not four a little. Three simple questions will help you choose:
Leave the framework until after the JavaScript and TypeScript phases. Components, state and data fetching only make sense once you can read plain JavaScript and its errors. With solid fundamentals, picking up a second framework later is mostly a matter of learning new syntax.
- Local job ads: which framework shows up most in the junior roles you would apply to?
- Your team: if you already work in a company, which one does the codebase use?
- Learning style: do you want a small library you build around, or a full framework with more built in?
Beginner, job ready, senior: how the frontend roadmap changes
The roadmap isn't the same at every level, and that's where many learners lose time. A beginner starts with the browser basics and JavaScript. A job-ready developer adds Git, TypeScript, one framework, tests and projects that hold up when someone reads the code. A senior owns architecture, performance budgets, accessibility standards and the review process.
Here's what you can do once you reach each stage:
- Beginner: you can build and deploy a responsive page and fix your own bugs.
- Job ready: you can join a codebase, pick up a ticket and open a clean pull request.
- Senior: you set the patterns others follow and can explain the tradeoffs to non-developers.
Frontend developer roadmap PDF, image and GitHub versions
Many people want a frontend developer roadmap as a PDF or an image to keep next to their desk. You can find community roadmaps on GitHub and in threads on Reddit, and they give a useful overview of the topics. Whichever version you keep, add your own dates and a milestone for each phase so you always know what to work on this week.
The same goes for older versions. A frontend developer roadmap from 2018, 2023, 2024 or 2025 still rests on the same base: semantic HTML, modern CSS layout, JavaScript, Git and responsive design. What changes over the years is the list of tools on top. That's why this roadmap puts TypeScript, accessibility, testing and performance inside the core phases instead of leaving them for the end. If you follow an older roadmap, keep its foundations and replace its tool list with the phases above.
How to prepare for frontend interviews
Frontend interviews usually mix three things: questions on JavaScript and CSS, a live coding exercise where you build a small UI component, and a talk about one of your projects. Prepare for all three during the last phase, not the week before.
- Explain closures, the event loop, promises and the cascade in plain words.
- Build a modal, tabs, a dropdown or a search filter from scratch in under an hour.
- Pick one project and be ready to explain why you made each choice and what you would change.
- Review your own code on GitHub as if you were the interviewer.
Using a frontend roadmap for a team or a migration
The same structure works when you're the one planning, not learning. A team lead can use the phases to bring new hires up to speed, or to plan a move from plain JavaScript to TypeScript or from one framework to another. Each phase becomes a period of work with a clear owner, and each milestone becomes something you can check in a review.
For a team plan, keep it short and easy to present:
- One goal at the top, such as "whole codebase typed" or "new hires shipping in their first month".
- Four to six phases with dates, not topics.
- One measurable milestone per phase, such as test coverage on key flows or Core Web Vitals passing on main pages.
- A named owner for each phase and a date to review it.
Common mistakes to avoid
- Jumping to a framework before JavaScript leaves you stuck on every bug. Finish the JavaScript phase and its milestone first.
- Trying to learn everything on the roadmap at once kills your progress. Treat it as a map and follow one phase at a time.
- Watching tutorials without building feels like learning but isn't. Write the project for each phase without looking at the video.
- Leaving accessibility and tests for later makes them much harder to add. Check the keyboard and screen reader from the first phase.
- Following a roadmap with no dates lets weeks slip. Give each phase an end date and review it when that date comes.
- Filling your portfolio with copied tutorial apps doesn't show your skills. Keep three original projects and document your choices.
Frequently asked questions
How long does it take to become a frontend developer?
It depends on your starting point and how many hours you put in each week. This roadmap plans 6 to 9 months of part-time study to reach a junior level, with the fundamentals done by month 6 and the last months spent on projects and interviews.
When should I learn TypeScript?
Learn it once you're comfortable with JavaScript, and before your projects get large. In this roadmap it comes in weeks 9 to 12, right before the framework phase. Converting a project you already wrote is the fastest way to see what types catch.
Should I learn everything on the frontend developer roadmap?
No. A full roadmap is a map of the field, not a to-do list for one person. Learn the core in order, ship one project per phase, and leave niche tools until a job or a project needs them.
What is the difference between frontend and backend development?
Frontend is what runs in the browser: layout, interaction and how the interface behaves. Backend is what runs on the server: data, business rules, authentication and APIs. A frontend developer still needs to understand REST APIs to work with backend data.
Is frontend development really coding?
Yes. HTML and CSS describe structure and style, and JavaScript and TypeScript are full programming languages. Modern frontend work includes state management, data fetching, testing and performance, and all of it is written in code.