Loading
Pick a focused question that fits your time, stack, and interview goal.
21 results across 1 active filter
Page 1 of 1
Compares caching response-shaped read models with caching domain entities or raw database objects.
Explains how TTL choices balance freshness, load reduction, user expectations, and operational safety.
Compares cache-aside, read-through, and write-through by read and write ownership, freshness, failure behavior, invalidation, fallback, stampede control, and operational complexity.
Explains when local process memory is enough and when shared Redis-style caching is worth the extra dependency.
Compares Redis pub/sub with durable queues when broadcasting cache invalidation or refresh events.
Explains how to decide if caching is the right fix for a slow API endpoint instead of query tuning or contract changes.
Explains cache-key scope for tenant, user, role, locale, filters, response version, and security-sensitive reads.
Explains hot-key behavior, traffic concentration, partition pressure, payload size, and mitigation options.
Explains when stale cache reads are acceptable, when they are dangerous, and how to make freshness visible.
Explains why cached authorization decisions are risky and how to bound or invalidate permission-related cache safely.
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 delete-on-write, versioned keys, event-driven invalidation, and the race conditions around cache freshness.
Explains cache observability across hit rate, latency, source load, memory, evictions, stale data, and fallback behavior.
Explains what happens when a hot key expires and how request coalescing, TTL jitter, background refresh, and stale serving help.
Explains why Redis connections are reused, how timeouts protect API threads, and how to diagnose client-side Redis pressure.
Explains cached value serialization, schema versioning, deploy compatibility, and safe handling of old payloads.
Explains session state choices for scaled-out ASP.NET Core APIs and when Redis-backed state is appropriate.
Explains the cache-aside pattern for read-heavy endpoints and how misses, TTLs, and source-of-truth reads fit together.
Explains Redis-backed rate-limit counters, atomic increments, windows, identity keys, and fallback behavior.
Explains the risks of Redis-based distributed locks and when database constraints, queues, or idempotency are safer.