.NET Senior Development

Derive functional requirements and quality attributes for the game backend from a short product scenario.

Partition the backend into cohesive player, progress, achievement, and leaderboard capabilities.

Compare layered, hexagonal, and vertical-slice structures for a stated backend scenario.

Structure the game backend as a modular monolith with enforceable dependency boundaries.

Encode a domain invariant with value objects and aggregate behavior rather than controller logic.

Separate a write use case from a read model without introducing unnecessary infrastructure.

Record a consequential architecture choice in an Architecture Decision Record.

Trace an ASP.NET Core request through middleware, routing, model binding, filters, and the endpoint handler.

Design REST resources, methods, status codes, and idempotency semantics for player and game-progress operations.

Implement a game-backend API endpoint using dependency injection and strongly typed configuration.

Diagnose a captive dependency or scoped-service lifetime defect in an ASP.NET Core application.

Validate API input and return consistent RFC 7807 Problem Details responses.

Generate an accurate OpenAPI description for an ASP.NET Core API.

Implement pagination, filtering, and sorting without exposing persistence models as API contracts.

Introduce a backward-compatible API change using an explicit versioning strategy.

Map a game-progress aggregate to PostgreSQL with explicit EF Core entity configuration.

Create a backward-compatible EF Core migration and document its rollback strategy.

Write projection-based EF Core queries that avoid unnecessary tracking and N+1 database access.

Implement optimistic concurrency control for competing game-progress updates.

Use a database transaction to preserve invariants across multiple writes.

Choose a PostgreSQL transaction isolation level for a stated consistency requirement.

Implement keyset pagination for a high-volume leaderboard query.

Write focused unit tests for domain invariants using behavior-oriented test names.

Make time-dependent and identifier-dependent code deterministic in tests.

Run an EF Core integration test against disposable PostgreSQL infrastructure.

Test an ASP.NET Core endpoint through its complete HTTP pipeline with WebApplicationFactory.

Verify error responses and API contracts with integration tests.

Create an architecture test that detects a forbidden dependency between modules.

Design a compact test suite that distinguishes unit, integration, contract, and end-to-end responsibilities.

Apply cloud consumption economics and the shared-responsibility model when choosing IaaS, PaaS, or SaaS for a migration scenario.

Explain how management groups, subscriptions, resource groups, and resources establish Azure scope.

Choose between regions, availability zones, and region pairs for a stated availability requirement.

Compare Azure App Service, Container Apps, Functions, Kubernetes Service, and virtual machines for a backend workload.

Select appropriate Azure storage, relational data, NoSQL, and messaging service categories for stated requirements.

Identify the roles of virtual networks, subnets, private endpoints, load balancers, and application gateways.

Choose Azure RBAC, Azure Policy, or resource locks for a stated access-control, compliance, or deletion-protection requirement.

Select Azure Cost Management, Advisor, Service Health, or Azure Monitor for a stated cost, optimization, platform-health, or telemetry need.

Create a lightweight STRIDE threat model for the public game API.

Distinguish OAuth 2.0 authorization from OpenID Connect authentication in a token-based application.

Register an API and test client in Microsoft Entra ID and obtain an access token.

Configure an ASP.NET Core API to validate Microsoft Entra ID access tokens.

Enforce claim-based and resource-based authorization with ASP.NET Core policies.

Store application secrets in Azure Key Vault and access them through managed identity.

Implement ASP.NET Core rate limiting to mitigate unrestricted API resource consumption.

Configure HTTPS, CORS, and secure error handling for a public API.

Build a secure multi-stage Docker image for the ASP.NET Core service.

Provision an Azure Container Registry and Container Apps environment with Bicep.

Provision Azure Database for PostgreSQL and its application connectivity with Bicep.

Deploy the game-backend container to Azure Container Apps with environment-specific configuration.

Create a continuous-integration pipeline that restores, builds, tests, and scans the application.

Create a continuous-delivery pipeline that publishes an image and deploys an immutable revision.

Apply a safe database-migration and application-rollback strategy during deployment.

Configure tags, budgets, and resource cleanup to control the portfolio environment's Azure cost.

Decide whether a capability should remain in the modular monolith or cross a service boundary.

Design an asynchronous integration event for an achievement-awarding workflow.

Publish and consume an Azure Service Bus message from .NET.

Implement the transactional outbox pattern for reliable event publication.

Make a message consumer idempotent under duplicate delivery.

Configure timeouts, retries, and circuit breaking for an outbound HTTP dependency using a .NET resilience pipeline.

Model eventual consistency and reconciliation for an asynchronously updated leaderboard.

Emit structured application logs with correlation identifiers and safe contextual fields.

Instrument a cross-component request with OpenTelemetry distributed tracing.

Define service metrics for request traffic, errors, latency, and dependency health.

Query application failures and performance data in Azure Application Insights.

Implement startup, liveness, and readiness health checks with distinct semantics.

Define a measurable service-level indicator and service-level objective for the game API.

Configure an actionable Azure Monitor alert that avoids obvious alert noise.

Diagnose an injected production-style failure and document the response in a concise runbook.

Design and run a repeatable load test for a representative game-backend workload.

Profile a .NET request path to identify a CPU, allocation, or blocking bottleneck.

Analyze EF Core-generated SQL and a PostgreSQL execution plan for a slow query.

Implement a cache-aside strategy for leaderboard reads with an explicit invalidation rule.

Prevent a cache stampede on a frequently requested resource.

Make the API stateless so multiple instances can serve requests safely.

Configure an Azure Container Apps scaling rule from a measured workload signal.

Translate measured load-test results into an Azure Container Apps capacity and monthly-cost estimate.

Tailor résumé accomplishment bullets to a representative senior .NET/Azure job description using evidence from prior work and the course project.

Estimate request throughput, concurrency, storage growth, and bandwidth from the assumptions in a timed system-design prompt.

Produce a system-design diagram showing components, data ownership, trust boundaries, and request flows.

Defend design trade-offs involving consistency, availability, security, operability, and cost.

Implement a bounded LRU cache in C# under interview constraints and justify its time and space complexity.

Review a pull request for correctness, maintainability, security, performance, and test coverage.

Prepare concise STAR stories demonstrating technical leadership, ownership, conflict resolution, and failure recovery.

Present the deployed game backend with an architecture diagram, operational evidence, and a senior-level trade-off narrative.