JS/TS fundamentals
6async/await). It's multi-paradigm: you can write object-oriented or functional code. Modern engines don't interpret it "line by line": they compile it on the fly (JIT). For an Angular interview, add that TypeScript is a superset of JavaScript that adds types checked at compile time, then disappears: the browser always runs JavaScript.class keyword, added in 2015, is a more readable syntax on top of that same mechanism. Functions are also values like any other, so a lot of JavaScript is written in a functional style (map, filter, pure functions). The reassuring answer: "yes, but prototype-based, and we often mix object-oriented and functional code".constructor called on creation. TypeScript adds types and modifiers (private, readonly). In Angular, almost everything is a class: a component, a service, a directive, a pipe. What makes them "Angular" is the decorator on top (@Component, @Injectable…), which tells the framework how to use them.new. If the class is the mould, the instance is the cake: each instance has its own values, but they share the same methods. The Angular point that makes the difference: you never write new MyService() yourself. Dependency injection creates instances and decides how many exist (a single one for the whole app with providedIn: 'root', one per component if you provide it in a component).export class MyComponent implements OnInit forces you to write ngOnInit(). TypeScript checks the contract at compile time. The detail that shows you understand it: interfaces disappear at runtime. That's why you can't inject an interface directly in Angular; you use an InjectionToken or an abstract class.querySelector, appendChild…). In Angular, you almost never touch it by hand: you describe the UI in the template, and Angular updates the real DOM when state changes. Watch out for a common mix-up: Angular does not use a virtual DOM like React, it compiles templates into instructions that update the DOM directly. If you really need the DOM (focus, a third-party library), do it after rendering (afterNextRender), and remember there is no document during server-side rendering.Angular Core
19@Component, which manages a piece of the UI. It has three parts: the selector (the tag that inserts it, app-user-card), the template (the HTML) and the styles. The class holds state and reacts to user actions; it receives data through its inputs and notifies its parent through its outputs. An Angular app is a tree of components.input() and output() rather than @Input() and @Output().app-product-card (dumb). Don't be dogmatic: a small self-contained component doing both is sometimes perfectly fine.input() and output(), and OnPush by default since Angular 22, display components are even simpler to write.input()), child to parent with outputs (output()), and both ways with model() (two-way binding). Between components that aren't parent and child (two "siblings", two pages), you go through a shared service or a store. There's also content projection (<ng-content>), where the parent slots its own HTML into the child, and viewChild() for a parent to reach a child. The good reflex to mention: switch to a service as soon as you find yourself passing data up three levels.core/ for app-wide singletons (interceptors, guards), a shared/ for reusable pieces, lazily loaded routes. Quality: TypeScript strict mode, ESLint and Prettier, written conventions (naming, BEM or another CSS rule, commit format). State: services with signals to start with, a store only if the need shows up. Tests and CI from day one, even light. Depending on the project: i18n, centralised HTTP error handling, environments. End with what you put in writing: a README with these rules, so the fifth person who joins codes like the first.core/ (singleton services, interceptors, guards), shared/ (reusable components, pipes and directives), then features/<feature>/ holding everything about it. On a bigger project, each feature can be split into layers (domain, application, infrastructure, presentation). Why: you find code where you expect it, a feature lazy-loads with its route, and you can delete or hand over a feature without digging through the whole project. The counter-example to mention: a components/ folder with 80 flat files.components/, services/, models/: simple at first, unmanageable later), by feature (the most widespread in Angular), layered inside each feature (inspired by Clean Architecture and DDD), and monorepo with Nx, where the app is split into libraries with rules about who can import what. For a UI component library you also see Atomic Design (atoms, molecules, organisms). Above all, show that you choose based on team and project size, not fashion.@Injectable that holds what doesn't belong in a component: HTTP calls, reusable business logic, state shared across several screens. The component asks for the service (dependency injection) instead of creating it. The result: the component stays focused on display, and the service can be tested on its own.inject(UserService) rather than through the constructor, and it often exposes its state as signals.providers (one instance for that part of the app) or in a component's (one instance per component, useful for state local to a form, for example). providedIn: 'any' still exists but has been deprecated since Angular 15.InjectionToken.inject() function has replaced constructor injection in most projects.providedIn: 'root' service: an AuthService or a shopping cart shared by the whole app. The classic trap: if you add that service to a component's providers, that component gets its own instance, and the state is no longer shared. It's a bug that takes a long time to find.{{ value }} to display text, property binding [src]="url" (class to template), event binding (click)="save()" (template to class) and two-way binding [(ngModel)], which is just shorthand for [ngModel] + (ngModelChange). The "others" interviewers usually expect: [attr.aria-label] (an HTML attribute with no DOM property), [class.active] and [style.width.px].model() lets you offer a [(value)] without writing the input and output by hand.disabled is a boolean attribute: its mere presence disables the button. So <button disabled="false"> is… disabled. In Angular, you bind the property: [disabled]="isSaving", and the button is enabled or disabled based on the value. Second trap, with reactive forms: don't put [disabled] on a field bound to a FormControl (Angular warns you in the console). You disable the control itself with control.disable(), or when you create it.*ngIf with else and as (to keep the result, for example user$ | async as user), *ngFor with index, first, last, even, odd, count and above all trackBy to avoid re-rendering everything, and [ngSwitch].@if / @else, @for with a mandatory track and the $index, $first, $last, $even, $odd, $count variables, an @empty block for empty lists, and @switch. *ngIf and *ngFor have been deprecated since Angular 20, and ng update can migrate the code.[ngClass] accepts an object ({ 'card--active': isActive, 'card--error': hasError }, the most common form), an array or a string. For a single conditional class, [class.card--active]="isActive" is more readable. Avoid calling a method in the binding ([ngClass]="getClasses()"): it runs again on every change detection; prefer a computed value.[class] and [style] bindings over NgClass and NgStyle, and an automatic migration exists.ngClass, or a home-made appAutofocus, appTooltip), and structural directives, which add or remove elements from the DOM (the old *ngIf). A component is actually a directive with a template. To write one: @Directive({ selector: '[appAutofocus]' }), then act on the host element.host property rather than with @HostListener and @HostBinding.{{ price | currency:'EUR' }}. Built-in ones to mention: date, currency, number, percent, uppercase, lowercase, titlecase, slice, keyvalue, json (for debugging) and above all async, which subscribes to an Observable and unsubscribes on its own. To create one: a @Pipe({ name: 'truncate' }) class with a transform() method. By default a pipe is pure: it only recomputes when its input changes (by reference), which makes it very cheap. An impure pipe recomputes on every cycle: avoid it. A detail interviewers like: to get French formats (1 234,56 €), you need to register the fr locale.path maps to a component ({ path: 'users/:id', component: UserDetail }), and you provide it with provideRouter(routes). When the URL changes, the router displays the right component in the <router-outlet>, without reloading the page. You navigate with routerLink in templates or router.navigate() in code. Around that: URL parameters, guards (canActivate, canMatch) to protect a route, resolvers to load data before display, and lazy loading.withComponentInputBinding(), route parameters arrive directly in the component's input()s.<router-outlet> changes as you navigate. They can be nested: a parent route with child routes displays the children in its own <router-outlet>. There are also named outlets, to show a second route side by side (a side panel, for example).loadComponent: () => import('./admin/admin').then((m) => m.Admin) (or loadChildren for a whole group of routes), the build creates a separate JavaScript file. The initial bundle is smaller, so the first page displays faster. You can then preload routes in the background once the page is shown (withPreloading(PreloadAllModules)).@defer applies the same idea to a piece of a template (a chart at the bottom of the page, loaded when it becomes visible).RxJS & Signals
6complete) or fail (error). It's lazy: until someone subscribes (subscribe), nothing happens. The expected comparison: a Promise gives a single value, starts right away and can't be cancelled; an Observable can give several values, starts on subscription and is cancelled by unsubscribing. The concrete trap: an HttpClient call is a "cold" Observable, so two | async on the same Observable fire two requests.next()), and which broadcasts them to all its subscribers at once. The variants to know: Subject (no initial value, a new subscriber only gets later values), BehaviorSubject (has an initial value and immediately gives the latest value to a new subscriber: ideal for state), ReplaySubject (replays the last N values) and AsyncSubject (only gives the last value, at the end). Good practice: keep the Subject private in the service and expose only asObservable(), so nobody else can emit.HttpClient returns Observables. The router exposes paramMap and its events as Observables. Reactive forms have valueChanges. The old @Output() relies on EventEmitter, which is a Subject. In templates, you read them with the async pipe, which subscribes and unsubscribes on its own. The example that shows you can use them: a search with valueChanges.pipe(debounceTime(300), distinctUntilChanged(), switchMap((term) => this.api.search(term))).toSignal(); RxJS remains the right tool for event streams.BehaviorSubject holding the state, a public read-only Observable (asObservable()), and methods that change it by creating a new value (this.items$.next([...this.items$.value, item])) rather than mutating the old one. Components read with | async and never get access to next(). ReplaySubject(1) is for when there's no sensible initial value.signal(), exposed with asReadonly(), and computed() for derived values (item count, total).map, filter, tap (side effect, debugging). Chain calls: switchMap (cancels the previous call: search), concatMap (in order: successive saves), mergeMap (in parallel), exhaustMap (ignores clicks while a call is running: a "pay" button). User input: debounceTime, distinctUntilChanged. Combine: combineLatest (several filters), forkJoin (wait for several calls). Errors: catchError, retry. Share: shareReplay. Stop: take, takeUntilDestroyed.subscribe() calls as possible. In the template, the async pipe subscribes and unsubscribes on its own. In the class, takeUntilDestroyed() ends the subscription when the component is destroyed. toSignal() does the same and turns the stream into a signal. The old way, still very common in existing code: a destroy$ = new Subject<void>(), takeUntil(this.destroy$) and a next() in ngOnDestroy. A useful detail: an HttpClient call completes on its own, but unsubscribing still cancels the request if the user leaves the page before the response.Architecture & State
10BehaviorSubject) is enough for most apps. NgRx Store (actions, reducers, selectors, effects) is justified when many screens share complex state and you want to trace every change (debugging tools, history). NgRx SignalStore is a lighter middle ground built on signals. What looks bad: bringing in NgRx for a three-page app. What looks good: explaining the criterion that made you choose, and what it cost (extra code, training the team).GET, POST, PUT, PATCH, DELETE), a URL identifying the resource (/api/users/42), headers (Content-Type, Authorization) and sometimes a JSON body. The server answers with a status code (200 OK, 201 created, 400 bad request, 401 not authenticated, 404 not found, 500 server error) and usually JSON. In REST, each request stands on its own: the server keeps no session between calls. In Angular: HttpClient (provideHttpClient()), typed responses, and interceptors to add the token or handle errors in one place.httpResource() re-runs the request on its own and is stable since Angular 22.fetch, localStorage, geolocation. A good API is stable and documented, and when it changes, it warns you (versioning).POST /users to create, GET /users or GET /users/42 to read, PUT (full replacement) or PATCH (partial change) on /users/42 to update, DELETE /users/42 to delete. The detail that makes the difference: GET, PUT and DELETE are idempotent (replaying them gives the same result), POST is not. That's why you never automatically retry a POST after a network error: you could create two orders.calculateTotalPrice() rather than calc()), short functions that do one thing, no duplication, no hidden side effects, and comments that explain why rather than what. In Angular, examples speak louder: no logic in templates, components that don't do everything, naming conventions followed everywhere. The best argument: a piece of code you made more readable, and what it changed for the team.domain/, a repository interface provided through an InjectionToken, and the HTTP implementation in infrastructure/. Benefits: logic can be tested without Angular, and you can swap the data source. A downside to acknowledge: more files. For a small app, it's often too much.Contract), bounded contexts ("customer" doesn't mean the same thing for billing and for support), entities (which have an identity), value objects (defined by their values, like an amount with its currency) and aggregates (a group of objects changed together under rules). On the front end, it mostly means one folder per business context and names that match the business.customElements.define('user-card', ...)), usable like any tag, in any page. Angular Elements (@angular/elements) turns an Angular component into a custom element with createCustomElement(): its inputs become properties and attributes, its outputs DOM events. Use case: embedding an Angular widget in a site that isn't built with Angular (a CMS, a React app). The limitation to mention: the element ships the Angular runtime, so it's heavy for a small component.Performance & Observability
2async emits or a signal read in its template changes. Hence the importance of immutability: mutating an object in place triggers nothing.Eager, and the migration adds it to existing components so they keep their behaviour.ErrorHandler, to know which error affects how many users; measuring real-world performance (Core Web Vitals from real visitors, through a RUM tool or Google's reports); and locally, Lighthouse, Chrome's Performance tab and the Angular DevTools profiler. The point not to forget: don't send personal data in error logs.Testing, Build & CI
7wait(5000)): wait for a condition (an element visible, a request finished), which Playwright and Cypress already do by retrying assertions. A clear choice between a real back end and mocked responses. And they run in CI, with screenshots or video on failure: an E2E suite you only run by hand ends up not being run at all.data-cy or data-testid: cy.get('[data-cy="submit"]'). It doesn't move when styling or HTML structure changes, and it clearly says "a test uses this element". To avoid: CSS classes (.btn-primary), position-based selectors (div > p:nth-child(2)) and displayed text if the app is translated.getByRole('button', { name: 'Send' }) with Playwright or Testing Library). Bonus: if the test can't find the button by its role, there's often an accessibility problem.ng serve locally (a dev server that recompiles on every save), ng build for production, and settings go through angular.json (environments, size budgets, assets). What the build does for you: bundle files, minify, remove unused code (tree shaking), split into chunks for lazy loading. You only touch Webpack for a special need, with a custom builder.tags keyword says which runner (which machine) should run it: for example a runner with Docker, or an internal runner with access to the company network. And Git tags (v2.3.0) are often used to trigger a release pipeline: build, test and deploy the tagged version. Around that, you can recap a typical front-end pipeline: install, lint, tests, build, deploy.