Angular interview questions

Change detection

• What triggers change detection? Events, HTTP responses and timers, via zone.js patching async APIs.
• Default versus `OnPush` - and what `OnPush` actually requires: new references rather than mutated objects.
• Why does a mutated array not update the view under `OnPush`?
• `markForCheck` versus `detectChanges`, and when you would reach for either.
• Why is a function call in a template a performance problem? It runs on every cycle.
• What does `runOutsideAngular` buy you?

RxJS, where the bugs live

• Unsubscribing. `takeUntil` with a destroy subject, `takeUntilDestroyed`, or the async pipe - and why the async pipe is preferred where possible.
• `switchMap` versus `mergeMap` versus `concatMap` versus `exhaustMap`. The canonical answer: `switchMap` for a typeahead because it cancels in-flight requests, `exhaustMap` for a submit button to ignore double-clicks.
• Hot versus cold observables, and why an HTTP call fires once per subscription.
• `Subject` versus `BehaviorSubject`.
• What is the nested-subscribe anti-pattern and what replaces it?

DI, modules and forms

• How does Angular's hierarchical injector resolve a dependency, and what does `providedIn: 'root'` do?
• Standalone components - what they replaced, and how migration from NgModules works.
• Reactive versus template-driven forms, and why reactive forms are preferred for anything non-trivial.
• Route guards and resolvers, and lazy loading a feature.
• What is content projection for?

The practical round

Expect to build or fix a small component - a filtered list with a debounced search, or a form with validation - and to explain performance choices as you go. `trackBy` in a list is the detail interviewers look for, because without it Angular tears down and rebuilds every row when the collection changes. Be ready to say how you would profile a slow component too: the Angular DevTools profiler shows which components are being checked and how often, which turns a guess about change detection into a measurement. The framework-agnostic half is in frontend interview questions and TypeScript interview questions.

How deep it goes by level

• Junior: the fundamentals above, explained clearly. Nobody expects production scars yet, and saying what you have not done reads better than bluffing.
• Mid-level: the same ground plus an application you have shipped and a performance problem you fixed. Expect follow-ups asking why you made a choice rather than whether you know the syntax.
• Senior: an NgModule-to-standalone migration, and state management choices across a large app. The recall questions get shorter and the judgement questions get longer.

Whatever the level, say your answers out loud rather than reading them. Most of what candidates lose in a Angular interview is lost between knowing something and explaining it under observation - the method is in how to use AI for interview prep.

Where CoPilot Interview fits

Disclosure: we build an interview assistant, so treat this as a disclosed pitch. CoPilot Interview is a native Windows and macOS app that puts suggested answers on your own screen in about two seconds, across coding, system design and behavioral rounds, with a permanent free tier that needs no credit card.

Frequently asked questions

What are the most common Angular interview questions?

What triggers change detection and how `OnPush` changes it, unsubscribing from observables, the difference between `switchMap` and `mergeMap`, hierarchical dependency injection, and reactive versus template-driven forms.

How do you avoid memory leaks in Angular?

Give every manual subscription a teardown - `takeUntil` with a destroy subject, `takeUntilDestroyed`, or preferably the async pipe, which unsubscribes automatically when the component is destroyed. Unterminated subscriptions are the most common defect in real Angular code.

What is the difference between switchMap and mergeMap?

`switchMap` cancels the previous inner observable when a new value arrives, which suits a typeahead where stale responses are useless. `mergeMap` runs them concurrently and keeps all results, which suits independent operations where every result matters.

What does OnPush change detection require?

That inputs change by reference rather than being mutated in place. Under `OnPush`, Angular only re-checks a component when an input reference changes, an event fires within it, or it is explicitly marked - so mutating an array without replacing it leaves the view stale.