Definitive Angular (Signals Edition) - Angular 22

If you take only one Angular course, this should be the one. This is the flagship course of Angular University: a single course that covers the framework from your very first component to its most advanced core features, in depth and in the right order.

Angular has changed more in the last few years than in the whole decade before. Signals, zoneless change detection, built-in control flow, signal inputs and queries, resource() and httpResource() — the way Angular applications are written today is fundamentally different from what most tutorials still teach.

This course is the definitive guide to modern Angular, from template syntax to dependency injection, deferred loading, security and render hooks. It is deliberately concise without sacrificing depth: every lesson explains not just how a feature works, but why it exists and when you should use it.

Every example is written with signals, standalone components and zoneless change detection. The new course is taught entirely the modern way, with no legacy decorators or NgModule material to wade through.

COURSE OVERVIEW

We start by setting up the tooling, including the Angular CLI MCP server and the official Angular Agent Skills, and introduce signals from the very first component. From that point on, all application state lives in signals — the golden rule that the rest of the course builds on.

We then explore the core of the framework in depth: template syntax, components with signal inputs, outputs and model(), built-in control flow, component styling and view encapsulation. A complete signals deep dive covers computed(), linkedSignal(), effect(), untracked(), and how dependencies between signals are created and destroyed.

Next comes HTTP the signals way, with resource(), httpResource() and debounced(), followed by HttpClient for writes, file uploads with progress, functional interceptors and signal-based state services.

The second half covers advanced framework features: security, attribute directives and directive composition, pipes and locale data, content projection and queries, ng-template and structural directives, dependency injection, @defer and error boundaries, lifecycle and render hooks, internationalization and RxJS interoperability.

Each section comes with its own standalone demo in the course repository, so you can start with whichever section you need.

TOPICS COVERED

• Angular CLI, Angular Language Service, Angular DevTools, the CLI MCP server and Angular Agent Skills

• Signals from the beginning: signal(), set() and update()

• Template syntax: property and attribute bindings, class and style bindings, events, template references and @let

• Strict template type checking

• Signal inputs, input transforms, output() and two-way binding with model()

• Signal queries: viewChild(), viewChildren(), contentChild() and contentChildren()

• Built-in control flow: @if, @for, @switch, tracking and diffing

• Component styling and view encapsulation

• computed(), linkedSignal(), effect(), untracked(), custom equality and effect cleanup

• When not to use effects and common signals mistakes

• Async state with resource(), httpResource() and debounced()

• HttpClient CRUD calls, error handling, file uploads and functional interceptors

• Signal-based state services and optimistic updates

• Angular security: sanitization, Content Security Policy, Trusted Types and XSRF protection

• Attribute directives and directive composition with hostDirectives

• Built-in and custom pipes, locale data, and pipes versus computed()

• Content projection, multi-slot projection and content queries

• ng-template, ngTemplateOutlet, TemplateRef, ViewContainerRef and structural directives

• Dependency injection: providers, tokens, hierarchical injectors, injection contexts and debugging

• Deferred loading with @defer and error boundaries with @boundary

• Lifecycle and render hooks: afterNextRender(), afterEveryRender() and afterRenderEffect()

• Internationalization with Angular i18n and $localize

• RxJS interoperability: toSignal(), toObservable(), rxResource() and takeUntilDestroyed()

WHAT WILL YOU LEARN?

By the end, you will understand not only how to use Angular's core features, but how they work under the hood and which tool fits each job. You will be able to design signal-based components and services, handle async data and HTTP, build reusable component APIs with content projection and templates, and confidently use dependency injection, deferred loading and render hooks.

PREREQUISITES AND SCOPE

You need HTML, CSS and JavaScript, and ideally some basic TypeScript. Previous Angular experience is helpful but not required. The course starts from the beginning, with signals from the first component. No prior RxJS knowledge is needed; it is covered in a dedicated interoperability section near the end.

WHO IS THIS COURSE FOR?

Developers who want to master Angular from fundamentals to advanced core features; developers who learned Angular before signals and want the modern, zoneless approach; and developers coming from another framework who want a thorough understanding of modern Angular.