Angular + .NET Interview Preparation

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

Recover from an unknown interview detail by reasoning from fundamentals without bluffing.

Predict Angular component and directive lifecycle-hook order and place initialization, view interaction, and cleanup logic correctly.

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

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 Angular HTTP interceptor chain for authentication, correlation, error handling, and controlled 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, or missed emissions in an Angular RxJS flow.

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 a browser event or asynchronous completion results in an Angular template update.

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.

Apply encapsulation, polymorphism, composition, and inheritance to improve a C# production design without overengineering it.

Choose between an interface and an abstract class based on contracts, shared implementation, 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.

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 through middleware, routing, endpoint execution, and response generation.

Order middleware correctly and explain short-circuiting for exceptions, CORS, authentication, authorization, and endpoints.

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.

Use IHttpClientFactory and resilience policies without introducing socket exhaustion or unsafe retry behavior.

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.

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

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

Write window-function queries with PARTITION BY, ordering, and explicit frame semantics.

Choose correctly among ROW_NUMBER, RANK, and DENSE_RANK for a stated business requirement.

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.

Choose between EXISTS and IN, or UNION and UNION ALL, based on semantics and likely execution behavior.

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.

Explain EF Core tracking, identity resolution, AsNoTracking, and AsNoTrackingWithIdentityResolution behavior.

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 that isolates business behavior without coupling tests to implementation details.

Use mocks, stubs, fakes, and real collaborators selectively based on the risk being tested.

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.

Diagnose common .NET production failures involving thread-pool starvation, memory pressure, connection pools, or exception storms.

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

Explain JWT structure, signing, claims, expiration, refresh-token risks, revocation limitations, and secure storage choices.

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

Assess CSRF, XSS, injection, broken access control, and secret-exposure risks in an Angular and .NET design.

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.

Evolve and version an API contract without unnecessarily breaking deployed clients.

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.

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.