Drills

Flatten a category tree with a recursive CTE

Uses a recursive CTE to return hierarchy depth and a readable root-to-node path.

SQLSQL Server

Group orders by customer summary

Builds customer summaries from order rows using grouping, aggregation, and deterministic ordering.

.NETC#

.NETASP.NET CoreC#EF CoreSQL+1

Guard an endpoint against N plus one queries

Uses a test-only DbCommandInterceptor to fail a regression when database command count grows with page size.

Handle an optimistic version conflict with SQLAlchemy

Uses SQLAlchemy version counters and an HTTP precondition to reject stale writes without silently overwriting newer state.

FastAPIPythonSQLAlchemy

.NETASP.NET CoreC#EF CoreSQL+1

Handle a rowversion conflict in an update endpoint

Uses the client's original rowversion to detect a lost update and return a deliberate conflict response.

Handle downstream timeout and cancellation

Separates caller cancellation from a dependency timeout and maps expected downstream outcomes safely.

.NETASP.NET CoreC#

Implement a bounded PDF upload endpoint

Validates size and signature, writes under a generated storage key, and keeps untrusted files outside the public web root.

.NETASP.NET CoreC#

Implement an atomic bulk status update

Validates a bounded command set completely before applying all updates in one SaveChanges transaction.

Implement and test a production-safe readiness check

Builds a bounded readiness check for one required dependency while keeping liveness independent and responses non-sensitive.

.NETASP.NET CoreC#xUnit

Implement an idempotent retryable Celery provider task

Builds a Celery task that survives timeout ambiguity, retries temporary failures, and records one durable business outcome.

Python

Implement an immutable USD money value object in Java

Builds a small immutable money type with explicit scale, rounding, arithmetic, ordering, and value equality.

Implement an immutable USD money value object in Python

Builds a frozen dataclass around Decimal with explicit scale, validation, arithmetic, ordering, and value equality.

Python

Implement an optimistic favorite with rollback

Applies an immediate reversible mutation, blocks overlapping writes, and restores the previous state on failure.

Next.jsReactTypeScript

Implement an optimistic version conflict in JPA

Carries the version observed by the client into a conditional update and returns an explicit conflict instead of silently overwriting newer data.

Implement a persisted idempotent FastAPI POST

Implements a database-backed idempotency boundary that replays one response and rejects key reuse with a different request.

FastAPIPythonSQLAlchemy

Implement a persisted idempotent POST

Stores an idempotency key, request hash, and response in the same transaction as the created resource.

Implement a persisted idempotent POST with Spring and JPA

Uses a scoped idempotency key, request hash, unique constraint, and one transaction to create an order exactly once from the API perspective.

Implement a simple fixed-window rate limiter

Implements a small in-memory fixed-window rate limiter with per-key counters.

.NETC#

Implement a simple LRU cache

Implements a small LRU cache using a dictionary plus linked list for O(1) get and put.

.NETC#

Implement a stable EF Core keyset page

Implements descending keyset pagination in LINQ using a compound timestamp-and-id cursor.

Implement stable keyset pagination with async SQLAlchemy

Builds descending keyset pagination with a unique tie-breaker, opaque cursor, limit-plus-one query, and stable next page.

PythonSQLAlchemy

Implement stable keyset pagination with Spring Data JPA

Implements descending cursor pagination with a unique tie-breaker, bounded projection query, and next-cursor detection.

Import records in bounded EF Core batches

Processes a large import in chunks with fresh DbContexts, idempotent keys, cancellation, and bounded tracker growth.