Angular + .NET Interview Preparation

Explain a coding solution while implementing it, including invariants, complexity, failure cases, and test strategy.

Use a concise five-layer readiness check to verify that a P0 concept can be expanded on demand through behavior, mechanics, trade-offs, edge cases, and a production example without reciting a scripted answer.

Predict component and directive lifecycle-hook and render-callback order, placing initialization, view interaction, and DestroyRef-based cleanup correctly.

Choose among a component, attribute directive, structural directive, pure pipe, and impure pipe for a production requirement.

Implement a typed reactive form with synchronous, asynchronous, and cross-field validation while explaining update and submission behavior.

Trace an Angular navigation through route matching, parameter handling, nested routes, redirects, and lazy-loaded boundaries.

Select and implement CanMatch, CanActivate, and CanDeactivate guards while explaining why client-side guards are not security boundaries.

Design an ordered functional HTTP interceptor chain for authentication, correlation, error handling, and safe retries without recursive or duplicate requests.

Explain the execution, laziness, cancellation, and multi-value differences between an Observable and a Promise.

Predict the behavior of cold, hot, unicast, and multicast observable pipelines in a given scenario.

Select among Subject, BehaviorSubject, and ReplaySubject based on late-subscriber and state requirements.

Choose among switchMap, mergeMap, concatMap, and exhaustMap for a production workflow and justify the concurrency semantics.

Compose multiple asynchronous sources with combination operators appropriate to their emission and completion behavior.

Design error handling, retry, timeout, and cleanup behavior for an RxJS pipeline.

Prevent subscription leaks using the async pipe, takeUntilDestroyed, and explicit teardown where appropriate.

Diagnose duplicate HTTP requests, stale responses, missed emissions, or incorrect caching caused by subscription placement, flattening operators, share, or shareReplay.

Plan a focused migration from an Angular 10 NgModule-based feature to Angular 22 standalone architecture and modern bootstrap configuration.

Explain hierarchical dependency injection, injection contexts, inject(), and environment-level providers in modern Angular.

Trace how an event or asynchronous completion schedules a template update in both Zone.js-based and zoneless Angular applications.

Explain how OnPush change detection interacts with input references, events, observable emissions, and signals.

Model local derived UI state with signal, computed, and effect while avoiding inappropriate side effects.

Choose between signals, RxJS, or an interoperation of both for a concrete state-management scenario.

Implement modern template control flow with stable tracking semantics for efficient list rendering.

Design route-level lazy loading and deferrable views that improve startup and interaction performance.

Refactor a production C# design by choosing composition or inheritance and an interface or abstract class based on contracts, shared behavior, versioning, and testability.

Detect a SOLID-principle violation in C# code and refactor it while explaining the resulting trade-offs.

Trace .NET dependency registration and resolution, select an appropriate service lifetime, and detect lifetime mismatches.

[P1 — if time] Model data using classes, records, or value types while reasoning precisely about nullability, equality, copying, mutation, and allocation behavior.

Explain how async and await compile into a state machine and how misuse can cause blocking or thread-pool starvation.

Implement an asynchronous C# workflow with bounded concurrency, cancellation, and deterministic error handling.

Reason about deferred execution, multiple enumeration, materialization, and side effects in a LINQ coding task.

Select C# collections by operation complexity, ordering, uniqueness, concurrency, and allocation requirements.

Apply HTTP method semantics, status codes, headers, idempotency, and caching behavior to an API scenario.

Design a REST-oriented resource contract with appropriate URIs, representations, pagination, filtering, and error semantics.

Contrast the .NET 10 LTS hosting and endpoint model with older startup and controller-centric ASP.NET Core practices.

Trace an ASP.NET Core request while ordering exception handling, CORS, authentication, authorization, routing, and endpoint middleware and explaining short-circuit behavior.

Explain model binding, validation, API controller behavior, and Problem Details responses for invalid requests.

Propagate CancellationToken correctly across an HTTP request, application service, EF Core, and outbound dependency.

[P1 — if time] Configure IHttpClientFactory handlers and resilience policies without causing socket exhaustion, handler-state leaks, retry storms, or retries of unsafe operations.

Write and reason about inner, outer, cross, and self joins for a stated data requirement.

Solve an aggregation problem using GROUP BY, HAVING, conditional aggregation, and correct null semantics.

Use a common table expression to make a multi-stage or recursive SQL query correct and understandable.

