Angular is a TypeScript-based front-end framework developed and maintained by Google.
It is used to build single-page applications (SPA) and large-scale web applications.

It provides features like components, modules, routing, two-way data binding, dependency injection, and built-in tooling through Angular CLI.

Angular is a TypeScript-based front-end framework for building scalable and maintainable web applications. It provides components, routing, forms, HTTP, and strong structure for enterprise-level apps.

It is used because it offers TypeScript support, component architecture, built-in tooling, and a complete ecosystem for developing large applications.

Components are the smallest UI building blocks in Angular. They include a template (HTML), a class (TypeScript), and metadata.

Components help create modular, reusable, and structured user interfaces.

Angular modules (NgModules) group related components, directives, pipes, and services.

They organize app features, enable lazy loading, and manage visibility of components.

Data binding connects the component class and the template.

Types include interpolation, property binding, event binding, and two-way binding.

Directives are instructions applied to DOM elements.

Types include structural directives (*ngIf, *ngFor) and attribute directives (ngClass, ngStyle).

Dependency Injection provides required services to components automatically.

It improves testability, reduces coupling, and organizes application logic.

Lifecycle hooks allow running code at specific moments such as initialization, change detection, and destruction.

Important hooks include ngOnInit, ngOnDestroy, and ngOnChanges.

Change detection updates the view automatically when component data changes.

Angular uses Zone.js to track async events and re-render components when needed.

Angular CLI is a command-line tool used to create projects, generate components, run builds, and perform testing.

It standardizes development and improves productivity.

AOT compiles Angular templates during the build process instead of in the browser.

It produces faster load times, smaller bundles, and more secure applications compared to JIT compilation.

Pipes are data transformation tools used inside Angular templates. They take input data, apply formatting, and return a transformed output.

Common uses include formatting dates, numbers, currency, converting text case, and filtering lists. Angular supports pure and impure pipes depending on performance and data needs.

Services contain shared or reusable logic that should not be placed inside components.

They are commonly used for HTTP calls, state management, business logic, utilities, and data sharing. Angular services work with Dependency Injection for clean structure and testability.

Observables represent asynchronous or event-based data streams. Angular uses RxJS Observables for HTTP requests, user inputs, route events, and real-time updates.

Observables support cancelling, multiple values, and powerful operators, making them ideal for reactive UI development.

Angular Routing enables navigation between components based on the URL. It maps paths to components and allows navigation without page reload.

It supports route parameters, query parameters, guards, and lazy loading, enabling SPA behavior.

Route guards control whether navigation to a route should be allowed or blocked.

Common guards include CanActivate, CanDeactivate, Resolve, CanLoad, and CanActivateChild. They are used for authentication, authorization, saving unsaved data, and preloading route data.

Lazy loading loads modules only when they are needed, not on initial app startup.

It improves performance by reducing initial bundle size and enables scalable enterprise-level application development.

Template-driven forms rely mainly on HTML templates and are suitable for simple forms.

Reactive forms place form logic in the component class, offering more control, better validation, and integration with RxJS—ideal for complex and dynamic forms.

Zones track asynchronous operations and notify Angular when to run change detection.

They eliminate the need to manually update the UI after async tasks, simplifying app development.

OnPush change detection checks a component only when its input reference changes, an event occurs, or an observable emits.

It improves performance in large, data-heavy applications by reducing unnecessary change detection cycles.

ViewChild allows a component to access child components, DOM elements, or directives.

It is useful for calling child methods, reading template references, and interacting with the DOM after view initialization.

A component is the fundamental UI building block in Angular, connecting HTML (view), TypeScript (logic), and CSS (styles).

Responsibilities include rendering UI, handling events, managing local state, communicating with other components, data binding, and calling services.

Lifecycle hooks are special methods Angular calls during component creation, update, and destruction.

They help with initialization, loading data, reacting to input changes, accessing the DOM, and cleaning up resources.

NgModule groups components, directives, pipes, and services into a logical unit.

It manages imports, exports, providers, compilation context, and enables lazy loading.

Dependency Injection provides required objects (services) to classes instead of creating them internally.

Angular uses injectors, providers, and a hierarchical DI system. Constructor injection is the most common mechanism.

Component-level services create a new instance for each component instance.

Module-level services provide a shared instance across the entire module/application.

Structural directives change the DOM structure (e.g., *ngIf, *ngFor).

Attribute directives change the appearance or behavior of an element (e.g., ngClass, ngStyle).

Change detection updates the UI when data changes. Angular checks component trees after async events using Zone.js.

