System Design for Developers

Model a backend domain as PostgreSQL tables with primary keys, foreign keys, uniqueness constraints, and appropriate data types.

Write SELECT queries that filter, sort, and limit PostgreSQL result sets.

Combine related tables using inner and outer joins.

Summarize relational data using aggregate functions, GROUP BY, and HAVING.

Perform parameterized INSERT, UPDATE, and DELETE operations and retrieve affected rows.

Execute parameterized PostgreSQL queries from Go using pgx and map results into typed structs.

Apply and roll back versioned PostgreSQL schema migrations.

Normalize a relational schema through third normal form and identify when a deliberate denormalization is justified.

Choose a PostgreSQL B-tree index for a specific query and explain its write and storage costs.

Use EXPLAIN ANALYZE to identify a sequential scan, inefficient join, or inaccurate row estimate.

Use a database transaction to preserve a multi-step business invariant.

Distinguish common PostgreSQL isolation levels by the anomalies each permits or prevents.

Diagnose a lock wait or deadlock and revise the transaction to reduce contention.

Implement keyset pagination for a stable, indexed result set.

Configure and justify PostgreSQL connection-pool limits for a Go service.

Translate application access patterns into a MongoDB document model.

Choose between embedding and referencing for a MongoDB relationship.

Perform parameterized MongoDB CRUD operations from Go using the official driver.

Create a MongoDB index that supports a given filter and sort pattern.

Use MongoDB explain output to verify whether a query uses its intended index.

Apply single-document atomic updates and transactions to preserve stated invariants.

Decide whether PostgreSQL, MongoDB, or both best fit a specified service workload.

Define a versioned REST API contract with resources, status codes, and a consistent error format.

Separate Go HTTP handlers, business logic, and persistence behind testable interfaces.

Validate and normalize untrusted API input before invoking business logic.

Propagate request cancellation and deadlines through Go contexts to database calls.

Implement filtering, sorting, and cursor-based pagination in a REST endpoint.

Make a state-changing endpoint safely retryable using an idempotency key.

Document and validate an HTTP API using an OpenAPI specification.

Choose between REST and gRPC for a service interaction and implement one unary gRPC method in Go.

Write table-driven unit tests for Go business logic using fakes at external boundaries.

Write an integration test that exercises a Go repository against a disposable database.

Detect and remove a data race in concurrent Go code using the race detector.

Implement a bounded Go worker pool that applies backpressure rather than spawning unbounded goroutines.

Apply timeout, retry, exponential-backoff, and jitter policies only to retry-safe operations.

Add a circuit breaker around an unreliable downstream dependency.

Implement graceful shutdown that drains in-flight HTTP requests and background workers.

Expose liveness, readiness, and dependency-health endpoints with distinct semantics.

Identify which reads are suitable for caching from their consistency and access-pattern requirements.

Implement cache-aside reads in Go using Redis.

Choose Redis TTL and eviction settings for a stated freshness and memory requirement.

Invalidate or update cached data after a successful database write.

Prevent a cache stampede using request coalescing or probabilistic refresh.

Implement a distributed rate limiter with Redis and explain its failure behavior.

Measure cache hit ratio and latency to decide whether a cache is beneficial.

Choose synchronous calls, a work queue, or event streaming for a specified interaction.

Map an event stream to Kafka topics, partitions, keys, and consumer groups.

Publish and consume versioned Kafka messages from Go.

Explain at-most-once, at-least-once, and effectively-once processing outcomes.

Build an idempotent Kafka consumer that tolerates duplicate delivery.

Route repeatedly failing messages through bounded retries to a dead-letter topic.

Use the transactional outbox pattern to avoid losing events after a database commit.

Diagnose consumer lag, partition skew, and backpressure from Kafka metrics.

Relate latency, throughput, availability, durability, and consistency to concrete service requirements.

Compare leader-follower and multi-leader replication for a stated read/write workload.

Select an appropriate strong or eventual consistency model for a business invariant.

Apply CAP and PACELC reasoning to a network-partition scenario.

Choose a partition key that limits skew while supporting required queries.

Use consistent hashing to reduce data movement when a sharded cluster changes size.

Select a distributed ID strategy based on ordering, uniqueness, and coordination requirements.

Model a multi-service business process as a saga with compensating actions.

Estimate requests per second, peak concurrency, storage growth, and network bandwidth from product assumptions.

Place load balancers and reverse proxies to distribute traffic and terminate connections.

Scale a stateless service horizontally while externalizing session state.

Use read replicas while accounting for replication lag and read-after-write requirements.

Combine a CDN and object storage for scalable delivery of static or user-uploaded content.

Use queues to absorb traffic bursts and protect slower downstream services.

Locate an architectural bottleneck using capacity estimates and propose the smallest effective scaling change.

Emit structured logs with request, user, and trace correlation identifiers while excluding sensitive data.

Instrument a Go service with request-rate, error-rate, latency, and resource-saturation metrics.

Trace a request across service, database, cache, and message-broker boundaries.

Define a service-level indicator, service-level objective, and actionable alert for a user-facing operation.

Create a threat model that identifies trust boundaries, assets, attack paths, and mitigations for an API.

Validate signed access tokens and enforce role- or resource-based authorization in Go middleware.

Apply parameterization, allow-listing, and outbound URL validation to prevent injection and server-side request forgery.

Protect service traffic and credentials using TLS, least-privilege access, and externally managed secrets.

Build a minimal multi-stage Docker image for a Go service that runs as a non-root user.

Run the service and its PostgreSQL, MongoDB, Redis, and Kafka dependencies in a reproducible local container environment.

Deploy a Go service with Kubernetes Deployment and Service resources.

Configure Kubernetes startup, readiness, and liveness probes for distinct failure conditions.

Supply runtime configuration and secrets to a Kubernetes workload without baking them into the image.

Set CPU and memory requests and limits, then configure horizontal scaling from an observed metric.

Perform a rolling deployment and rollback while preserving service availability.

Design a CI/CD pipeline that tests, scans, builds, migrates, deploys, and verifies a backend release.

Clarify a system-design prompt into explicit functional requirements, constraints, and out-of-scope items.

Derive capacity estimates and measurable non-functional requirements before selecting components.

Present an API, data model, high-level architecture, and request flow in a coherent interview sequence.

Evaluate architecture choices using bottlenecks, failure modes, consistency needs, security, and cost.

Produce a time-boxed design for a URL-shortening service with durable storage, caching, and collision handling.

Produce a time-boxed design for a notification platform using queues, retries, preferences, and delivery tracking.

Produce a time-boxed design for an order-processing system that preserves inventory and payment invariants.

Produce a time-boxed design for a high-volume activity feed with fan-out, ranking boundaries, and hot-user mitigation.