Choose among a join, noncorrelated subquery, and correlated subquery based on semantics and execution implications.

Choose between a SQL Server stored procedure and function based on composability, side effects, security, and performance constraints.

Normalize a relational model to remove update anomalies and justify selective denormalization for a measured workload.

Choose correctly between EXISTS and IN under three-valued NULL logic, and between UNION and UNION ALL under duplicate and execution-cost requirements.

Write window-function queries with partitioning, ordering, and explicit frames, selecting ROW_NUMBER, RANK, or DENSE_RANK for the required tie behavior.

Solve a timed SQL coding problem involving duplicates, missing matches, top-per-group rows, or running aggregates.

Explain how clustered and nonclustered indexes store and locate rows in SQL Server.

Design a composite covering index using key order, selectivity, predicates, sorting needs, and included columns.

Interpret execution-plan operators such as seeks, scans, lookups, joins, sorts, and spills.

Rewrite a non-SARGable or poorly estimated query to improve index usage and cardinality estimation.

Diagnose a slow parameterized query using actual plans, runtime statistics, parameter sensitivity, and measured evidence.

Predict dirty reads, non-repeatable reads, phantom reads, and blocking under SQL Server isolation levels.

Compare locking-based READ COMMITTED with row-versioning options such as RCSI and SNAPSHOT.

Analyze a SQL Server deadlock graph and propose changes that reduce recurrence without weakening correctness.

Define a transaction boundary that preserves a business invariant while minimizing contention.

Define a safe DbContext unit-of-work boundary and choose among tracking, AsNoTracking, and AsNoTrackingWithIdentityResolution while explaining identity resolution and thread-safety constraints.

Choose between FirstOrDefault and SingleOrDefault based on generated work, data invariants, and failure behavior.

Explain what SaveChanges does for change detection, command execution, transactions, generated values, and concurrency failures.

Eliminate EF Core N+1 queries, cartesian explosion, over-fetching, and unnecessary client-side materialization.

Define a unit-test boundary and choose mocks, stubs, fakes, or real collaborators based on behavioral risk without coupling tests to implementation details.

Test asynchronous .NET code for success, cancellation, failure, and race-sensitive behavior.

Write an ASP.NET Core integration test that exercises routing, middleware, dependency injection, and persistence boundaries.

Test an Angular component or service with observable or signal-driven state without brittle timing assumptions.

Correlate structured logs, metrics, and distributed traces across an Angular-to-.NET request path.

Localize an intermittent latency regression across browser, API, EF Core, SQL Server, and external dependencies.

Distinguish .NET thread-pool starvation from database or HTTP connection-pool exhaustion using metrics, traces, call stacks, and async-flow analysis.

[P1 — if time] Use GC and heap evidence to distinguish retained-memory leaks from allocation pressure, high GC pause time, and Large Object Heap fragmentation.

Separate authentication from authorization and trace a JWT bearer request through token validation and policy evaluation.

Design browser authentication using an appropriate OAuth 2.0 and OpenID Connect flow, then reason about JWT signing, claims, expiration, refresh, revocation limitations, and browser storage choices.

Configure CORS from the browser security model rather than treating it as an authentication mechanism.

Threat-model an Angular and .NET design for CSRF, XSS, injection, broken access control, and secret exposure, then select concrete mitigations.

Design idempotent APIs and background workflows that remain correct under retries and duplicate delivery.

Select caching boundaries and invalidation strategies for browser, API, distributed cache, and database layers.

Design a scalable full-stack feature by defining service boundaries, data ownership, API contracts, and failure behavior.

[P1 — if time] Evolve and version an API contract without unnecessarily breaking deployed clients or creating permanent compatibility branches.

Handle a progressively deep Angular and RxJS interview chain from API usage through runtime mechanics and performance trade-offs.

Handle a progressively deep .NET and EF Core interview chain from request behavior through runtime and database mechanics.

Solve and explain a timed SQL task that includes correctness, indexing, execution-plan reasoning, and concurrency follow-ups.

Solve and explain a timed practical data-structure problem at the level expected in a senior full-stack interview.

Produce a scoped senior-level system design under time pressure and adapt it when requirements change.

Lead a production-incident scenario from triage through mitigation, root-cause analysis, and prevention.

[P1 — if time] Present a behavioral example about technical leadership, disagreement, ownership, or failure using specific evidence and reflection.

Run a final gap-driven mock interview and convert missed follow-ups into a prioritized last-mile review plan.