Two strategies exist: Default (checks all components) and OnPush (checks only when needed).

Angular supports interpolation, property binding, event binding, and two-way binding.

Each type controls how data flows between component and template.

Content projection allows inserting external content into a component's template.

It enables reusable UI wrappers, flexible layouts, and component composition.

AOT compiles Angular templates during build time for faster startup, smaller bundles, earlier error detection, and better security.

AOT is the default for production builds in modern Angular.

Angular change detection is triggered by async events handled by Zone.js, such as timers, promises, user events, and HTTP calls.

Understanding these triggers helps avoid unnecessary re-renders, optimize performance, and decide when to use OnPush strategy.

Default Strategy: Angular checks all components, even if data has not changed.

OnPush Strategy: Angular checks only when input references change, observables emit, or events occur.

OnPush improves performance, especially in complex apps.

Pure Pipes: Run only when input changes, fast and cached.

Impure Pipes: Run on every change detection cycle, can slow performance.

Impure pipes are needed only when data mutates without reference change.

RxJS provides observables and operators for handling async programming in Angular.

It powers HTTP requests, forms, router events, websockets, and state management.

Cold Observables: Start producing values on subscription (e.g., HTTP calls).

Hot Observables: Produce values regardless of subscribers (e.g., events, websockets).

Cold = fresh execution per subscriber; Hot = shared execution.

Subject: No initial value; subscribers only receive future values.

BehaviorSubject: Has initial value and gives latest value to new subscribers.

ReplaySubject: Stores a buffer of values and replays them to new subscribers.

Module Federation allows multiple Angular applications to share modules or components at runtime.

It enables microfrontends, improves modularity, and supports independent deployments.

Zones track async tasks and trigger change detection. Disabling them is useful for high-performance apps that manually control UI updates.

Helps in real-time or graphics-heavy applications.

Tree-shaking removes unused code from the bundle.

It results in smaller builds, faster load times, and better performance.

ViewEncapsulation controls how component styles are scoped.

Modes: Emulated (default), ShadowDom, and None.

It prevents CSS conflicts and supports reusable component styling.

NgRx solves complex application state management problems, especially in large apps where multiple components need shared state.

You should use NgRx when many components read and update global state, require time-travel debugging, offline caching, immutability, or predictable unidirectional data flow.

Small apps do not need NgRx; services or BehaviorSubjects are sufficient.

NgRx uses a predictable data flow:

• Actions: Describe events
• Reducers: Update state immutably
• Store: Holds global state
• Selectors: Retrieve computed data
• Effects: Handle async operations

The flow is: Actions ? Reducers ? Store ? Selectors ? Components ? Effects ? new Actions.

Reactive Forms use TypeScript classes for form control, offer better scalability, testing, dynamic fields, and are suitable for enterprise use.

Template-Driven Forms rely on HTML templates, good for small simple forms but less testable and harder to scale.

Guards run before route activation to allow or block navigation.

Types include: CanActivate, CanDeactivate, CanLoad, CanActivateChild, and Resolve.

They handle security, data preloading, navigation rules, and preventing access to invalid or unauthorized pages.

RouterOutlet is a dynamic placeholder where Angular loads components based on the active route.

Routing parses the URL, matches it with route configuration, runs guards/resolvers, and finally loads the mapped component into the outlet.

Lazy loading loads feature modules only when required.

This reduces initial bundle size, speeds up first load, improves performance, and helps modularize large enterprise applications.

Preloading loads lazy-loaded modules in the background after the main app loads.

Benefits include faster navigation and balanced app performance.

Angular provides built-in strategies like PreloadAllModules and supports custom strategies.

ChangeDetectorRef gives manual control over Angular’s change detection.

Used when working with OnPush, avoiding heavy re-renders, handling updates outside Angular zones, or running performance-sensitive operations.

Schematics automate code generation, enforcing consistent structure across the project.

They generate modules, components, upgrade Angular versions, and apply organization-wide architecture rules.

Shared Module contains reusable components, pipes, and directives and can be imported many times.

Core Module holds global singletons like services, interceptors, and layout components, imported only once.

This separation improves architecture, scalability, and avoids duplicate service instances.

Interceptors act as middleware for all HTTP requests and responses in Angular.

Internally, Angular creates a chain of interceptor handlers. Each interceptor receives the outgoing request, can clone or modify it, and then passes it to the next handler. Responses flow back in reverse order, allowing global transformations.

Common uses: authentication tokens, error handling, logging, retry logic, preventing duplicate calls.

Token handling must prioritize security. Best practices include:

