Senior Full-Stack .NET Interview Preparation

Explain the responsibilities of Angular components, templates, services, and dependency injection, and distinguish standalone from NgModule-based application bootstrap.

Explain how Angular template expressions, bindings, directives, and pipes participate in rendering a component view.

Explain Angular component lifecycle hooks and parent-child data flow through inputs and outputs.

Compare template-driven and reactive forms and defend a choice for a complex form scenario.

Explain route configuration, lazy loading, route-parameter handling, and why route guards do not replace API authorization.

Use Angular HttpClient in a typed service and explain response handling, error handling, and cross-cutting interceptor responsibilities.

Model a small TypeScript domain with interfaces or type aliases, discriminated unions, unknown narrowing, and a generic result type, defending each choice.

Explain observable subscription behavior and the roles of Observable, Subject, and BehaviorSubject.

Build and explain a representative RxJS pipeline using map, filter, catchError, and a lifecycle-safe teardown mechanism.

Write and explain a relational query using INNER or LEFT joins and aggregation, and use a basic window function when row-preserving analytics are required.

Explain clustered, nonclustered, composite, and covering indexes and their basic write-cost trade-offs.

Explain how ACID guarantees and SQL Server isolation levels govern a transaction.

Match HTTP methods and status codes to common API operations and error conditions.

Explain resource-oriented URLs, statelessness, safety, idempotency, and content negotiation in a REST API.

Distinguish authentication from authorization and explain the roles of JWTs, HTTPS, and CORS at a high level.

Choose among classes, records, and structs for a .NET model and defend the choice using identity, mutability, and allocation behavior.

Define cancellation and timeout boundaries for an asynchronous ASP.NET Core operation.

Select dependency-injection lifetimes and identify captive-dependency and thread-safety risks.

Explain how Angular change detection affects a component and justify when to use OnPush.

Choose among switchMap, concatMap, mergeMap, and exhaustMap for a stated user-interaction scenario.

Read a SQL Server execution plan to identify a likely indexing or query-shape problem.

Shape an EF Core query to avoid N+1 loading, over-fetching, and unnecessary tracking.

Design a resource-oriented HTTP contract with defensible methods, status codes, validation errors, pagination, and versioning.

Diagnose sync-over-async and thread-pool starvation in an ASP.NET Core request path.

Order an ASP.NET Core middleware pipeline to support exception handling, authentication, authorization, and observability.

Choose a reliable execution model for background work initiated by a web application.

Make a state-changing API operation safe against duplicate delivery using idempotency and concurrency controls.

Explain the OAuth 2.0 Authorization Code with PKCE and OpenID Connect flow for an Angular client calling a protected .NET API, including token-validation responsibilities.

Design policy-based authorization that enforces least privilege beyond simple role checks.

Threat-model an API feature for injection, broken access control, sensitive-data exposure, and unsafe input handling.

Use TypeScript narrowing and domain types to make invalid UI states harder to represent.

Diagnose duplicate requests and memory leaks caused by incorrect observable subscription management.

Choose among local component state, shared RxJS services, signals, and a store for an Angular feature.

Diagnose stale UI data or out-of-order responses in an Angular application.

Design a relational model for a business workflow and defend normalization and denormalization choices.

Choose an isolation level and mitigation strategy for a blocking or deadlock scenario.

Explain EF Core optimistic concurrency using concurrency tokens and defend a conflict-resolution strategy.

Isolate the cause of a slow data-access path across EF Core, generated SQL, indexes, and database waits.

Define a reproducible performance investigation using a baseline, hypotheses, measurements, and success thresholds.

Correlate logs, metrics, and traces across browser, API, dependencies, and database for one failed request.

Select .NET diagnostic evidence to distinguish high CPU usage, memory or garbage-collection pressure, and lock contention in a production scenario.

Diagnose an Angular performance problem using browser network, rendering, and bundle evidence.

Lead investigation of an intermittent production failure while separating mitigation from root-cause analysis.

Frame a system-design prompt by clarifying functional requirements, quality attributes, constraints, and success criteria, then estimating traffic, storage, latency, and availability needs sufficiently to guide the design.

Choose between a modular monolith and microservices based on team, domain, deployment, and operational trade-offs.

Choose synchronous or asynchronous communication for a cross-component workflow and explain its failure modes.

Design a caching strategy with explicit ownership, invalidation, and stale-data behavior.

Design an eventually consistent workflow using durable messaging, idempotent consumers, and recovery paths.

Present an evolvable full-stack architecture for a stated product scenario and defend its boundaries, bottlenecks, security, failure handling, and trade-offs under follow-up questioning.

Deliver a role-relevant senior-engineer introduction that connects past impact to the target position.

Explain an example of end-to-end ownership using specific decisions, measurable impact, and lessons learned.

Describe resolving a technical disagreement through evidence, listening, and an explicit decision process.

Explain how you mentored or unblocked another engineer without taking over their work.

Describe influencing an architectural or delivery decision across engineers, product partners, and stakeholders.

Discuss a failure or production incident with accountability, corrective action, and demonstrated learning.

Answer a prioritization scenario involving technical debt, delivery pressure, operational risk, and stakeholder expectations.

Choose unit, integration, contract, and end-to-end test coverage for a stated change based on risk and feedback speed.

Write a focused unit-test strategy for an asynchronous .NET service without over-mocking implementation details.

Design an ASP.NET Core integration test that exercises middleware, routing, authentication, and dependency wiring.

Design an Angular test for a component or service with asynchronous RxJS behavior.

Diagnose a flaky test and distinguish timing, shared-state, environment, and test-isolation causes.

Explain production-readiness trade-offs for a containerized .NET service across configuration, secrets, health checks, networking, and least-privilege execution.

Design CI quality gates for build, tests, static analysis, dependency scanning, and artifact creation.

Choose a deployment strategy and rollback trigger for a high-risk production release.

Map a .NET API, Angular front end, SQL database, background processing, and files to appropriate Azure services.

Design service-to-service access using managed identities, least privilege, and Key Vault.

Choose resilience controls for transient faults while avoiding harmful retry amplification.