Design distributed systems architecture

Trace the DNS resolution path for a request to a globally distributed service, identifying performance bottlenecks and caching layers

Configure DNS A, AAAA, CNAME, and MX records and verify their propagation

Configure DNS TTL values and analyze trade-offs between availability and cache staleness

Implement DNS-based load balancing using round-robin and weighted records, analyzing its limitations for high-load systems

Set up GeoDNS routing to direct traffic based on geographic location

Analyze the TCP connection lifecycle in high-load systems, identifying connection reuse and pooling optimizations

Configure TCP keepalive parameters to detect dead connections in load balancers

Analyze Layer 4 vs Layer 7 load balancing trade-offs in terms of performance, observability, and routing capabilities

Configure nginx as a reverse proxy with upstream definitions, load balancing algorithms, and health checks

Compare HAProxy and nginx for TCP and HTTP load balancing, analyzing their performance characteristics and configuration approaches

Set up Envoy proxy with basic routing rules and cluster definitions

Configure nginx upstream connection pooling and analyze its impact on latency and resource utilization

Configure proxy timeouts in nginx and analyze their effect on system resilience and user experience

Configure retry policies and budgets in nginx for upstream services and analyze the trade-offs between availability and load

Configure nginx as an edge proxy to distribute traffic across simulated datacenter clusters using weighted routing

Analyze ACID property trade-offs in PostgreSQL for high-throughput workloads

Configure and compare PostgreSQL isolation levels: Read Committed, Repeatable Read, and Serializable

Demonstrate concurrency anomalies in PostgreSQL and resolve them using appropriate isolation levels

Configure PostgreSQL write-ahead logging (WAL) parameters and analyze their impact on durability and performance

Configure PostgreSQL streaming replication with synchronous and asynchronous modes

Configure connection pooling with PgBouncer for high-concurrency scenarios

Analyze the architectural and operational trade-offs between single-node partitioning and multi-node sharding in PostgreSQL

Design a partitioning scheme by selecting an appropriate partition key and strategy for a given workload

Implement declarative table partitioning in PostgreSQL with automatic partition routing

Analyze the stages of the expand-contract pattern, detailing the state of application code and database schema at each step to ensure zero-downtime deployment

Implement a zero-downtime column addition using the expand-contract pattern

Design a shadow table migration strategy for a complex schema change, outlining the trigger logic, backfill process, and cutover plan

Implement triggers to dually write to an original table and a shadow table during a migration

Execute and monitor a data backfill process to populate a shadow table without locking the original table

Perform an atomic cutover to a shadow table using a table rename and validate the migration's success

Explain MongoDB's consistency model and configure read and write concerns for different consistency requirements

Set up MongoDB replica sets with primary-secondary replication and automatic failover

Set up a MongoDB sharded cluster architecture, including routers (mongos), config servers, and shard replica sets

Select an appropriate shard key for a given data model and query pattern, analyzing trade-offs between different key strategies

Analyze chunk distribution, splits, and the behavior of the balancer in a sharded MongoDB cluster

Explain consistent hashing and virtual nodes in Cassandra and analyze their impact on data distribution

Configure Cassandra replication strategy and replication factor across datacenters

Explain Cassandra's eventual consistency model, including the roles of replication factor (N) and tunable consistency levels (W, R)

Configure various consistency levels for read and write operations in Cassandra and analyze the resulting trade-offs in availability and consistency

Explain Cassandra's storage architecture: Log-Structured Merge-Tree, Memtables, and SSTables

Configure compaction strategies in Cassandra for different workload patterns

Explain Redis persistence models: RDB snapshots and AOF, analyzing durability vs performance trade-offs

Configure Redis replication with master-replica topology

Set up Redis Sentinel for automatic failover and high availability

Configure Redis Cluster for horizontal sharding and analyze partition distribution

Configure cache eviction policies in Redis: LRU, LFU, and TTL-based

Implement the cache-aside pattern for synchronizing Redis with a primary data store

Configure Redis pipelining and transactions for batching operations

Explain Kafka's log-based architecture and its durability guarantees

Configure Kafka topics with partitions and replication factor

Explain the architecture of Kafka's In-Sync Replicas (ISR) and its role in consistency

Configure producer acknowledgment levels (acks=0, 1, all) and analyze latency-durability trade-offs

Configure consumer groups with partition assignment strategies

Configure log retention policies: time-based and size-based

Analyze the architecture and trade-offs of cross-datacenter replication with MirrorMaker 2, including failover strategies and data consistency considerations

Configure and run MirrorMaker 2 to replicate a topic between two Kafka clusters

Implement an idempotent Kafka producer to achieve exactly-once semantics per partition

Implement a transactional Kafka producer to achieve atomic writes across multiple partitions

Implement the Retry pattern with exponential backoff and jitter

Implement the Circuit Breaker pattern using a client-side library

Configure circuit breaking in a service mesh proxy (e.g., Envoy) and analyze the trade-offs versus a library-based approach

Implement the Bulkhead pattern to isolate resource pools in microservices

Implement structured logging with correlation IDs for tracing requests across services

Configure health checks and readiness probes for graceful service deployment

Implement the Transactional Outbox pattern using a database table and message relay

Compare choreography vs orchestration for implementing Sagas and design a Saga for a given scenario

Implement compensation logic for a failed step in a choreographed Saga

Design bounded contexts for a given business domain using DDD strategic patterns

Design aggregates within a bounded context to enforce transactional consistency boundaries

Apply Clean Architecture layers and dependency rules to structure the code within a service or bounded context

Design a CQRS-based architecture for a given workload, implementing separate read and write models

Explain Event Sourcing concepts: event stream, aggregates, projections, and snapshots

Implement persistence of an aggregate's state as an event sequence in an event store

Model a business process by defining event sequences, producers, and consumers

Implement a projection to create a read model from an event stream

Implement a mechanism to rebuild a projection from an event store

Design an idempotent event handler to ensure exactly-once processing semantics

Outline a strategy for non-breaking event schema evolution