• Store tokens in memory or sessionStorage (avoid localStorage for sensitive apps).
• Use HttpOnly cookies when backend supports them.
• Add tokens only through interceptors.
• Avoid placing tokens in URLs.
• Implement token refresh + logout on refresh failure.
• Never expose secrets in frontend code.

Angular i18n extracts translatable strings from templates and applies translations at build time.

The Angular compiler replaces template text with localized versions, generating separate build bundles for each locale. ICU expressions manage pluralization and formatting, improving runtime performance and memory usage.

Content Projection inserts external content into a child component's template, enabling reusable layout patterns.

View Projection uses internal views created by the component via ViewChild, ViewContainerRef, or embedded views.

Content projection passes external markup; view projection manages internal view trees.

AOT compiles Angular templates to optimized JavaScript during build, not in the browser.

Benefits: faster startup, smaller bundles, better security, and earlier error detection. AOT is the default mode for production builds.

Angular destroys component instances automatically when navigating, but developers must prevent memory leaks by:

• Unsubscribing Observables using async pipe or takeUntil.
• Clearing intervals/timeouts.
• Removing manual event listeners.
• Avoiding storing component references in services.

Smart Components handle data fetching, state management, and service interactions.

Dumb Components focus purely on presentation, using @Input and @Output. They are reusable, testable, and predictable.

This separation improves scalability and modularity in enterprise Angular applications.

The rendering pipeline steps:

1. Change detection runs to identify data changes.
2. Angular updates DOM nodes via compiled instructions.
3. Directive inputs + lifecycle hooks run.
4. Browser recalculates styles and layout.
5. Paint + render occurs.

Angular optimizes minimal DOM updates for performance.

Custom decorators allow attaching metadata or logic to classes, properties, or methods. They are useful for logging, validation, metadata injection, and reducing boilerplate.

However, overuse can create hidden complexity and should be applied selectively.

Major risks include:

• XSS – rely on Angular sanitization, avoid bypassSecurityTrust.
• CSRF – use server-issued anti-forgery tokens or HttpOnly cookies.
• Sensitive data exposure – never store secrets in the frontend.
• Clickjacking – enforce frame-ancestors policies on server.
• API abuse – ensure backend role validation and rate limiting.

NgZone allows Angular to track asynchronous operations such as HTTP requests, timeouts, promises, and events. When these operations complete, Angular triggers change detection to update the UI automatically.

Developers can execute heavy tasks outside Angular’s zone using runOutsideAngular() to avoid unnecessary change detection and improve performance.

Default Strategy: Angular runs change detection for the entire component tree whenever any async event occurs. Simple but expensive for large apps.

OnPush Strategy: Angular checks the component only when its input reference changes, an observable emits, or an event originates from the component. This dramatically improves performance.

Smart Components handle data loading, business logic, and state management.

Dumb Components only display UI, receive input, and emit events.

This pattern increases reusability, makes components more testable, and keeps UI clean and maintainable.

Common leak causes include:

• Unsubscribed Observables
• DOM references kept alive
• Event listeners not removed
• Intervals/timeouts not cleared

Angular avoids leaks via async pipe, takeUntil, DestroyRef, and proper cleanup patterns.

Template-Driven Forms: Defined mostly in HTML, suitable for simple forms, limited dynamic capability.

Reactive Forms: Structured entirely in TypeScript, scalable, predictable, supports dynamic fields, custom validators, and is ideal for enterprise-level applications.

Performance debugging techniques include:

• Using Angular DevTools to inspect change detection
• Profiling DOM updates and rerenders
• Checking unnecessary subscriptions
• Auditing bundle size and lazy-loading usage
• Using browser Performance tools to identify bottlenecks

SSR pre-renders Angular pages on the server using Angular Universal.

Benefits include improved SEO, faster first contentful paint, better performance on slow devices, and reduced time-to-interactive.

The server renders HTML ? browser loads it ? Angular hydrates and takes over as a SPA.

Custom Pipes transform UI data, but avoid heavy logic inside pipes because they can re-run frequently. Use memoization or pre-computed values when needed to avoid performance issues.

Angular supports:

• Build-time localization
• Static translations via Angular i18n
• Runtime translations via ngx-translate
• Locale-specific formatting for dates, currency, numbers

i18n is essential for global and multilingual applications.

Signals store synchronous reactive values and update the UI automatically without subscriptions.

They simplify state management, eliminate manual cleanup, and improve performance. Observables remain essential for asynchronous workflows, but signals simplify UI state handling.

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.