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.
1345 results
Page 17 of 57
Explains Redis memory pressure, eviction policies, key sizing, TTL discipline, and what happens when the cache is full.
Explains how an API behaves when Redis is unavailable and which cache usages can safely fall back.
Explains stale edit detection, row versioning, conflict UI, refresh behavior, and safe update contracts.
Explains what happens when roles or tenant membership change while access tokens still contain old claims.
Explains initial incident triage: confirm impact, mitigate, assign roles, preserve evidence, and communicate.
Explains why application-level duplicate checks are not enough and how EF Core APIs map database constraints to friendly errors.
Builds a story about turning unclear requirements into a scoped, testable plan without overbuilding.
Separates process start from readiness, coordinates hosted-service startup, and drains work within a bounded shutdown window.
Handles an urgent production fix from verified impact and deployed provenance through minimal code, focused validation, controlled rollout, rollback readiness, and merge-forward.
Explains Python calls through object sharing, local parameter binding, mutation, reassignment, and explicit ownership.
Defines managed memory leaks as unwanted reachability and connects caches, listeners, class loaders, ThreadLocal values, and queues to retaining paths.
Connects EF Core change tracking to object retention, query shape, projections, and read-only API performance.
Shows how publisher-to-subscriber references can retain objects and how to clean up event-based lifetimes.
Focuses on ToList chains, collection capacity, repeated enumeration, and memory-aware data shaping.
Finds failures hidden by test-owned transactions, automatic rollback, open persistence contexts, missing flushes, and separate server threads.
Separates caller time bounds, cancellation propagation, and ownership of protected underlying work.
Explains optimistic atomic updates, retries, contention, immutable state replacement, and the boundary of single-variable safety.
Separates authentication orchestration, mechanism-specific verification, and username-based user lookup.
Explains staging slots, validation before swap, warm-up, traffic continuity, and safer production releases for App Service APIs.
Explains early and late acknowledgement without promising exactly-once task execution.
Tunes worker pools and reservation behavior to task shape instead of maximizing a single concurrency number.
Explains Java's catch-or-declare rule and turns exception choice into a recoverability and API-contract decision rather than a universal slogan.
Explains attribute lookup, shared class state, instance shadowing, and automatic method binding through practical Python behavior.
Explains lexical scope, captured names, late lookup, loop callback failures, and deliberate state ownership in closures.