Drills

Query timeouts and command timeouts

Fits database command timeouts into endpoint latency budgets while diagnosing slow SQL, blocking, pool pressure, and uncertain write outcomes.

Refactor an N plus one order-status loop

Replaces a parent query plus one status query per row with one server-side projection.

Coding problemHard~35 min

Reproduce an API concurrency conflict

Uses two isolated EF Core contexts to reproduce a real optimistic-concurrency conflict through the API boundary.

.NETASP.NET CoreC#EF CoreSQL+1

Coding problemHard~35 min

Retry an explicit EF Core transaction safely

Wraps a complete explicit transaction in the provider execution strategy and creates fresh context state for each retry attempt.

.NETASP.NET CoreC#EF Core

Return 202 for a durable background job

Persists a job and outbox command before returning a status URL for long-running work.

Debugging scenarioHard~12 min

Review a destructive EF Core migration before production

Reviews and stages destructive EF Core schema changes around live data, locks, mixed application versions, recovery, and rollback.

.NETASP.NET CoreEF CoreSQLSQL Server

Save an order and outbox message together

Persists domain state and its outbox message in one SaveChanges transaction without publishing inside the request transaction.

Coding problemHard~35 min

Scope tenant state around a pooled DbContext

Wraps a pooled DbContext factory so every request assigns tenant state before a global query filter can run.

Shadow properties and audit columns in EF Core

Explains EF Core shadow properties for audit or infrastructure columns with practical .NET data-access examples and production trade-offs.

Tag and inspect a slow EF Core query

Adds a stable query tag and inspects generated SQL without embedding user data or enabling unsafe global logging.

.NETASP.NET CoreC#EF CoreSQL+1

Test an idempotent POST retry

Proves repeated requests with one idempotency key create one resource and return a consistent result.

Architecture scenarioHard~12 min

Test database migrations and rolling compatibility

Verifies migration SQL, data preservation, production-provider behavior, mixed application versions, backfills, and expand-contract releases.

.NETC#EF CoreSQLSQL Server+1

Update one property without loading the entity

Attaches a key-only stub and marks one property modified for a narrow update while naming the rules this pattern bypasses.

Concept questionHard~9 min

Use capacity, load shedding, and backpressure signals

Explains saturation signals and how systems shed, queue, throttle, or degrade before cascading failure.

.NETApplication InsightsASP.NET CoreAzure Service BusEF Core+4

.NETASP.NET CoreEF CoreSQL

Use DbContext pooling without leaking request state

Uses EF Core context pooling only when reusable context state, tenant isolation, and underlying connection state are controlled and tested.

.NETASP.NET CoreEF CoreSQL

Use EF Core compiled queries on hot paths

Explains when EF Core compiled queries help, what they do not fix, and how to measure their value.

Debugging scenarioMedium~10 min

Use EF Core query tags and correlation for production debugging

Explains how query tags, request correlation, and telemetry help connect slow SQL back to code paths.

.NETApplication InsightsASP.NET CoreEF CoreSQL

.NETASP.NET CoreEF CoreSQL

Use ExecuteUpdate instead of loading entities for bulk changes

Explains when set-based EF Core updates are better than loading entities and where lifecycle behavior can differ.

Architecture scenarioHard~12 min

Use read models for complex API screens

Explains read models for complex API screens with practical .NET data-access examples and production trade-offs.

Concept questionEasy~5 min

What is deferred execution in LINQ and EF Core?

Explains LINQ deferred execution with EF Core with practical .NET data-access examples and production trade-offs.

What is the N+1 query problem in EF Core?

Explains N+1 queries in EF Core with practical .NET data-access examples and production trade-offs.

Concept questionEasy~5 min

Why avoid returning EF entities directly from APIs?

Explains returning EF entities from APIs with practical .NET data-access examples and production trade-offs.