These Angular interview questions are written for engineering managers and tech leads hiring frontend developers, and for candidates preparing for a frontend round. Angular has changed a lot in the last few releases: standalone components are the default, signals handle most reactive state, and templates use built-in control flow. The questions below test that modern style, while still checking that a candidate can work in an older codebase. Choose 6 to 8 for one round, match them to the level you're hiring for, and follow every answer with "how would you know it worked?"
What a strong Angular interview checks
- Modern Angular fluency: standalone components, signals, the inject() function and built-in control flow, not only NgModules and decorators.
- Change detection sense: knowing what triggers a re-render and how OnPush and signals keep a large app fast.
- Reactive data handling: enough RxJS to manage HTTP, cancellation and errors, plus a clear view of when a signal is the simpler tool.
- App structure: routing, lazy loading, dependency injection scopes and shared state that a team can maintain.
- Testing and quality: component tests that check behavior, and a habit of measuring performance before changing it.
- Teamwork: handling migrations, code review and disagreements about patterns without drama.
Angular interview questions: core concepts
1. What is a standalone component, and why did Angular move to them?
What good looks like: a standalone component declares its own dependencies in an imports array instead of belonging to an NgModule. Since Angular 19, components are standalone by default, so the standalone: true flag is no longer needed. The benefits are less boilerplate, clearer dependencies per component, and simpler lazy loading, since a route can point straight at a component with loadComponent.
Red flag: believing standalone components can't use NgModule-based libraries. They can, by importing the module in the component's imports.
2. Explain signal, computed and effect.
What good looks like: signal() holds a value you read by calling it and change with set or update. computed() derives a read-only value from other signals, is lazy, and is cached until a dependency changes. effect() runs side effects, such as logging or syncing to local storage, when the signals it reads change. A strong candidate says effects are for side effects, not for copying one signal into another, which computed or linkedSignal does better.
Red flag: using an effect to set another signal as the default way to derive state.
3. How are signal inputs different from the @Input decorator?
What good looks like: input() returns a read-only signal, so the component reads this.name() and can build computed values on it without ngOnChanges. input.required() makes a missing binding a compile-time error. output() replaces @Output with EventEmitter, and model() creates a two-way binding a parent can use with the banana-in-a-box syntax.
4. How does change detection work, and what does OnPush change?
What good looks like: with the default strategy and Zone.js, Angular checks the component tree after async events like clicks, timers and HTTP responses. With ChangeDetectionStrategy.OnPush, a component is checked only when an input reference changes, an event fires inside it, an async pipe emits, or a signal it reads in the template changes. Strong candidates mention zoneless change detection, which drops Zone.js and relies on signals and explicit notifications. It is stable in recent versions, and new projects created with Angular 21 use it by default.
Red flag: mutating an array in place under OnPush and being surprised the view doesn't update.
5. What does built-in control flow replace, and why is track required in @for?
What good looks like: @if, @for and @switch replace the *ngIf, *ngFor and ngSwitch directives, with less boilerplate and better type narrowing. track tells Angular how to identify each item, such as track item.id, so it reuses DOM nodes instead of rebuilding the list. @empty handles the no-items case.
6. How does dependency injection work, and when would you use inject()?
What good looks like: Angular resolves dependencies from a tree of injectors. providedIn: 'root' gives one app-wide instance that can be tree-shaken if unused. Providers on a route or component create a scoped instance for that part of the tree. inject() works in constructors, field initializers, and functional guards, resolvers and interceptors, which is why it has largely replaced constructor parameters in new code.
Red flag: calling inject() inside a click handler or a setTimeout, outside an injection context.
7. What is @defer, and when would you use it?
What good looks like: a @defer block lazy-loads the components inside it, with triggers such as on viewport, on idle or on interaction. @placeholder and @loading blocks cover the wait. It suits heavy widgets below the fold, like charts or comment threads. A strong candidate notes that the deferred components must be standalone and not referenced elsewhere in the same file, or they won't be split out.
8. Compare switchMap, mergeMap, concatMap and exhaustMap.
What good looks like: all four map each value to an inner observable. switchMap cancels the previous inner request, which fits typeahead search. mergeMap runs them in parallel. concatMap queues them in order, which fits saves that must not overlap. exhaustMap ignores new values while one is running, which fits a submit button clicked twice.
Red flag: using switchMap for a save request, which can cancel a write halfway.
9. How do you avoid memory leaks from subscriptions?
What good looks like: prefer the async pipe or toSignal(), which clean up for you. For manual subscriptions, use takeUntilDestroyed() from @angular/core/rxjs-interop. HTTP calls complete on their own, but long-lived streams like router events, websockets and interval do not.
Routing, forms and data
10. How do you protect a route and lazy-load a feature?
What good looks like: a functional guard with CanActivateFn that uses inject() to check auth and returns true, false or a UrlTree to redirect. Lazy loading uses loadComponent for a single page or loadChildren for a set of routes. A strong candidate says guards only shape the UI, and the API must still enforce permissions.
11. Reactive forms or template-driven forms?
What good looks like: reactive forms define the model in code, are strongly typed since Angular 14, and are easier to test and to validate dynamically, so they suit complex forms. Template-driven forms are quicker for small, simple ones. Strong candidates can write a custom validator and know when to use FormArray for repeating fields.
12. Where should HTTP logic live, and how do interceptors fit in?
What good looks like: components call services, and services own HttpClient calls. provideHttpClient(withInterceptors([...])) registers functional interceptors for auth headers, logging or retry. A strong candidate mentions toSignal() or the resource APIs for exposing data as signals, and handles loading and error states on purpose.
13. What does hydration do in a server-rendered Angular app?
What good looks like: the server sends rendered HTML, and hydration lets the browser reuse those DOM nodes instead of destroying and rebuilding them, which avoids flicker and helps load metrics. It is enabled with provideClientHydration(). Strong candidates know that code touching window or document directly can break on the server, and use afterNextRender or platform checks for browser-only work.
Practical scenarios
14. A large table component feels slow when the user types in a filter box. How do you investigate?
What good looks like: profile first with Angular DevTools and the browser performance panel. Common causes are a missing track in @for, method calls in the template that run on every check, and the whole tree being checked on each keystroke. Fixes include OnPush or signals, a computed for the filtered rows, debouncing the input, and virtual scrolling for very long lists.
Red flag: jumping to a rewrite before measuring.
15. Several unrelated components need the current user and cart. How do you share that state?
What good looks like: a root-provided service that holds private writable signals and exposes read-only ones with asReadonly() or computed, with methods for every change. They'd reach for NgRx or a signal store only when the app has many interacting features, complex side effects, or a team that wants strict conventions.
16. How would you migrate an NgModule app to standalone components and signals?
What good looks like: do it in steps, not in one big release. Run the official schematics (ng generate @angular/core:standalone, and the migrations for signal inputs and control flow), keep tests green between steps, and migrate feature by feature. A strong candidate keeps old and new styles working side by side during the move.
17. How do you test a component that loads data from an API?
What good looks like: use TestBed with provideHttpClientTesting() and HttpTestingController, or provide a fake service. Test what the user sees: the loading state, the rendered rows, and the error message. A strong candidate avoids testing private methods and keeps end-to-end tests for a few critical flows.
Behavioral (STAR)
18. Tell me about a performance problem you fixed in a frontend app.
What good looks like: a clear Situation (which screen, which users), the Task, specific Actions with the tool they used to measure, and a Result in numbers, such as load time or bundle size before and after. They explain why their fix worked.
Red flag: "I made it faster" with no measurement.
19. Describe a time you pushed back on a design or product request.
What good looks like: they understood the goal behind the request, explained the technical cost in plain terms, offered an option that met the goal, and kept the relationship intact. Bonus if they admit when the other side was right.
20. Tell me about introducing a new pattern or library to a team.
What good looks like: they proved it on a small piece first, wrote down the conventions, helped teammates adopt it through pairing or review, and checked later whether it actually reduced bugs or code. Strong candidates also describe a pattern they decided not to adopt.
A simple scoring rubric
Running this interview with AI
When an Angular role draws a big applicant pool, an adaptive AI interviewer can handle the first conversation. NTRVSTA lets you customize the interview per role, so your team adds its own Angular questions like the ones above. The interviewer adjusts difficulty in real time: a candidate who explains signals and OnPush clearly gets pushed on hydration and migrations, while one who struggles gets simpler follow-ups and, if you turn it on, a hint. Behavioral questions follow the STAR method.
After each interview, your tech lead gets a score breakdown (technical skills, English proficiency, communication) and video snippets of the key moments. Before you rely on any automated score, read how AI interviews are scored, and compare tools in our guide to AI interview software. Hiring across the stack? See our frontend developer and JavaScript interview questions, or start the posting from our software engineer job description template.
Questions
Should I still ask about NgModules and Zone.js in 2026?
Briefly, yes, if your codebase still uses them. Many production apps are mid-migration, so a candidate who can read an NgModule app and also explain standalone components and signals is more useful than one who only knows either the old or the new style.
How long should a first-round Angular interview be?
Around 45 minutes works for most teams. Use 5 or 6 fundamentals matched to the level, one or two practical scenarios, and one behavioral question, with time left for follow-ups. Save live coding or a take-home for the next round.
Do Angular candidates need deep RxJS knowledge now that signals exist?
They need working RxJS, not encyclopedic RxJS. HTTP calls, router events and many libraries still return observables, so they should know switchMap, error handling and how to unsubscribe. Signals cover most local state, and strong candidates know how to bridge the two.
Curious how an AI interviewer handles an Angular round? Book a 20-minute demo with our team, or take a sample interview yourself.
