Angular Masterclass

Part of our "Web and Mobile" courses

3 days (onsite)
4 days (online)

Angular
Outline Last updated:

Course Overview

Build modern web applications with Angular as it is written today: standalone components, signals, the new template control flow and zoneless change detection, alongside RxJS, forms, routing and testing with Vitest.

We go beyond the API and explain the machinery underneath, from how the Angular compiler turns your templates into code to how the signal graph decides what to re-render and how the injector tree resolves your dependencies. Throughout the course you build a real-world recipe application against a REST back end.

Who should attend

Web developers who know JavaScript and HTML/CSS and want to build applications with Angular, and Angular developers who learnt the framework in the NgModule and zone.js era and want to understand and adopt standalone components, signals and zoneless change detection. It suits teams in larger organisations that value Angular's opinionated, batteries-included approach.

What you'll learn

  • Build applications from standalone components with the new template control flow
  • Manage state with signals and understand how the reactive graph drives change detection
  • Share logic through dependency injection and understand the injector hierarchy
  • Combine RxJS and signals for asynchronous and server data
  • Build validated, typed forms and navigate with the Angular router
  • Test components and services with Vitest and the TestBed

Course Prerequisites

Students should be familiar with JavaScript and have a strong understanding of HTML/CSS. The course uses TypeScript throughout, so some experience with it helps. We recommend our Modern JavaScript/ECMAScript Masterclass and TypeScript Masterclass beforehand.

Outline

This course teaches Angular as it is written today. Angular has changed more in its recent releases than in the years before: NgModules gave way to standalone components, zone.js to signals, and the structural directives to a built-in control flow. We teach the modern framework from the ground up, and we explain what the older building blocks did, because most teams still maintain code that uses them.

As in all our courses, we go one layer beneath the abstraction. You learn how the Angular compiler turns templates into instructions, how the signal graph decides what needs to re-render, and how the injector tree resolves your dependencies. That understanding lets you predict Angular's behaviour instead of memorising its rules.

Throughout the course you build a single, non-trivial recipe application against a REST back end. Teams comparing frameworks may also be interested in our React Masterclass, which builds the same application.

Introduction

  • Understand the rationale behind a complete, opinionated front-end framework
  • Discuss Angular's history, from AngularJS through the Ivy compiler to signals
  • Contrast Angular with React, Vue and Svelte
  • Use the Angular CLI to create, serve and build projects
  • Understand the application builder and what esbuild and Vite do at build time
  • Recap the decorators and other TypeScript features Angular relies on
  • Discuss server-side rendering and hydration

Components and Templates

Components

  • Understand components as the building blocks of an Angular application
  • Define components with the @Component decorator
  • Appreciate standalone components and why NgModules are no longer needed
  • Bootstrap an application with bootstrapApplication and an application configuration
  • Understand how the Angular compiler turns templates into instructions
  • Scope styles to a component with view encapsulation
  • Migrate NgModule-based code with the CLI's migration schematics

Templates

  • Use interpolation and template expressions
  • Distinguish property, attribute, class and style bindings
  • Handle user input with event binding
  • Render conditionally with @if and @switch
  • Render lists with @for and understand the role of track
  • Declare local template variables with @let
  • Defer loading parts of a template with @defer
  • Transform values with pipes and distinguish pure from impure pipes
  • Reference elements with template reference variables

Signals and Change Detection

  • Understand change detection and how Angular keeps the DOM in sync with state
  • Appreciate why Angular relied on zone.js and what that cost
  • Introduce signals as reactive primitives
  • Derive state with computed and understand its laziness and memoisation
  • Run side effects with effect and recognise when not to
  • Use linkedSignal for state that resets when its source changes
  • Analyse the reactive graph: producers, consumers and glitch-free propagation
  • Build zoneless applications and understand what schedules a render
  • Discuss the OnPush strategy and where it still matters

Component Communication and Directives

  • Pass data into components with signal inputs
  • Emit events with outputs
  • Implement two-way binding with model inputs
  • Compose components with content projection
  • Query child elements with viewChild/contentChild
  • Hook into the component lifecycle
  • Develop attribute directives
  • Understand structural directives and the * micro-syntax beneath them
  • Reuse behaviour across components with host directives

