Loading
Pick a focused question that fits your time, stack, and interview goal.
618 drills fit a 20-minute session. Closest fits first.
Page 15 of 26
Explains dependency duration, error rate, timeout rate, query tagging, Redis latency, HTTP downstream calls, and endpoint correlation.
Chooses contracts and shared implementation based on substitutability, state ownership, evolution, and inheritance constraints.
Avoids hidden quadratic work by indexing repeated matches while preserving duplicate, missing, ordering, and memory semantics.
Compares test doubles by purpose and explains when a real dependency provides a more trustworthy test.
Chooses a type shape from identity, value semantics, mutation, copy cost, default values, and serialization boundaries.
Creates valid objects with clear intent while choosing construction patterns proportionally to optional data, validation, and lifecycle complexity.
Explains when optimistic UI is worth it, when to wait for server confirmation, and how to recover from rejected mutations.
Compares rollback, roll-forward, feature kill switches, scaling, and degraded mode as incident mitigations.
Chooses a deployment strategy from capacity, compatibility, risk, observability, and rollback needs, then defines progressive promotion and abort signals.
Selects small structural and behavioral patterns from the problem being solved instead of pattern-name recognition.
Separates ordinal identity comparison from culture-aware display ordering and keeps hash-based collection semantics consistent.
Chooses database test infrastructure by the provider behavior a test must prove.
Explains inward dependency flow, stable business policy, adapters, and when a smaller project structure is enough.
Explains cleanup for subscriptions, timers, event listeners, and aborting stale fetches.
Explains loading, error, empty, success, refetch, stale data, and request lifecycle in client-rendered React.
Uses complexity as a first filter while accounting for constants, locality, allocations, data size, and the complete operation sequence.
Explains short-lived access tokens, refresh-token rotation, revocation, storage choices, and replay detection.
Compares cache-aside, read-through, and write-through by read and write ownership, freshness, failure behavior, invalidation, fallback, stampede control, and operational complexity.
Designs a narrow covering index from predicates and ordering, then weighs eliminated lookups against storage, write overhead, cache efficiency, overlap, and maintenance cost.
Explains when CSRF matters, how cookies change browser behavior, and what mitigations fit API clients.
Compares vendor-neutral OpenTelemetry concepts with Application Insights usage for .NET production services.
Compares Redis pub/sub with durable queues when broadcasting cache invalidation or refresh events.
Explains how roles group permissions while API policies enforce specific capabilities and resource rules.
Combines focused collaborators for independent behavior while recognizing cases where a genuine stable hierarchy remains simpler.