Get the Preplance app for a seamless learning experience. Practice offline, get daily streaks, and stay ahead with real-time interview updates.
Get it on
Google Play
4.9/5 Rating on Store
Google · System Design
Practice System Design questions specifically asked in Google interviews – ideal for online test preparation, technical rounds and final HR discussions.
Questions
67
Tagged for this company + subject
Company
View company-wise questions
Subject
System Design
Explore topic-wise practice
Go through each question and its explanation. Use this page for targeted revision just before your Google System Design round.
Per-tenant or per-user quota enforces fairness. A global circuit or shedder protects the whole fleet from aggregate spikes. A layered approach lets you preserve good traffic while isolating abusers or faulty clients.
check(userLimit) && check(globalLimit) ? allow() : shed();
For complete preparation, combine this company + subject page with full company-wise practice and subject-wise practice. You can also explore other companies and topics from the links below.
SRP reduces ripple effects. When a class owns one responsibility, changes are localized and easier to test. This improves cohesion and long-term maintainability. In system design, the same idea guides service boundaries: one clear capability per service keeps coupling low and evolution safer.
Denormalize when read latency and complex joins dominate critical paths, or when pre-joined aggregates are repeatedly needed. It trims joins and can simplify queries. Risks include write amplification, anomalies, and harder integrity. You must add repair jobs, careful update paths, and validations to keep copies in sync.
Use structured logs, RED/USE metrics, and distributed tracing. A shared correlation id links them. This speeds incident triage and validates SLOs after release.
X-Correlation-Id: a2b3-...-9c
Introduce it when the lifecycle is complex and errors are costly. It makes allowed transitions explicit and highlights guards such as “payment captured” before shipping. This reduces invalid state hops, improves tests, and informs compensating actions for failures and refunds.
Pending -> Paid -> Shipped -> Delivered Invalid: Shipped -> Pending (guard prevents)
Sequence diagrams show lifelines and messages across participants with time flowing top to bottom. They’re ideal to explain request flows, retries, and timeouts in system design discussions.
Identify entities: ParkingLot, Floor, Spot, Ticket, Vehicle, RateCard, Payment. Use Strategy for pricing so rules vary by type and duration. A SpotSelector chooses an appropriate spot based on vehicle type and availability. Repositories manage persistence per aggregate (e.g., Ticket as root). Keep commands like enter(vehicle) and exit(ticketId). Ensure concurrency safety with atomic spot allocation and ticket issuance.
interface Pricing{ moneyFor(entry, exit, type): Money }
class Ticket{ id; spotId; entryTime; }If the WHERE clause references the partition key with ranges or equality, the planner can skip irrelevant partitions. Design queries and partition schemes together to exploit pruning and reduce scan cost.
WHERE event_date BETWEEN '2025-10-01' AND '2025-10-07'
Anchor on product impact: user tolerance for stale reads, regulatory needs, and failure stories. If latency and availability are king, prefer AP regions with conflict resolution and client-visible freshness markers. If correctness dominates (e.g., financial ledger), choose CP paths, accept higher latency, and invest in queues, retries, and user feedback for occasional write unavailability.
For feeds, eventual consistency is fine if users tolerate brief staleness. You gain low latency and high availability using caches and replicas. Add freshness markers and client pull-to-refresh for critical actions. If strict correctness is required, confine strong consistency to write paths or small critical reads, then fan-out later. This narrows the expensive guarantees to where they matter.
Header: X-Data-Freshness: ~5s
Validate payload structure and simple constraints at the boundary to fail fast. Enforce business invariants inside domain services to keep them centralized. This split avoids duplication and keeps core rules intact even when called from jobs or other services.
if(!payload.email) return 400; orderService.place(validatedCommand);
Tokens represent allowance. You atomically decrement on each request and refill at a steady rate. Use monotonic clocks and per-key buckets; persist to a store like Redis when distributed.
if(tokens.get(k) > 0){ tokens.decr(k); allow(); } else deny();Microservices pay off when teams cannot ship independently. Tight coupling, long integration cycles, and a shared database that forces lockstep releases are strong signals. If a monolith still deploys quickly and safely, keep it. Optimize modularity first; split only where autonomy is worth the operational cost.
Symptom: one small change → rebuild whole app → coordinated release
A sync chain fails if any hop fails, which raises tail latency and blast radius. Async queues buffer work and isolate producers, but you must design for out-of-order delivery and duplicates. Choose per use case. Keep the critical user path short and consider async for side effects.
orders → (event) orders.created → inventory,email
Coalesce concurrent misses so only one rebuild hits the origin. Refresh hot keys before expiry with staggered jitter to avoid thundering herds at the same second.
mutex.lock(k); if(expiringSoon) refreshWithJitter();
When a partition occurs, the system cannot synchronously coordinate all replicas. You either reject or block some requests to keep data consistent, or serve all requests and risk divergence. That is the core trade-off at partition time.
If partition: choose C (reject writes) OR choose A (accept, reconcile later).
Split write and read concerns. A primary region handles consistent writes and emits events. Downstream read models and geo replicas are built asynchronously for low-latency reads near users. During partitions, writes may be constrained to the primary (CP), while reads use replicas with eventual or bounded staleness (AP). Clear freshness headers and cache hints set user expectations. Backfill and replays keep read models correct over time.
Write → Event Bus → Regional Read Model → CDN/Cache
Horizontal sharding distributes different rows of the same table to multiple physical nodes to scale write and read throughput. Vertical partitioning separates columns by concern, often isolating wide or cold fields to another table or service for performance and cost control.
users_shard_17 holds user_id hash 544..575; profile_wide moved to users_profile_ext
A router computes the shard from the partition key, manages shard maps, and provides health-aware failover. It shields clients from topology changes and exposes metrics on hit rates, latency, and errors. Deploy it stateless behind a load balancer with config in a durable store. Roll out changes with feature flags and canaries. Keep a fast local cache of the shard map and a background refresher to avoid cold lookups.
route(key){ sid=hash(key)%N; return pool[sid].pickHealthyReplica(); }Use a single LUA script to compute tokens available since last refill, cap by burst size, and atomically decide allow/deny. Store last_refill_ts and tokens_left per key. The script reads, calculates new tokens using now, clamps, then decrements if request fits, returning remaining and reset. This read–modify–write in one command prevents races across instances. Add key expiry based on idle time to reclaim memory and return headers based on the script output.
EVALSHA(bucket.lua) -> {allowed, remaining, resetEpoch}Queues are good for task distribution: a message is consumed once by any consumer in the group. Streams (like Kafka) persist an append-only log; many consumer groups can read the same data independently. Pick queues for fan-out of work, and streams for analytics, multiple downstreams, or replay.
Queue: workers pull → ack Stream: topic partitions → consumer groups with offsets
EDA means services react to events to decouple producers and consumers. The database of record can still be state-based; events are integration messages and may be disposable after processing. It shines when multiple downstream actions or workflows must react to the same change with loose coupling. Event sourcing persists the append-only sequence of domain events as the system of record, and current state is derived by replay. Choose it when auditability, temporal queries, and reconstructing past state are central, and when the domain naturally fits an event log.
EDA: order.created → email, billing ES: store domain events; Read models build via projection
Prefer precise invalidation over global flushes. Keep a mapping from product IDs to cache keys and issue targeted purge or key bump on update. Pair this with short TTLs and stale-while-revalidate so the CDN can serve slightly stale content while refreshing in the background. For dynamic fragments, use Edge Side Includes or micro-APIs with independent TTLs. On write, publish an event that triggers cache purge in edge and application caches for that product ID.
onProductUpdate(id){ purge(`product:*:${id}:*`); emit('product.updated', id); }CAP states that under partition you trade serving every request (availability) against returning the latest consistent view (consistency). Designs pick AP or CP per workload and surface the guarantees to clients.
TTL limits staleness automatically. Event invalidation updates or removes keys on data change. Choose eviction (LRU/LFU/FIFO) and consistency model per use case.
A sequence diagram shows lifelines and messages across participants over time. It clarifies who calls whom, retries, and error paths. This is ideal to reason about APIs, timeouts, and idempotency in a distributed system.
User -> API -> Auth -> API -> Orders
Component diagrams show modules, the interfaces they expose, and the dependencies they consume. This helps define clean boundaries and plan team ownership and versioned APIs.
AuthService provides IAuth; API requires IAuth
Multiplicity clarifies cardinality: 0..1, 1, 1..*, or 0..*. It prevents ambiguity and aligns with DB design. Use it to avoid many-to-many surprises in LLD.
Customer 1 ─── places ─── 1..* Order
Pick a sequence diagram when the focus is who talks to whom and in what order. It highlights calls, retries, and time-based concerns like timeouts or backoffs. Pick an activity diagram when the focus is the flow of work, branching conditions, and parallelism. It clarifies business rules, forks, and joins without tying you to specific participants.
Decision: sequence for API call flow; activity for checkout workflow
Abstract Factory creates related products that are meant to be used together, like themed UI widgets. One switch changes the entire set coherently. This prevents mismatched combinations and centralizes the family choice at construction time.
interface UIFactory { btn(): Button; input(): TextBox }
class MacFactory implements UIFactory { /* returns Mac widgets */ }Singletons act like globals. They hide dependencies and make order of initialization tricky. Tests become hard because state leaks across cases. Prefer dependency injection and scoped lifetimes. If a single instance is required, enforce it at composition root, not inside the class.
class Config { private static final Config I = new Config(); static Config get(){ return I; } }A unique key per intent lets servers detect duplicates and return the original result. This prevents double charges or duplicate orders. It also simplifies client logic under network retries and failovers.
POST /orders Idempotency-Key: 9f1d-...-ab12
Decorator wraps an object to add cross-cutting behavior like caching, logging, or rate limiting. You stack them flexibly. It follows open–closed: extend behavior without touching the wrapped type.
CacheRepo = new CachingDecorator(new SqlRepo());
Observer broadcasts changes to subscribers without hard coupling. It supports plug-in listeners for metrics, audit, or caches. For distributed systems, evolve it into pub/sub with a message broker for scale and durability.
subject.attach(logger); subject.notify({event:"OrderPlaced"});Choose Template Method when the high-level algorithm is stable and you need fixed steps with small overridable hooks. Subclasses change only the hook points while the skeleton stays in the base. Choose Strategy when entire algorithm variants need swapping at runtime, not just small differences. Strategy keeps composition flexible, while Template Method relies on inheritance.
abstract class Validator{ final validate(){ checkAuth(); checkBody(); } protected abstract checkBody(); }Circuit Breaker tracks recent failures when calling a dependency. After a threshold, it opens and fails fast. After a cool-off, it half-opens and probes. If probes succeed, it closes again. The goal is to avoid cascading failures and protect shared resources. Place it in the client library or gateway where calls originate. Combine with timeouts, bulkheads, and fallbacks. Expose metrics so SREs can tune thresholds per dependency and traffic pattern.
if (breaker.open) throw FastFail;
try{ resp=call(); breaker.recordSuccess(); } catch(e){ breaker.recordFailure(); }Start with what success looks like. State functional goals, traffic shape, latency and availability targets, data retention, and hard constraints. This aligns trade-offs. Only then pick storage, caches, and protocols. The system exists to meet SLOs, not to use favorite tools.
SLO: p95 GET /feed < 200 ms, 99.9% availability
LFU prefers items with high access frequency, which can outperform LRU when hot sets are stable. LRU works well when recent access predicts near-future access.
policy: allkeys-lfu
Queues buffer bursts and isolate producers from consumer slowness. They improve resilience and enable backpressure. Design for at-least-once delivery; make consumers idempotent.
topic: orders.created -> workers: inventory, email
Phase 1: simplest architecture that meets SLOs—CDN, a cache, a single write store with replicas, and background workers. Keep feature flags and blue-green deploys. Phase 2: add sharding, dedicated search, or stream processing when metrics prove need. Use cost dashboards, autoscaling, and right-sizing. Revisit storage classes and egress to cut waste.
rollout: canary 1% -> 10% -> 50% -> 100%
Immutable objects cannot change after creation, so you avoid aliasing bugs and accidental sharing issues. This makes concurrent code safer. They also enable safe reuse and hashing. Changes are modeled as new instances, which keeps history clear.
class Money { readonly amount:number; readonly currency:string; }Concurrent structures need clear ownership and atomicity. Use read–write locks or CAS-based maps. Keep critical sections short and avoid holding locks during I/O. Prefer immutable snapshots for readers when feasible; it reduces contention.
ConcurrentMap<K,V> cache; // atomics for putIfAbsent/get
A mesh standardizes networking features between services: mutual TLS, circuit breaking, timeouts, and per-route policies, often without code changes. It complements gateways by handling east–west traffic. Use it when the fleet grows and policies must be consistent.
Policy: timeout 300ms; retry: 2; mTLS: strict
You place a routing layer in front of the monolith and peel off one capability at a time into a new service. The router sends only that capability’s traffic to the new service and keeps everything else on the monolith. Run shadow traffic and canaries before switching real users. Keep a rollback path and common auth, logging, and metrics across both worlds so issues are visible and reversible.
Gateway routes /payments/* → PaymentsSvc; rest → monolith
Add timeouts and retries with jitter to avoid long hangs. Use a circuit breaker to fail fast after consecutive errors and probe recovery through half-open trials. Provide fallbacks where possible, such as cached data or degraded responses. Expose metrics on error rates and breaker state so on-call teams can tune thresholds.
timeout=300ms; retries=2; circuit=open after 5 failures/30s
Caching brings data closer to callers and avoids repeated expensive computations or reads. This cuts tail latency and protects the origin during traffic spikes. Consistency usually becomes weaker or bounded by policy.
Client -> CDN/Edge -> App cache -> DB
Per-node in-process caches and selective replication spread read load. You can also use request coalescing and small response compression to lower network pressure.
Local LRU -> Distributed cache -> DB
Tier one is the browser or app cache with conditional GETs. Tier two is CDN or edge cache close to users to absorb most hits. Tier three is a regional in-memory store like Redis to protect the origin. Each tier has its own TTL and validation policy. Together they cut latency and confine failures. Use ETag or versioned keys so edges can revalidate cheaply and avoid serving stale data after updates.
Client cache -> CDN (max-age=300) -> Redis (TTL 120) -> Service/DB
Balance size, speed, and compatibility. JSON is human-friendly but larger; MessagePack or ProtoBuf are compact and fast. Include versioning to handle schema changes without mass invalidation. Avoid embedding unstable fields like timestamps in cache keys to improve hit rate; keep them in payload if needed.
value: { v:2, data: <binary> } // v is schema versionLinearizability is a strong single-object guarantee: every operation seems to take effect instantaneously between call and return, shared by all clients. It is stricter than sequential consistency.
Put(x=1); later any get(x) returns 1 unless overwritten after
If read quorum R and write quorum W intersect (sum greater than N), at least one replica in the read set has the latest write. That gives strong single-row semantics when paired with versioning.
N=5, W=3, R=3 → 3+3>5 ensures overlap
Bounded staleness offers a tunable bound on how far behind a replica can be. It trades strictness for predictable freshness, useful for geo-reads with SLAs.
Replica lag <= 5 seconds or <= 2 versions
Keep per-item version vectors or last-write-wins timestamps. On heal, merge carts per user by resolving conflicts item-wise: choose higher version, or sum quantities with caps, or surface conflicts to users. Log all merges for audit. Rebuild secondary indexes from the merged truth and invalidate related cache keys. Notify clients to refresh.
merge(item): if vA>vB → pick A; if concurrent → rule: max(qty) or user confirm
Consistent hashing maps keys to a ring so only a fraction of keys remap on topology change, easing resharding. Evenness improves with virtual nodes, but perfect balance is not guaranteed without monitoring.
node slots: N virtual nodes per physical shard on the hash ring
Snowflake-like IDs embed time and shard bits. They are k-sortable per shard and avoid a global sequence bottleneck. Pure UUID v4 distributes well but is not ordered; global sequences create a single hot writer.
id = (timestamp<<22) | (shard<<12) | sequence
Choose tenant_id as the primary partition key so tenant-scoped reads and writes stay on one shard. Within a tenant, derive entity keys from tenant_id to keep locality for joins. For global reports, build asynchronous aggregates or warehouse exports. If some tenants are huge, allow them multiple sub-shards with a tenant hash suffix to avoid hotspots while preserving tenant isolation.
key = tenant_id + ":" + user_id // shard by tenant_id
Token Bucket accrues tokens at a steady rate and spends them per request, so brief spikes are allowed as long as tokens exist. This suits user-facing APIs that need snappy feel during small bursts. Leaky Bucket drains at a fixed pace. It smooths traffic but may queue or drop during spikes. It is common when downstreams demand steady flow.
if(tokens[user]>0){ tokens[user]--; allow(); } else deny();Atomic operations ensure increments and expirations are consistent across nodes. LUA scripts in Redis let you read, decide, and write in one step. Local caches can assist for reads but should not replace a single source of truth for limits.
EVAL token_bucket.lua 1 user:key rate burst now
Multiple users can appear as one IP, punishing good traffic. Mobile networks also change IPs often, breaking fairness. Prefer API keys or authenticated identities and use IP as a secondary signal.
key = userId || apiKey || ipFallback
Use token buckets for short-term control and a separate rolling counter for daily caps. The request must pass both checks. Tokens refill each second; the daily counter is a sliding window or a single counter with TTL aligned to a 24-hour window. Keep limits in a shared store with atomic updates. Expose admin APIs to change tiers, and return headers so clients can back off. Shadow-test new limits before enforcing them to avoid surprising customers.
allow = bucket.allow(req) && dailyCounter.withinLimit(tenant);
Bounded prefetch limits in-flight messages and memory use. Pausing partitions or adding consumers prevents backlog growth and reduces latency spread. Unbounded prefetch and disabled acks cause loss or memory pressure.
prefetch=100; onLag↑ → pause(partition) or addConsumer()
Write domain changes and the outbound event to the same database transaction. A relay process reads the outbox table and publishes to the broker. This avoids dual-write races. It improves reliability when you cannot use distributed transactions.
BEGIN; UPDATE order...; INSERT outbox(event_json); COMMIT;
Track end-to-end latency (produce → consume → side effect), per-partition lag, consumer group rebalances, and DLQ rates. Add cardinality-bounded labels like topic, partition, and consumer group. Propagate a correlation id through events and logs. Sample traces around spikes and retries to pinpoint slow handlers and hotspots.
metrics: lag_seconds, processing_ms, dlq_count, rebalance_count
A cache sits closer to the user or the app to serve frequent data with microsecond to millisecond latency. That improves user-perceived speed. It also absorbs repeat reads so the origin database and services handle less load, which lowers tail latency and cost under spikes.
GET key -> cache hit? return; else read DB, set cache, return
Real workloads often follow Zipf distributions. Policies that prefer recently or frequently used items, like LRU/LFU or TinyLFU, retain high-value keys and deliver better hit rates. FIFO and random ignore access patterns and can evict still-hot items.
policy: TinyLFU admission + LRU eviction
A single-flight guard lets only one worker rebuild a value while others serve stale data or wait briefly. Proactive refresh before expiry plus jitter avoids many keys expiring at once. This keeps origin stable during spikes or cold starts.
if(lock.try(k)){ v=recompute(); cache.set(k,v,ttl+jitter); lock.release(k); }Cache-Control sets TTL and revalidation behavior. ETag or Last-Modified enables conditional requests. Vary declares which request headers are part of the cache key (e.g., Accept-Encoding, Authorization when needed). These controls prevent stale or incorrect variants from being served.
Cache-Control: public, max-age=300, stale-while-revalidate=30 ETag: "ab12" Vary: Accept-Encoding