Dependency Injection and Services

  • Understand dependency injection and the inversion of control behind it
  • Inject dependencies with the inject function
  • Define services and register them with providers
  • Explore the injector hierarchy of environment and element injectors
  • Distinguish provider types: class, value, factory and alias
  • Use an InjectionToken for dependencies that are not classes
  • Discuss scoping, from application-wide singletons to component-level instances

Reactive Programming with RxJS

  • Introduce reactive programming and the Observer pattern
  • Understand Observables and contrast them with Promises and signals
  • Compose streams with operators
  • Distinguish the higher-order mapping operators: switchMap, mergeMap, concatMap and exhaustMap
  • Manage subscriptions and avoid leaks with takeUntilDestroyed
  • Bridge both worlds with toSignal and toObservable
  • Discuss when RxJS earns its place and when signals are enough

HTTP and Server Communication

  • Configure the HttpClient with provideHttpClient
  • Perform CRUD operations against a REST API
  • Intercept requests with functional interceptors
  • Load data declaratively with httpResource and the resource API
  • Handle errors and loading states in the user interface
  • Upload files to the server

Forms

  • Compare template-driven and reactive forms
  • Build template-driven forms with ngModel
  • Build reactive forms with FormGroup and FormControl
  • Rely on typed forms for compile-time safety
  • Validate input with built-in and custom validators
  • Implement asynchronous validation against the server
  • Reflect control state (touched, dirty, valid) in the user interface
  • Introduce signal forms, Angular's signal-based forms API

Routing

  • Configure the router with provideRouter
  • Define routes with route parameters and wildcards
  • Navigate declaratively with routerLink and routerLinkActive
  • Navigate programmatically with the Router service
  • Bind route parameters to component inputs
  • Build hierarchical layouts with child routes
  • Lazy-load features with loadComponent and loadChildren
  • Protect routes with functional guards
  • Fetch data before navigation with resolvers
  • Discuss preloading strategies

Testing

  • Understand the different types of tests: unit, component, integration and end-to-end
  • Run unit tests with Vitest
  • Configure a test environment with the TestBed
  • Test components through the ComponentFixture and DebugElement
  • Test zoneless components and wait for the application to become stable
  • Replace dependencies with test doubles and spies
  • Mock HTTP requests with the HttpTestingController
  • Discuss end-to-end testing with Playwright and Cypress

Frequently asked questions

Do I need Angular experience to attend?

No, but you should be comfortable with JavaScript and HTML/CSS. The course uses TypeScript, so familiarity helps; our Modern JavaScript and TypeScript courses are ideal preparation.

Which Angular version do you teach?

The current release, with standalone components, signals, the @if/@for control flow and zoneless change detection. Where Angular changed meaningfully we say so, because most teams have some older code to live with.

Our application still uses NgModules and zone.js. Is this course for us?

Yes. We explain what the older building blocks did, why Angular replaced them, and how to migrate an existing application step by step with the CLI's migration schematics, so your team can modernise without a rewrite.

How does this compare with your React course?

Both courses build the same recipe application, so they make a fair comparison for teams choosing a framework. Angular is a complete, opinionated platform with routing, forms, HTTP and testing included; our React Masterclass covers a library that you assemble with tools of your choice.

Do I need to install anything on my laptop?

No. Every student gets their own pre-configured cloud machine with Node and the Angular tooling already in place, so all you need locally is an SSH client (already present on Linux, macOS and Windows). Work in the editors installed on the machine (vim, LazyVim, Emacs) or connect your own with VS Code Remote Development or IntelliJ's SSH remote development. Login details are emailed a week before the course.

How long is the Angular Masterclass course?

3 days on-site or 4 days online. Sessions can run on consecutive days or be spread out to fit your team's schedule.

What are the prerequisites?

Students should be familiar with JavaScript and have a strong understanding of HTML/CSS. The course uses TypeScript throughout, so some experience with it helps. We recommend our Modern JavaScript/ECMAScript Masterclass and TypeScript Masterclass beforehand.

How large are the groups?

Deliberately small so the trainer can adapt to every participant: at most 10 on-site and 7 online.

In which languages can the course be delivered?

English or French.

This Angular Masterclass course looks very interesting, I do however have a question

Related courses