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.

Choose among aggregation, a subquery, a CTE, and a window function for a reporting requirement.

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.

Design a basic paginated REST endpoint contract with input validation and consistent problem responses.

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.

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

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

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

Diagnose resource leaks using garbage-collection roots, IDisposable, and IAsyncDisposable reasoning.

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.

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

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

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

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

Design a reactive-form validation flow that handles dynamic fields and server-side validation errors.

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.

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

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

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

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

Plan a backward-compatible EF Core database migration for a live deployment.

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

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

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.

Diagnose CORS or CSRF behavior without confusing browser controls with authentication or authorization.

Protect a public API with rate limits, audit evidence, secure error handling, and abuse monitoring.

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.

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.

Diagnose a SQL Server bottleneck using query plans, waits, blocking, and workload evidence.

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

Produce a blameless incident explanation with impact, evidence, contributing factors, corrective actions, and verification.

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.

Choose a realistic database-testing approach for EF Core behavior that an in-memory fake cannot validate.

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.

Design a secure, cache-efficient multi-stage Dockerfile for an ASP.NET Core service.

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.

Choose among Azure App Service, Functions, container hosting, and AKS for a stated workload.

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

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

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.