Expert Angular Interview Questions

RxJS powers Angular’s async architecture—HTTP, events, routing, and UI streams. It provides a reactive, push-based model that supports composition, cancellability, and declarative async workflows. This makes complex UI flows predictable, scalable, and maintainable.

Cold Observables start producing values only when subscribed. Each subscriber gets its own execution (e.g., HTTP calls).

Hot Observables emit values regardless of subscriptions. Subscribers join an active stream (e.g., events, websockets).

A Subject is both an observable and an observer. Angular uses it for shared service communication, event broadcasting, and maintaining UI state.

BehaviorSubject stores the latest value and immediately emits it to subscribers—ideal for UI and state.

ReplaySubject replays a buffer of previous values—ideal for logs, history, or cached responses.

takeUntil auto-unsubscribes when a notifier emits. It prevents memory leaks, especially in components with long-living subscriptions.

switchMap cancels previous inner observables and switches to a new one. Perfect for search boxes, route params, dependent dropdowns, and avoiding race conditions.

mergeMap runs all inner observables concurrently. It is ideal for batch operations or parallel API calls, unlike switchMap which cancels previous executions.

debounceTime delays emissions until input stabilizes. Common usage: wait for the user to stop typing before calling a search API to avoid unnecessary requests.

Angular recommends:

• Feature & core modules
• Smart/dumb components
• Reusable shared modules
• Service-based data layer
• Routing boundaries
• State management

This ensures scalability and clear separation of concerns.

A Facade provides a simplified API to components by hiding underlying complexity such as services, state, and API calls. It reduces coupling and improves maintainability.

CoreModule contains global singletons (services, interceptors, configs). Loading it more than once creates duplicate instances and breaks global state.

SharedModule contains reusable UI pieces—components, directives, pipes. It must NOT contain stateful services to avoid duplicated instances.

State management centralizes data, ensures predictable updates, reduces duplication, simplifies debugging, and enables caching and reactive UIs. Enterprises rely on it for consistency.

NgRx implements Redux principles with actions, reducers, selectors, and effects. Use it when applications have large shared state, complex flows, or need deterministic debugging.

Effects handle side effects like API calls, caching, and async workflows without polluting reducers. They keep the store pure and predictable.

Interceptors modify all HTTP requests/responses. They inject tokens, handle errors, retry requests, log APIs, and centralize HTTP concerns for maintainability.

Route Guards protect navigation, enforce security, manage unsaved changes, restrict lazy loading, and validate data before route activation.

Lazy loading loads feature modules only when accessed. This reduces initial bundle size, improves performance, and enforces clean module boundaries in large systems.

Angular apps rely on clear communication patterns—Inputs, Outputs, services, Subjects, and facades. These prevent coupling, simplify flows, and support scalable UI structure.

Use modular structure, proper state management, facades, smart/dumb components, DRY architecture, consistent naming, and unit-tested services/components for long-term maintainability.