Lead with proposals, not questions.
Only those whose answer changes the design; decide everything else and move on.
An unbounded FIFO queue of waiting users plus a pool of admission permits, both in Redis.
Consistent hashing: hash a stable id, such as the client’s, onto the ring of servers, so a client keeps reaching the server that holds its state.
Index, scale out, cache.
Polling, long polling, SSE and WebSockets, from simplest up; WebRTC for peer to peer.
A device token per install: Apple’s APNs and Google’s FCM address the app on each device by its token.
Off the critical path, whenever possible.
Orchestration for complex flows: a workflow execution engine such as Temporal, Camunda or AWS Step Functions drives each step.
A global sequence in Postgres, with each id encoded in Base62 (0–9, a–z, A–Z).
Separate it from the write path and scale it on its own.
Use an ACID database and keep the current max bid on the auction row.
Server-Sent Events (SSE) for bid updates.
Put a message queue in front of bid processing.
Isolate the priority tiers from end to end.
A token bucket per client, kept in Redis as two values: tokens and last_refill.
Each node sits at hash(node_id), for example hash("10.0.0.5:6379"), on a ring spanning the hash’s range: 2^32 positions for a 32-bit hash.
To space the nodes out more evenly: each node is placed many times, at hash(node_A#001), hash(node_A#002) and so on.
Hash the key with the same function, then binary-search the sorted node positions for the first node at or after it, wrapping round to the start.
a=3, b=55, c=99 and hash(value) = 42 give node b.It depends on what the nodes hold, and approaches differ.
A key so popular, such as a viral post or a Taylor Swift event, that the one shard it maps to is overloaded, even with consistent hashing.
swift#01 to swift#09, which the mapping f(id) = node spreads across shards.f('swift#01') = node_a, f('swift#02') = node_d.Reads get more expensive: they must read every suffix, #01 to #09, and aggregate the results.
From shared config in etcd or ZooKeeper, for example swift: {version: 1, buckets: 9}.
EventSource opens one long-lived HTTP GET to a stream endpoint; the server keeps the response open and pushes events down it.
const s = new EventSource(\n '/videos/123/comments/stream');\ns.onmessage = (e) =>\n renderComment(JSON.parse(e.data));\nThe expected answer today is TLS everywhere, re-encrypted at each hop:
Handshakes are the costly part, and clients open huge numbers of short connections.
An ALB always terminates TLS; an NLB can do either.
A web application firewall filters HTTP requests at the edge.
A load balancer moves traffic; a gateway enforces policy. Use one when:
When there’s no policy to enforce: load balancer traffic costs a fraction of gateway traffic.
About 23 bytes of header per row, padded to 24, plus a 4-byte pointer to the row: roughly 28 bytes.
timestamp.With its built-in table partitioning: one logical table is split into child tables by time range.
It runs one OS process per connection, and each one uses a few MB of memory.
A database does useful work on only about 2–4 queries per CPU core at a time.
Use the built-in full-text search, not LIKE, in three steps:
tsvector column, generated and stored.@@ and a tsquery.tsvector column for full-text search?","answerHtml":"A stored generated column; name the text search configuration, since the expression must be immutable:
ALTER TABLE articles ADD COLUMN search_vector\n tsvector GENERATED ALWAYS AS\n (to_tsvector('english', content)) STORED;\ntsvector column in Postgres?","answerHtml":"A GIN index on the column, then match with @@ against a query in the same configuration:
CREATE INDEX articles_search_idx\n ON articles USING GIN (search_vector);\n\nSELECT content FROM articles\nWHERE search_vector @@\n plainto_tsquery('english', 'foo bar');\nOne leader plus read replicas, with synchronous replication to at least one replica, so failover doesn’t lose acknowledged writes.
synchronous_standby_names = 'ANY 1 (s1, s2)': each commit waits until s1 or s2 confirms it.Two things: losing acknowledged writes, and split brain.
A client always sees its own earlier writes, and nothing more.
Keep a strongly consistent view of the leader in etcd (for example via Patroni), and make sure an old leader can’t write.
INSERT skip rows that would break a unique constraint?","answerHtml":"ON CONFLICT DO NOTHING: rows that would conflict are skipped silently.
ON CONFLICT ON CONSTRAINT constraint_x, or its columns, ON CONFLICT (col).CHECK, foreign key and NOT NULL violations still raise errors.INSERT?","answerHtml":"Add RETURNING: by default an INSERT returns no rows.
INSERT ... RETURNING id, col_foo, col_bar returns those columns from each inserted row.Set the level per transaction; the others keep the default (Read Committed in Postgres).
BEGIN ISOLATION LEVEL SERIALIZABLE;SET TRANSACTION ISOLATION LEVEL SERIALIZABLE; as the transaction’s first statement.Receive → process → delete; a received message stays hidden from other workers for its visibility timeout (30 s by default).
maxReceiveCount receives.Retention is a per-queue setting: 4 days by default, from 1 minute up to 14 days.
Long-poll in batches, then call again straight away.
Natively, in batches: for example “wait for 500 messages or 1 s, whichever comes first”.
Set a per-message delay, DelaySeconds: the message stays hidden until it’s due.
Kinesis: 24 hours by default, up to 365 days; retention beyond 24 hours costs extra.
Kinesis replicates every record synchronously across 3 availability zones.
broker.rack); default.replication.factor defaults to 1.Single-threaded: one command at a time, in order, each taking microseconds.
Tens to low hundreds of millions of keys per node.
Add a replica, and Sentinel for automated failover.
A single node, a primary with replicas (plus Sentinel for failover), or a cluster.
Every key hashes to one of 16,384 hash slots, and each slot is assigned to a node.
MOVED reply pointing at the right one.Use a hash tag: only the part of the key in {braces} is hashed.
{user:123}:posts and {user:123}:likes hash to the same slot, so they live on the same node.object-type:id:field, for example user:1001:profile, session:abc123 or rate:api:user:1001.
v2:user:1001.Nothing is evicted. The default policy is noeviction: once maxmemory is reached, writes fail with an OOM error; reads still work.
maxmemory defaults to 0 (no limit), so set one.allkeys-lru (or allkeys-lfu).volatile-lru: LRU among keys with a TTL.So that keys written together don’t all expire together.
SET seat:42 <token> NX EX 60: an atomic set-if-absent with a TTL.
NX sets the key only if it doesn’t exist yet, so only one client gets the lock.EX 60 expires the key after 60 s, so a crashed holder can’t keep it forever.DELEX seat:42 IFEQ <token> (Redis 8.4+) or a Lua script.Locks, rate limiting, leaderboards, geospatial search, event sourcing and Pub/Sub.
Subscribing and unsubscribing are instant and cheap: tens of thousands of channels per server and millions in total are fine.
SPUBLISH, Redis 7.0+) keeps each channel within its shard.WAIT only improves durability; a network partition can still cause split brain.
Acquire locks in one globally sorted order.
Write only if a value you read hasn’t changed since, checked in the same atomic step as the write.
UPDATE ... SET ..., version = 8 WHERE id = 1 AND version = 7.