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.
108 results across 1 active filter
Page 4 of 5
Chooses between a modular monolith and microservices using domain boundaries, team ownership, scaling, deployment, data consistency, and operational cost.
Turns a useful Aspire development model into explicit production infrastructure without treating the local AppHost as the runtime platform.
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.
Explains token storage, cookies, XSS, CSRF, and why browser UI never replaces server authorization.
Builds a story about challenging a risky requirement while staying constructive and product-oriented.
Builds a story about taking feedback seriously and changing behavior in a visible way.
Repairs a workflow when a remote operation may have succeeded but local state, messages, and callbacks disagree.
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.
Protects source, dependencies, workflows, build identities, runners, artifacts, and deployment verification while preserving traceability and patch response.
Uses separate models where they protect contracts, invariants, or storage evolution while avoiding repetitive mapping with no boundary value.
Explains the output shape of core LINQ transformations and uses them without hiding empty groups, duplicate keys, or excessive buffering.
Applies single responsibility to reasons for change, cohesive behavior, and maintainable service boundaries instead of counting methods.
Uses static members for type-wide stateless behavior and constants while avoiding hidden global mutable state and lifetime problems.
Distinguishes operators that can yield incrementally from operators that must consume substantial input before producing results.
Uses async streams for incremental asynchronous production while preserving cancellation, disposal, backpressure expectations, and API boundaries.
Structures xUnit tests around per-test instances and shares only expensive infrastructure through deliberate class, collection, or assembly fixture lifetimes while preserving isolation and parallel safety.
Selects synchronous calls, asynchronous messaging, or a deliberate combination based on user feedback, coupling, latency, durability, and failure behavior.
Builds a story about taking responsibility for a production bug, mitigating impact, and preventing recurrence.
Moves invariant-sensitive decisions toward the owning object while keeping orchestration, queries, and cross-boundary work appropriately explicit.
Builds a concrete story about owning a feature from requirements through release, verification, and follow-up.
Combines schema diffing, real provider tests, consumer expectations, generated clients, semantic scenarios, and rollout evidence to prevent accidental API breaks.