Senior Angular interview questions for the Angular you actually run

Senior Angular interview questions test how a candidate reasons about change detection, reactive state, dependency injection, and rendering, and the good ones are matched to the Angular your team actually runs. Angular has changed a lot in its last few major versions. A senior engineer fluent in NgModules, Zone.js, and RxJS everywhere is a different hire from one who has shipped signals and zoneless, and most question banks score them the same.

This set is written for the interviewer, including the one who doesn't write Angular. It opens with a short warm-up, then spends most of its time on senior questions, each tagged both eras, modern, or legacy, with a model answer and a scoring anchor. It starts with the step most banks skip: deciding which era of answers should score highest for your codebase.

Key Takeaways

Our position: match your senior Angular interview questions to your codebase's version first, because a legacy-fluent and a signals-fluent engineer are both strong hires for different teams.
Tag every question as both eras, modern, or legacy, and decide in advance which tags carry the most weight for your role.
Senior rounds should cover signals and computed/effect, zoneless change detection, the DI hierarchy, SSR and hydration, RxJS interop, and performance.
Signals didn't make RxJS questions obsolete. A strong senior candidate knows when each one fits and how they work together.
Score every answer against a weak, adequate, and strong anchor written before the interview, so the screen stays fair even when the interviewer isn't an Angular engineer.

What senior Angular interview questions should test in 2026

As of October 2026, Angular v22 is the actively supported major version, released in June 2026, with v21 and v20 on long-term support, per the official Angular releases page. Versions 2 through 19 are no longer supported. Plenty of production apps still run on them, which is exactly why version-matching matters.

Across those versions, the big shifts are standalone components as the default, signals for reactive state, built-in control flow (@if, @for, @switch), deferred loading with @defer, and zoneless change detection. Angular's own zoneless guide says zoneless is the default from v21 onward.

What doesn't change is what you're testing: does this person understand when Angular updates the screen, where state lives, and how async data flows through the app. TypeScript itself is a separate skill, and our TypeScript interview questions cover generics and type narrowing so this set doesn't have to.

Match the questions to your Angular version first

Before you pick questions, answer two things about your codebase. Is it still built on NgModules and Zone.js, or is it standalone and moving to signals? And are you hiring someone to maintain what exists, or to migrate it?

Legacy-heavy codebase: weight legacy and both-eras questions highest. A candidate who goes quiet on zoneless details is fine here. One who can't explain Zone.js or NgModule providers isn't.
Modern codebase: weight modern and both-eras questions highest. Deep NgModule knowledge is a bonus, not the bar.
Migration role: you need both. The strongest signal is a candidate who can explain what breaks when you move from one era to the other.

Write this weighting down before the first interview. If you decide it afterward, you'll end up rewarding whichever era your interviewer happens to know.

Junior and mid-level warm-up questions

Spend five minutes here, even with senior candidates. A shaky warm-up tells you to adjust the rest of the round.

What's the difference between *ngIf and `@if`? (both eras) *ngIf is a structural directive, while @if is built-in template syntax that needs no import, per Angular's control flow guide. A strong answer adds that @for requires a track expression, which stops needless DOM re-creation.
What does OnPush change? (both eras) Angular only checks the component when an input changes by reference, an event fires inside it, an async pipe emits, or, in modern Angular, a signal read in its template changes. A strong answer explains why mutating an object in place breaks OnPush.
`switchMap`, `mergeMap`, `concatMap`, or `exhaustMap`? (both eras) These are the core RxJS interview questions. switchMap cancels the previous inner request, as in a typeahead. mergeMap runs them all at once, concatMap queues them in order, and exhaustMap ignores new ones while one is running, as in a submit button.
How do you avoid subscription memory leaks? (both eras) Prefer the async pipe, which unsubscribes for you. Otherwise use takeUntilDestroyed, or convert with toSignal. "Unsubscribe in ngOnDestroy" works but is the error-prone way.

Scoring note: the control-flow question is a quick era check. A candidate who only knows *ngIf probably learned on older Angular, which is fine for a legacy codebase and worth noting for a modern one.

Angular signals interview questions: signal, computed, effect and RxJS interop

These are the angular signals interview questions that separate people who've read about signals from people who've shipped them. The signals guide is the neutral reference.

What are `signal`, `computed`, and `effect`? (modern) A signal holds a value and notifies readers when it changes. computed derives a value and caches it, so reading it again returns the cached value without recalculating. effect runs side effects.
Which dependencies does a computed track? (modern) Only the signals actually read during the derivation. A strong answer spots the trap: a signal read inside a branch that didn't run this time isn't a dependency yet, and untracked stops a read from being tracked on purpose.
When should you not use `effect`? (modern) For propagating state. The guide reserves effects for reacting to signal changes on non-reactive APIs, and points to computed or linkedSignal for derived state. A weak answer copies one signal into another inside an effect.
When do you use signals, and when RxJS? (modern) Signals fit synchronous state the template reads. RxJS fits events over time: debouncing, cancellation, retries, and sockets. A strong answer uses both, bridging them with toSignal and toObservable, instead of declaring a winner.
What's the difference between share and `shareReplay`? (both eras) Both multicast one source to many subscribers. shareReplay also replays recent values to late subscribers, and without refCount: true it can keep the source subscription alive after everyone unsubscribes.

Scoring note: on effect, a weak answer says "it runs when a signal changes". A strong one explains why deriving state in an effect is a smell and what to use instead.

Senior Angular interview questions on change detection, zoneless and performance

These advanced Angular interview questions test whether a candidate has migrated or tuned a real app, not just read the release notes.

