Angular Roadmap: Learn Modern Angular in 6 Phases

8 min read ยท 2026-10-23

A good angular roadmap has six phases, in this order: TypeScript first, then standalone components and templates, then signals and services, then routing, HTTP and RxJS, then forms, and finally testing, performance and server-side rendering. This plan is built for 24 weeks at 8 to 10 hours of practice a week, for someone who already writes solid JavaScript. If you have more or fewer hours, the length changes.

Each phase below has a time box, concrete steps, a practice project and a milestone you can check. The guide also explains what the official Angular roadmap means for what you should learn today.

The roadmap at a glance

Goal: Build, test and deploy maintainable Angular applications using standalone components, signals and the official tooling. Duration: 24 weeks at 8 to 10 hours per week (adjust to your own hours)

  1. TypeScript Foundations (Weeks 1 to 3)

    Get comfortable with the language Angular is written in before you touch the framework.

    • Review modern JavaScript: modules, classes, arrow functions, destructuring, promises and async/await.
    • Learn TypeScript types, interfaces, union types, generics and access modifiers.
    • Understand decorators at a basic level, since Angular uses them to mark components and services.
    • Install Node.js, the Angular CLI and an editor with the Angular Language Service.

    Milestone: A small typed command line program that uses classes, interfaces and one generic function, with no TypeScript errors.

  2. Components and Templates (Weeks 4 to 7)

    Build interfaces with standalone components and the modern template syntax.

    • Create a new app with ng new and read through every generated file.
    • Generate standalone components with ng generate and compose them into a page.
    • Practice interpolation, property binding, event binding and two-way binding.
    • Use the built-in control flow blocks @if, @for with track, and @switch.
    • Pass data with the input and output functions and style each component with scoped CSS.

    Milestone: A product listing page with reusable card components and working filter controls.

  3. Signals and Services (Weeks 8 to 11)

    Manage state with signals and share logic through dependency injection.

    • Create state with signal, derive values with computed and run side effects with effect.
    • Use linkedSignal for state that must reset when another value changes.
    • Load data with resource and httpResource, and handle their loading and error states.
    • Write injectable services and use them with the inject function.
    • Learn providers, the injector hierarchy and providedIn root singletons.
    • Clean up resources with DestroyRef and lifecycle hooks.

    Milestone: A shopping cart shared by three components through one signal-based service.

  4. Routing, HTTP and RxJS (Weeks 12 to 16)

    Build multi-page apps that talk to real APIs.

    • Set up routes with lazy-loaded components, route parameters and child routes.
    • Protect routes with functional guards and load data with resolvers.
    • Call REST APIs with HttpClient and add a functional interceptor for auth headers.
    • Learn the core RxJS operators: map, filter, switchMap, debounceTime, catchError and combineLatest.
    • Connect observables and signals with toSignal and toObservable.

    Milestone: A multi-page app with login, protected routes, debounced search and lazy loading.

  5. Forms and UI (Weeks 17 to 20)

    Handle complex input and build interfaces people can actually use.

    • Build new forms with Signal Forms, which manage form state with signals.
    • Learn typed reactive forms with FormGroup, FormControl and FormArray, since most existing codebases use them.
    • Write built-in, custom and async validators with clear error messages.
    • Use Angular Material and the CDK for dialogs, tables and overlays.
    • Add labels, focus management and ARIA attributes so the forms work with a keyboard and screen readers.

    Milestone: A multi-step registration form with dynamic fields, async validation and full keyboard support.

  6. Testing and Production (Weeks 21 to 24)

    Ship an app that is tested, fast and deployed.

    • Write unit tests for components and services with Vitest and the Angular testing utilities.
    • Add end-to-end tests for your main user flows with Playwright or Cypress.
    • Improve speed with OnPush change detection, zoneless change detection, deferrable views and lazy loading.
    • Add server-side rendering and hydration with Angular SSR where search visibility matters.
    • Build for production and deploy to a host such as Firebase Hosting, Netlify or a Node server.

    Milestone: A deployed capstone app with tests running in CI and SSR turned on.

Prerequisites: what to know before Angular

Angular expects you to know the web platform. Before phase one, you should be able to build a simple page with HTML and CSS, including a layout with flexbox or grid, and write JavaScript that fetches data and updates the DOM. If those feel shaky, add a few weeks for them before you start. Every Angular error is harder to read when the underlying JavaScript is unclear.

TypeScript is not optional. Angular projects are TypeScript projects, and the framework's APIs rely on types to catch mistakes early. The good news: you do not need advanced type gymnastics. Interfaces, union types, generics and classes cover most of what you will write at first.

  • Must know: HTML forms, CSS layout, JavaScript functions, arrays, objects, promises.
  • Learn in phase one: TypeScript types, interfaces, generics, classes.
  • Nice to have: basic Git and the command line, since the Angular CLI runs there.

Modern Angular versus older tutorials

Angular has changed a lot in recent major versions. Standalone components replaced NgModules as the default. Signals brought fine-grained reactivity. The control flow blocks @if and @for replaced the ngIf and ngFor directives. Functional guards, interceptors and the inject function replaced many class-based patterns.

