Senior Full-Stack .NET Interview Preparation

Apply encapsulation, abstraction, inheritance, polymorphism, interfaces, and composition to explain a small C# object model.

Explain the responsibilities of Angular components, templates, services, dependency injection, and application bootstrap.

Use interpolation, property binding, event binding, two-way binding, directives, and pipes in a small Angular template.

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

Choose between template-driven and reactive forms and explain basic routing and route-parameter handling.

Use Angular HttpClient in a typed service and explain basic response and error handling.

Distinguish TypeScript interfaces, type aliases, unions, generics, any, and unknown in interview-sized examples.

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

Apply common RxJS creation, transformation, filtering, error-handling, and completion operators to a simple data flow.

Write and explain INNER, LEFT, and self joins for a stated relational query.

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

Explain ACID properties, isolation levels, blocking, and deadlocks in a basic SQL Server transaction scenario.

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 an OAuth 2.0 and OpenID Connect token flow for an Angular client calling a protected .NET API.

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.

Implement and explain optimistic concurrency handling for an EF Core update.

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.

Diagnose a .NET performance problem involving CPU, allocation, garbage collection, locks, or thread-pool pressure.

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.

Clarify functional requirements, quality attributes, constraints, and success criteria before proposing an architecture.

Estimate traffic, storage, latency, and availability needs sufficiently to guide a design decision.

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 and defend its boundaries, bottlenecks, security, 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.

Configure and troubleshoot container networking, externalized settings, secrets, health checks, and non-root execution for a .NET service.

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.