Java System Design Interview Questions

Hit heap sizing (-Xms/-Xmx), young/old generations, metaspace, thread stacks, and safepoints. Mention GC logs/metrics, allocation rate, promotion failures, and how you iterate: measure → change one knob → re-measure under production-like load.

Explain that larger batches, fewer context switches, and G1 throughput tuning raise TPS but risk longer pauses, while ZGC, smaller batches, and tighter timeouts protect p95/p99 latency at some throughput cost. Always anchor to SLAs and real traffic shapes.

For CPU-bound work, start near NCPU (or NCPU ± 1). For I/O-bound tasks, size by blocking ratio; consider virtual threads (Java 21) to simplify concurrency without ballooning platform threads. Cap queues, surface backpressure, and measure saturation.

Use CompletableFuture for async composition, timeouts, and non-blocking pipelines; fall back to plain threads for simple, bounded tasks. Prefer structured cancellation and combine with timeouts and bulkheads to avoid runaway fan-out.

Show demand signaling (request(n)), buffer/ drop policies (onBackpressureBuffer/Drop/Latest), and boundaries (publishOn/subscribeOn). Emphasize measuring queues and using timeouts + retries to prevent slow subscribers from collapsing the pipeline.

Keep services small with clear boundaries, externalize config, use Actuator for health/metrics, validate input, and secure defaults. Add idempotency, retries, and circuit breakers; prefer immutable DTOs and contract tests.

Service discovery (Eureka/Consul/K8s DNS) removes hard-coded endpoints, a Config Server centralizes versioned config, and an API Gateway (Spring Cloud Gateway) handles routing, auth, and rate limits. Cost: more hops/operational complexity; benefit: control and safety.

Use REST for synchronous request/response and user-facing actions; use Kafka for async workflows, decoupling, and retries at scale. Often you blend both: REST to accept the command, Kafka to orchestrate downstream side effects.

Pick SQL for strong consistency, joins, and transactions; pick NoSQL for high write throughput, flexible schemas, or large key-value/column workloads. Discuss data access patterns, sharding/secondary indexes, and operational maturity.

Use cache-aside for read-mostly, read-through/write-through when you need atomicity, and TTLs to limit staleness. Prevent stampedes with locks or request coalescing, and invalidate on authoritative writes or via pub/sub.

Prefer stateless (JWT or server-side token + shared store) for scale and resilience. Use sticky sessions only when legacy constraints demand it, and mitigate with a central session store and short lifetimes.

Implement per-key buckets with Redis/Lua or in-JVM buckets plus persistence for multi-node fairness. Expose Retry-After, enforce timeouts, and integrate with gateway policies.

Explain partitions, replication factor, consumer groups, per-partition ordering, and offset management. Tie choices to throughput, durability, and failure handling.

Use Resilience4j (or Spring Cloud Resilience) for timeouts, retry with jitter, bulkheads, and circuit breakers. Distinguish transient vs permanent errors, cap retries, and emit metrics.

Instrument with Micrometer counters, gauges, and histograms; expose /actuator/prometheus; scrape with Prometheus and visualize in Grafana. Track p50/p95/p99 latency and error rates per endpoint.

Propagate W3C traceparent context, instrument HTTP and Kafka clients, export via OTLP, and sample smartly (tail or dynamic) to keep overhead low. Correlate traces with logs/metrics via trace IDs.

Prefer backward-compatible changes; when breaking, use URI or header versioning and deprecate gradually. Provide contract tests and consumer-driven contracts to avoid surprises.

Use JSON/REST for web and ecosystem reach; use gRPC/Protobuf for low-latency, strongly typed, internal RPCs and streaming. Many stacks expose REST externally and gRPC internally.

Measure single-instance throughput, model CPU/heap/GC impact, project concurrency, and add safety margins. Validate with load tests, set SLOs, and add admission control and load shedding before saturation.

Use Strategy to swap algorithms at runtime, Factory to centralize creation and hide complexity, and Template Method to define skeletal workflows. Combine with Spring DI for testability and clear seams.