Pick a focused question that fits your time, stack, and interview goal.
How much time do you have?
Show one-drill sessions you can finish now.
300 results across 1 active filter
Page 7 of 13
Makes nested create and update semantics, authorization, identity, and transaction ownership explicit.
Uses FastAPI Security dependencies to combine declared scopes with current application authorization.
Separates fast rollback isolation from tests that must observe commits, multiple connections, or database concurrency.
Uses routers as feature-oriented HTTP modules while keeping application logic, composition, and contract ownership clear.
Organizes Django configuration without duplicating environments or leaking secrets into source code.
Carries an original version through an API update and turns an optimistic-lock failure into an explicit conflict workflow.
Coordinates admission stop, task cancellation or draining, resource closure, and bounded termination.
Tests asynchronous coordination through observable events and proves spawned tasks finish or cancel cleanly.
Verifies provider signatures over raw bytes, enforces freshness, and makes repeated delivery idempotent.
Chooses immutable values and controlled mutable entities based on identity, concurrency, invariants, allocation cost, and update semantics.
Builds a small immutable money type with explicit scale, rounding, arithmetic, ordering, and value equality.
Builds a frozen dataclass around Decimal with explicit scale, validation, arithmetic, ordering, and value equality.
Uses inheritance only for stable behavioral subtyping and tests whether derived objects preserve the promises callers rely on.
Designs consumer-focused contracts that reduce accidental authority and coupling without producing meaningless one-method wrappers.
Builds a useful DRF lifecycle model for policy checks, handler execution, exception conversion, and rendering.
Explains substitutability through inputs, outputs, side effects, and failure behavior rather than inheritance syntax alone.
Starts object-oriented design from cohesive state and behavior instead of creating classes for every noun in a requirement.
Uses stable extension points for genuinely variable behavior while avoiding speculative abstractions and configuration-driven branching.
Separates compile-time overload selection from runtime virtual dispatch and diagnoses method hiding through a base reference.
Places invariants and state transitions near the data they protect while keeping orchestration and infrastructure out of domain entities.
Evaluates repositories by domain language, query ownership, and substitutability instead of treating them as a mandatory wrapper around DbSet.
Explains how callers use one contract while runtime dispatch selects implementation, then connects that mechanism to extensible behavior.
Uses separate models where they protect contracts, invariants, or storage evolution while avoiding repetitive mapping with no boundary value.
Applies single responsibility to reasons for change, cohesive behavior, and maintainable service boundaries instead of counting methods.