What changes when an app goes zoneless? (modern) Without Zone.js, Angular no longer runs change detection after every async event. Updates come from signals read in templates, the async pipe, template or host listeners, setInput, or an explicit markForCheck. A strong answer names what breaks: state changed inside a setTimeout or a third-party callback that never tells Angular.
How would you migrate a large NgModule app to standalone? (legacy to modern) Incrementally, not in one release. Angular ships a standalone migration schematic, and strong candidates run it module by module, keep tests green, and leave routing and shared modules for last.
When does @defer help? (modern) It lazy-loads part of a template, with triggers like viewport, idle, or interaction, and a placeholder until it loads. A strong answer uses it for heavy, below-the-fold components and knows it isn't a substitute for route-level lazy loading.
A list page is slow. Where do you look first? (both eras) A strong answer checks for a missing or unstable track expression in @for, components that aren't OnPush, and expensive work in template expressions. A weak answer reaches for a library before profiling.

Scoring note: the zoneless question separates seniors who've read the release notes from those who've migrated an app. Ask what they'd check first in a codebase before turning it on.

Senior questions on the DI hierarchy, SSR and hydration

These are the Angular interview questions for experienced engineers that most banks skip. Angular's guides on hierarchical dependency injection and hydration are the references.

What's the difference between providedIn: 'root' and a component's `providers`? (both eras) Root gives one instance for the whole app. A component-level provider gives every instance of that component its own private instance. A strong answer explains that Angular searches the element injector tree first, then the environment injectors.
What do `@Self`, `@SkipSelf`, @Host and @Optional do? (both eras) They change where Angular looks. @Self only checks the current component's injector, @SkipSelf starts at the parent, @Host makes the host component the last stop, and @Optional allows a missing service.
What is hydration, and what breaks it? (modern) Hydration restores a server-rendered app on the client by reusing the existing DOM instead of recreating it. Components that manipulate the DOM directly with native APIs, or templates with invalid HTML like a <div> inside a <p>, cause errors or mismatches, and ngSkipHydration is the escape hatch at the cost of hydration's benefits.
What is incremental hydration? (modern) It leaves parts of the page dehydrated and hydrates @defer blocks on triggers like hydrate on viewport or hydrate on interaction. Per the current incremental hydration guide, it depends on event replay and turns it on automatically, so clicks before hydration aren't lost.

Scoring note: on DI, a weak answer says "services are singletons". A strong one knows when a component-level provider is the right call, for example per-instance state in a reusable widget.

How to score a senior Angular answer: weak, adequate, strong

Use the same three anchors for every question, adjusted by the era weighting you chose. A weak answer recites the API. An adequate one explains it correctly with a typical use. A strong one names the trade-off and the failure mode unprompted.

Change detection. Weak: "Angular updates the view automatically." Adequate: explains OnPush triggers. Strong: explains why in-place mutation fails, and how signals or zoneless change the picture.
State and signals. Weak: inputs and outputs only. Adequate: knows services and signals for shared state. Strong: chooses between local signals, a shared service, and a store, and says why for a concrete feature.
RxJS. Weak: "I use subscribe." Adequate: names the operators correctly. Strong: picks the right one per scenario, knows where subscriptions leak, and bridges to signals cleanly.
Rendering and DI. Weak: knows the APIs exist. Adequate: can configure hydration or a component provider. Strong: knows what breaks hydration and when a provider belongs on a component.

These angular interview questions and answers work best as a structured round, the same way our React interview questions and JavaScript interview questions are set up. If you're hiring across frameworks, the frontend question bank and the frontend developer role page cover the shared ground.

Frequently asked questions

What are some common senior Angular interview questions?

Senior Angular interview questions usually cover signals with computed and effect, zoneless change detection, when to choose signals over RxJS, the DI hierarchy, SSR and hydration, migrating NgModule apps to standalone, and performance. The best ones ask for trade-offs and failure modes, not API definitions.

What are common Angular signals interview questions?

Expect "what's the difference between signal, computed and effect?", "which dependencies does a computed track?", "when shouldn't you use effect?", and "how do you bridge signals and RxJS?". A strong candidate answers the last one with toSignal and toObservable and a real use case.

Should I still ask about RxJS now that Angular has signals?

Yes. Signals handle synchronous state well, but RxJS still handles events over time, like debouncing, cancellation, and retries. Most real codebases use both, so a strong candidate should know when each fits and how to bridge them.

How can I prepare for a senior Angular interview?

If you're the interviewer, decide which Angular era matters for your codebase, pick questions from each senior area, and write weak, adequate, and strong anchors before the first candidate. If you're the candidate, the same list works in reverse: be ready to explain trade-offs and a failure you've actually fixed.

Is Angular knowledge different from TypeScript knowledge in an interview?

Yes. TypeScript questions test the language: types, generics, and narrowing. Angular questions test the framework: change detection, components, dependency injection, and RxJS patterns. A candidate can be strong in one and average in the other, so score them separately.

Running a senior Angular screen without an Angular engineer

A recruiter or a hiring manager from another stack can run a fair first round with this set, as long as the era weighting and the anchors are written down first. What's hard is the follow-up: knowing what to ask when an answer about OnPush or hydration sounds right but thin.

Here's how we'd split it on Expert Hire, honestly. The AI interview covers the framework: it scores every answer against the Angular skills and weightage you set, and follow-up questions adapt to what the candidate actually says. The coding test covers TypeScript logic, not Angular components or templates, so don't treat it as a framework test.

Your Angular engineer then reviews a report card for each finalist instead of sitting through every first round. If you want that follow-up asked the same way for every candidate, see how the Expert Hire AI interview platform scores a framework round.

By TK, Growth at Expert Hire. Last updated October 6, 2026. Reviewed by Anand Suresh, CPO at Expert Hire.