This matters because many tutorials still teach module-based Angular. Those apps still run and you will meet them at work, but learning that way first adds complexity you do not need. Learn the modern patterns first, then learn to read the older ones.

  • Use: standalone components, signals, @if and @for, inject, functional guards.
  • Recognize: NgModules, ngIf and ngFor, constructor injection, class-based guards.
  • Check: the publish date and Angular version of any tutorial before following it.

What the official Angular roadmap means for learners

The Angular team publishes its own roadmap on angular.dev/roadmap. It is not a study plan. It lists what the team is building, with three stated goals: improve the AI experience for developers, improve the Angular developer experience, and improve the framework's performance. Reading it tells you which skills are rising and which are fading.

The points below come from that page as it read on October 22, 2026, when the site showed Angular v22. The roadmap changes with each release, so check the page again before you plan around it.

For a learner, the message is clear. Signals are now at the center of state, data loading and forms, and the old reliance on zone.js is going away.

  • Zoneless: the page says that "as of Angular v20.2, Zoneless Angular is now stable". This means you can run Angular without zone.js in your bundle.
  • Signal Forms: the page says "Signal Forms are now stable". They manage form state with signals.
  • Vitest: the page says that following its stable release in Angular v21, Vitest "is now our primary test runner". The team is now working on promoting its experimental Karma to Vitest migration tool to stable.
  • resource and httpResource: the page lists these signal APIs for asynchronous data as promoted to stable.
  • linkedSignal and effect: both appear in the roadmap's "Production ready" section.
  • Incremental hydration and route-level render modes: the page says both graduated to stable in v20.
  • Angular Aria: the page says it launched in developer preview in Angular v21 and was promoted to stable in Angular v22. It gives you patterns for accessible, headless components.
  • Web MCP: listed under "Available to experiment with".
  • Learn now: signals, computed, linkedSignal, resource and httpResource, standalone components, SSR with hydration.
  • Use for new work: Signal Forms for forms, Vitest for unit tests, zoneless change detection.
  • Still learn to read: reactive forms and Karma test setups, which you will meet in existing codebases.

Signals and RxJS: when to use each

Signals and RxJS solve different problems. Signals fit synchronous state that the UI reads: the current user, a cart, a filter value, a toggle. RxJS fits streams of events over time: debounced search, WebSocket messages, and requests that must be cancelled.

Use signals for component and app state, and RxJS where time and cancellation matter. Convert at the edges with toSignal and toObservable. You do not need every operator: the six listed in phase four cover most everyday code.

Practice projects by level

Projects turn reading into skill. Pick one per level, finish it, and put it on GitHub with a short README that explains your choices.

  • Beginner: a to-do list with filters, a recipe browser that reads a public API, a unit converter.
  • Intermediate: a movie search app with debounced search and detail routes, an expense tracker with forms and charts.
  • Advanced: an admin dashboard with login, role-based routes, tables and tests, or a booking system with SSR and a deployed backend.

Adapting this plan to your schedule

The plan follows a simple template: one goal, a total duration, phases with a time box, and one checkable milestone per phase. Copy it into a spreadsheet, Notion or a visual roadmap board and mark each step done as you go.

If you can only study about half the hours, double each phase instead of cutting steps. If a milestone slips, add a week to that phase and move the later dates.

Common mistakes to avoid

  • Starting Angular without TypeScript basics makes every error confusing, so spend the first three weeks on types, classes and generics.
  • Following NgModule-based tutorials as a beginner adds needless complexity, so learn standalone components and signals first.
  • Subscribing to observables without cleanup causes memory leaks, so use the async pipe, toSignal or takeUntilDestroyed.
  • Nesting subscribe calls inside each other creates tangled code, so use operators like switchMap instead.
  • Putting business logic inside components makes them hard to test, so move it into injectable services.
  • Watching courses without building anything leaves gaps you only find in interviews, so finish one project per phase.

Frequently asked questions

How long does it take to learn Angular?

It depends on your JavaScript level and your weekly hours. This plan estimates 24 weeks at 8 to 10 hours a week for someone with solid JavaScript. On that schedule, you build your first multi-component page by the end of phase two, around week 7. Advanced RxJS and performance work keep developing on real projects.

Do I need to learn TypeScript before Angular?

Yes. Angular is written in TypeScript and every new project uses it. You only need the basics to start: types, interfaces, classes and generics, which this plan covers in the first three weeks.

Should I learn Angular or React first?

Choose based on the jobs you want and how you like to work. Angular is a complete framework with routing, forms and testing built in, and it is common in enterprise teams. React is a library with a large ecosystem of separate tools. Check job listings in your region, since core frontend skills transfer between both.

What is the difference between Angular and AngularJS?

AngularJS is the original JavaScript framework, and Angular is a full rewrite in TypeScript with a different architecture. They are not compatible. Only learn AngularJS if you have to maintain an old app.

Can AI build a learning roadmap for Angular?

Yes. An AI tool can draft a roadmap from a goal such as "learn Angular in 24 weeks" and split it into phases and milestones. Check the draft against the official docs, so it teaches standalone components, signals and Signal Forms rather than older patterns, and adjust the durations to your real weekly hours.

Generate this roadmap with AI