1. Signal Forms are production-ready

Form management in Angular has always felt a bit heavy. The FormGroup, FormControl, valueChanges chain — and most importantly, the fact that any change to any field triggers the entire form tree.

With Angular 22, Signal Forms land as stable. Forms are now managed through a reactive structure built on top of Angular Signals:

typescript

const name = signal('');
const email = signal('');

const form = signalForm({
  name,
  email
});

The key difference here is granular reactivity. In a form with 50 fields, only the field you changed gets updated — the entire form tree doesn't recalculate. In large, complex forms, that difference shows up directly in performance.

2. Zone.js is gone — Zoneless is now the default

For anyone learning Angular for the first time, Zone.js always felt like a magic black box. "How does it know something changed?" — Zone.js was always the answer. But that magic came at a cost: monkey-patching every async operation, unexpected re-renders, and performance issues that were painful to debug.

With Angular 22, new projects no longer include Zone.js by default:

typescript

bootstrapApplication(AppComponent, {
  providers: [
    provideExperimentalZonelessChangeDetection()
  ]
});

Existing projects don't need to drop Zone.js immediately — backward compatibility is preserved. But new projects now start with a lighter, more predictable change detection mechanism.

3. Selectorless Components: forget about selectors

Until now, every component required a string selector:

typescript

@Component({
  selector: 'app-user-card',
  // ...
})

Then you'd write <app-user-card /> in your template. In large projects, tracking those names, avoiding typos, preventing naming conflicts — all of it added up to real cognitive overhead.

With Angular 22, you can import the component class directly and use it:

typescript

import { UserCard } from './user-card.component';

@Component({
  imports: [UserCard],
  template: `<UserCard [user]="currentUser" />`
})

Refactoring is easier, type safety is stronger, and "what was that component's selector again?" is no longer a question you need to ask.

4. debounced() signal — no more RxJS for this

You're building a search box and you don't want to fire an API request on every keystroke. The classic solution: toObservable → debounceTime → switchMap → toSignal. Five lines, two imports, one mental context switch.

Angular 22 solves this natively:

typescript

const searchQuery = signal('');
const debouncedQuery = debounced(searchQuery, 300);

effect(() => {
  console.log(debouncedQuery()); // fires after 300ms
});

RxJS is still powerful and has its place, but you no longer need to reach for it every time you have a simple async scenario.

5. httpResource and rxResource are now stable

With Angular 22, the httpResource and rxResource APIs also graduate to stable. These APIs are becoming the standard way to integrate HTTP requests and reactive data streams into the Signal world:

typescript

const userId = signal(1);

const user = httpResource(() => `/api/users/${userId()}`);

// user.value()     → the data
// user.isLoading() → loading state
// user.error()     → error state

When userId changes, the request is automatically re-fired. No more managing loading and error states separately.

6. Angular Aria: accessibility is now a first-class citizen

Angular 22 introduces Angular Aria in developer preview — a set of headless, accessibility-first UI components. You have complete freedom to apply your own styling, while the framework handles the ARIA logic.

In practice, this means: when building components like modals, dropdowns, or tooltips, you no longer have to implement ARIA attributes, focus trapping, and keyboard navigation from scratch.

Wrapping up

Angular 22 is less about what it added and more about what it finished. Signals stable, Zoneless by default, Signal Forms production-ready. Put those three things together and the picture of what Angular development looks like in 2026 becomes very clear.

If you're still using older patterns — ngOnChanges, the async pipe chain, Zone.js-dependent change detection — you don't have to drop everything at once. But Angular is being very deliberate about where it's headed.

If you're interested in what Angular 21 brought to the table, check out my previous post.