Queues, Streams, Eventing
SQS visibility timeout, DLQ, and the outbox pattern
A DLQ silently accumulated 50,000 messages over three days while the on-call team watched a different dashboard. All of them were one-off edge-case orders that needed human review. When they finally ran redrive-all without a rate limit, the source queue received 50,000 messages in one second and the downstream service went down.
SQS visibility timeout mechanics
SQS does not have an acknowledge/reject RPC. Instead, it uses a visibility timeout. When a consumer receives a message, SQS records:
- A per-message timestamp
- The consumer’s receipt handle (a unique token for this delivery)
For the duration of the visibility timeout, no other consumer can receive the message. If the consumer calls DeleteMessage with the matching receipt handle before the timeout, the message is gone. If the timeout fires first, the message becomes visible to all consumers again — at-least-once delivery.
Key pitfall: visibility timeout resets to the queue default on each redelivery, not to whatever value you set via ChangeMessageVisibility on the previous delivery. If your normal path extends to 90s but the queue default is 30s, every redelivered message starts with 30s and may expire again before your slow consumer finishes.
Rule of thumb: queue default visibility = 6x average processing time.
The heartbeat pattern for variable processing times
For consumers with processing times that vary widely (1s to 5 minutes depending on payload), the heartbeat pattern decouples the queue timeout from worst-case processing:
- When the consumer receives a message, start a background heartbeat thread.
- Every
visibility_timeout / 3seconds, callChangeMessageVisibility(receipt_handle, new_timeout). - If the consumer crashes, heartbeats stop. The timeout expires naturally. The broker redelivers.
- If the consumer finishes, cancel the heartbeat and
DeleteMessage.
This means the queue default only needs to cover the time between ReceiveMessage and the first heartbeat — not the entire processing time. The heartbeat also detects deadlocked consumers: if the processing thread is stuck (not crashed), heartbeats stop eventually anyway, and a different worker recovers the message.
Dead-letter queues and redrive discipline
Without a DLQ, a poison-pill message — a payload that consistently crashes the consumer due to a bug or malformed data — blocks the queue forever. SQS redelivers it indefinitely, burning resources and preventing progress.
The DLQ is a separate queue where SQS moves messages after maxReceiveCount failed delivery attempts:
- Recommended maxReceiveCount: 5–10. Setting it to 1 or 2 sends transient failures (flaky downstream, brief DB timeout) to DLQ immediately — almost everything looks like a poison pill. Setting it too high means thrashing on real poison pills for a long time.
- DLQ retention: up to 14 days (SQS maximum). Messages older than retention are lost permanently.
The outbox pattern: producer-side reliability
Even publishing a message to the broker is at-least-once: the producer may retry on timeout and the broker receives two copies. Worse, the dual-write problem: the application updates the DB and publishes a message as one logical operation. If the DB commits but the broker publish fails, the broker never sees the event. Silent data loss.
The outbox pattern fixes this with a transactional outbox table:
- In the same DB transaction as the business update, INSERT a row into an
outboxtable:(id, payload, status='pending'). - COMMIT: both the business update and the outbox row succeed atomically, or both roll back.
- A separate Outbox Sender reads pending rows and publishes them to the broker. On success, marks the row
status='sent'. - If the sender crashes after publish but before marking sent, the row stays pending. Next sender run re-publishes (duplicate), but the broker’s idempotent producer or consumer dedup handles it.
The CDC-based variant (Debezium reads the DB transaction log) is the modern form — no polling loop, lower latency, and works as long as the DB is online.
An SQS consumer calls ChangeMessageVisibility to extend to 90s during processing. The consumer then crashes. When does SQS redeliver the message?
An application updates a Postgres row and publishes a Kafka message in two separate operations. The DB commit succeeds but Kafka publish fails. What data state exists?
Order the steps of the outbox pattern for reliable event publishing:
- 1 Application receives request to update order status
- 2 BEGIN DB transaction
- 3 UPDATE orders SET status='paid' WHERE id=123
- 4 INSERT INTO outbox (payload='{order_paid, id:123}', status='pending')
- 5 COMMIT — both update and outbox row committed atomically
- 6 Outbox Sender reads pending row and publishes to Kafka
- 7 Outbox Sender marks row status='sent'
- 01What happens to the visibility timeout value on SQS message redelivery?
- 02What is the recommended maxReceiveCount for a production SQS DLQ and why not 1?
- 03What is the dual-write problem and how does the outbox pattern solve it?
SQS visibility timeout is a per-message timer that resets to the queue default on each redelivery — set it to 6x average processing time, and use ChangeMessageVisibility heartbeats (every timeout/3 seconds) for variable workloads. Dead-letter queues quarantine poison pills after maxReceiveCount failures (use 5–10, not 1); redrive with a rate limit of 1–10 msgs/s to avoid stampeding the source queue. The outbox pattern solves the producer-side dual-write problem by INSERTing an event row in the same DB transaction as the business update — the row is the durable intent; a separate sender publishes from it, and any publish failure is retried from the still-pending row without losing the event.
appears again in178
- Why GraphQL gets N+1junior
- DataLoader mechanics: tick-boundary batchingmiddle
- Batch function contracts: ordering, shapes, errorsmiddle
- Federation and lookahead: batching beyond DataLoadermiddle
- Query complexity defences: depth, cost, persisted queriesmiddle
- Senior GraphQL API: scheduling contract, tenant isolation, observabilitysenior
- Why idempotency: making retries safejunior
- Server-side state machine: four states of an idempotency keymiddle
- Outbox and inbox: effectively-once across the dual-write boundarymiddle
- Concurrency and cache architecture for idempotency at scalesenior
- Observability, production failures, and global-scale designsenior
- The event loop: one thread, three queuesjunior
- Tasks, microtasks, and scheduler.yield()middle
- Microtask starvation, Long Tasks, and LoAFsenior
- Node.js event loop: phases, nextTick, and loop lagsenior
- React, Vue, and INP observability in productionsenior
- The render pipeline: six stages from bytes to pixelsjunior
- Stage costs and the renderer process modelmiddle
- Invalidation, dirty bits, and containmiddle
- Compositor layers: promotion, overlap, and GPU memorymiddle
- DevTools flame strip and the frame lifecyclemiddle
- Layout thrash: forced synchronous layoutsenior
- BeginMainFrame, compositor-driven animations, and GPU memorysenior
- Production observability: LoAF, INP, and the full attack surfacesenior
- What V8 is and why performance varies 100×junior
- V8''''s four-tier JIT pipeline and profile-guided tieringmiddle
- Hidden classes, transition trees, and memory layoutmiddle
- Inline caches, IC states, and deoptimizationmiddle
- Orinoco GC: parallel scavenger, concurrent marking, and write barriersmiddle
- TurboFan''''s speculative engine and the deopt-loop trapsenior
- V8 in production: isolates, pointer compression, and real failuressenior
- Service worker lifecycle and cache strategiesmiddle
- Service worker edge cases: version skew, durability, and navigation trapssenior
- What the reconciler does: render vs commitjunior
- The fiber object and the double-buffer treemiddle
- Render phase purity and commit phase sub-stepsmiddle
- Reconciliation: diffing heuristics and the key trapmiddle
- Priority lanes, time-slicing, and useTransitionmiddle
- Bailout, memoisation, and tearingsenior
- React Profiler, the Compiler, and production observabilitysenior
- Rendering strategies: SSG, SSR, ISR, streaming, and hydrationjunior
- SSG, SSR, ISR, streaming, and RSC — how each worksmiddle
- Hydration cost: selective, progressive, islands, resumabilitymiddle
- Hydration mismatch: causes, detection, and the determinism rulesenior
- RSC, per-route strategy, and production observabilitysenior
- Core Web Vitals: what LCP, INP, and CLS measurejunior
- CLS: why layout shifts happen and how to stop themmiddle
- Metric tradeoffs, RUM attribution, and the CI+field loopsenior
- The full picture: URL to LCP to INP as a relay racejunior
- Eight layers traced: from the service worker to the second navigationmiddle
- Five canonical breaks: where production reliably diessenior
- The three-track method: reading traces and building a monitored systemsenior
- What is a cache stampede and why it makes things worsejunior
- Lock and single-flight: bounding concurrent rebuildsmiddle
- XFetch: coordination-free probabilistic early expirationmiddle
- Stale-while-revalidate and CDN request coalescingmiddle
- Detecting stampedes and designing TTL for productionmiddle
- Metastable failure, fencing tokens, and production postmortemssenior
- What a relation is: tables, rows, keys, and constraintsjunior
- Constraints, keys, and Postgres data typesmiddle
- Normal forms, denormalization, and why schemas stickmiddle
- JSONB, arrays, and when a side table winsmiddle
- Heap storage, TOAST, and column alignmentsenior
- Schema integrity: deferral, versioning, and production failure modessenior
- Relational vs document, wide-column, graph, and key-valuesenior
- Index-only scans, the Visibility Map, and INCLUDEsenior
- Production failure modes and the index audit playbooksenior
- pg_statistic, ANALYZE, and production observabilitymiddle
- Production failure modes and plan stabilitysenior
- MVCC: why readers and writers never wait for each otherjunior
- Row versions and snapshots: the on-disk mechanicsmiddle
- HOT updates and isolation levels: what you gain and what you paymiddle
- Vacuum and bloat: keeping the storage tax boundedmiddle
- CLOG, XID wraparound, and MultiXact: deep visibility internalssenior
- SSI internals and production autovacuum tuningsenior
- Real-world MVCC failures, deployment patterns, and distributed snapshotssenior
- Connection pools: amortising the cost of a Postgres backendjunior
- PgBouncer session, transaction, and statement modesmiddle
- Pool sizing: the (cores × 2) + spindles formula and the two-layer stackmiddle
- Pool exhaustion and idle-in-transaction: the 3 AM failure modemiddle
- Migrating to transaction mode: rollout playbook and PgBouncer 1.21 prepared statementsmiddle
- The Postgres process model and why raising max_connections degrades throughputsenior
- Pooler landscape 2026, serverless connection storms, and the full failure-mode taxonomysenior
- What a schema migration is and why it replaces ad-hoc DDLjunior
- ADD COLUMN: instant in PG 11+ vs rewrite in older Postgresjunior
- The lock-queue failure mode: why instant DDL can freeze the databasemiddle
- Safe DDL patterns: NOT VALID, CONCURRENTLY, and unsafe-op fixesmiddle
- Expand-contract: zero-downtime for breaking schema changesmiddle
- Advisory locks, migration tools, and deploy coordinationsenior
- Migration failure taxonomy and production disciplinesenior
- Why sharding exists: the single-Postgres ceilingjunior
- Shard-key selection: hash, range, list, and directory strategiesmiddle
- Partitioning vs sharding: same word, two different thingsmiddle
- Co-location and Citus: the invariant that makes sharding usablemiddle
- The hot-shard failure mode: detection, isolation, and durable policymiddle
- Schema-based sharding and multi-tenancy alternativessenior
- Online resharding, 2PC, and the operational cost of shardingsenior
- The seven acts: from CREATE TABLE to Citusjunior
- Acts 1–3 in depth: schema, indexes, and planner statisticsmiddle
- Acts 4–6 in depth: MVCC bloat, connection pooling, and safe migrationsmiddle
- Act 7 in depth: sharding, co-location, and the seven-tier tradeoff cascademiddle
- Observability, anti-patterns, and production triagesenior
- Raft roles, terms, and why majority quorums prevent split brainjunior
- How Raft replicates a log entry and decides it is safe to commitmiddle
- Raft leader election: timeouts, voting rules, and the four safety propertiesmiddle
- Raft in the real world: partitions, slow disks, and client routingmiddle
- Raft extensions: pre-vote, learners, snapshots, and linearizable readssenior
- Raft in production: membership changes, Multi-Raft, and observabilitysenior
- Where data fetching happens — and why it decides LCPjunior
- Fetch waterfalls — diagnosis and the Promise.all curemiddle
- React Server Components and Suspense streamingmiddle
- Client-side cache: TanStack Query, SWR, and stale-while-revalidatemiddle
- LCP, prefetch, and race conditions in interactive fetchingmiddle
- Senior internals: RSC payload, caching layers, and production failure modessenior
- The three-way handshakejunior
- Sequence numbers and connection statemiddle
- DNS: what it does and why it existsjunior
- The resolver walk: referrals, record types, and gluemiddle
- TTL, caching, and DNS propagationmiddle
- The 1-RTT handshake: key shares and ECDHEmiddle
- Session resumption and 0-RTTmiddle
- WebSocket: the HTTP upgrade handshakejunior
- WebSocket frame format: opcodes, masking, fragmentationmiddle
- WebSocket backpressure: when clients can''''t keep upmiddle
- Reconnection: jittered backoff, thundering herd, message resumptionsenior
- WebSocket at scale: HTTP/2 multiplexing, permessage-deflate, C10Msenior
- WebSocket in production: proxies, security, and distributed architecturesenior
- What reverse proxies dojunior
- Health checks, connection draining, and slow startmiddle
- Session affinity, consistent hashing, and the right fixmiddle
- Retry storms, circuit breakers, and load sheddingsenior
- Resilient LB architecture: anycast, zone-aware routing, and observabilitysenior
- Why QUIC and not TCP+TLSjunior
- Connection IDs and network migrationmiddle
- 0-RTT resumption and packet encryptionsenior
- DDoS: what it is and why it worksjunior
- Amplification attacks and state exhaustionmiddle
- Rate limiting: algorithms and architecturemiddle
- WAFs, firewalls, mTLS, and HSTSmiddle
- DNS cache poisoning and BGP hijackingsenior
- Defense-in-depth architecture and attack economicssenior
- DNS, TCP, TLS in sequence: where the milliseconds gomiddle
- Proxy intercepts and security gates: rate limiters, WAF, mTLSmiddle
- Alternate paths: QUIC 0-RTT, WebSocket upgrade, connection migrationmiddle
- Observability: distributed traces, USE/RED, and samplingsenior
- Resilience: cascading retries, circuit breakers, and error budgetssenior
- What the three signals are: logs, metrics, and tracesjunior
- Why structured logs exist: the diary vs the spreadsheetjunior
- The production log schema: fields every line must carrymiddle
- PII redaction and log injectionsenior
- OTel Logs Data Model and audit logs as a subsystemsenior
- SLI, SLO, and the error budget: reliability by the numbersjunior
- Error budget policy, latency SLOs, and composite journeysmiddle
- Production SLO failures, self-observability, security, and the big picturesenior
- The incident loop: from pager to postmortem to preventionmiddle
- Cache lines, struct layout, and false sharingmiddle
- SIMD, SoA vs AoS, and memory bandwidthmiddle
- Cache-oblivious algorithms, PGO, and production failuressenior
- GC in production: observability, security, edge cases, and fleet governancesenior
- Batching: amortize fixed cost per operationjunior
- The batching window: size and wait timemiddle
- Batching in Kafka and Postgresmiddle
- io_uring and observability of batchingmiddle
- From Nagle to io_uring: evolution of batchingmiddle
- Backpressure, failure isolation, and batch security in productionsenior
- CI enforcement and RUM: making budgets stickmiddle
- V8 JIT pipeline, HTTP priorities, and bundle securitysenior
- The performance loop: discipline, not a projectjunior
- Classify and fix: matching bottleneck families to remediesmiddle
- Observability stack and CI gates: catching regressions before they shipmiddle
- Incident to enforcement: SLO burn to verified fix in 35 minutesmiddle
- Culture, economics, and org-scale performancesenior
- What OAuth is and why passwords are not the answerjunior
- Authorization code flow with PKCEmiddle
- ID token validation and JWKS cache managementmiddle
- Refresh token rotation and scope-based least privilegemiddle
- Sender-constrained tokens: DPoP and mTLSsenior
- OAuth in production: audience attacks, observability, and real failuressenior