Click to read full live report and analysis.

# Write-Behind Caching in Go: Async Flush Mechanics, Ordering Hazards, and the Durability Boundary Write-through caching is safe but slow—every write blocks on two stores. Write-behind (also called write-back) pushes the database write off the critical path: you acknowledge to the caller after the cache write, then flush to the database asynchronously. The latency win is real, often 5–20× on write-heavy workloads where MongoDB round-trips dominate. But the durability contract is now probabilistic, and most implementations break silently under the failure modes that actually occur in production. This article covers the mechanics you need to build a production-grade write-behind layer in Go: flush worker design, ordering invariants, failure handling, and where to draw the durability boundary given your SLA. ## What Changes in the Write Path In write-through, the call graph is synchronous: caller → cache.Set(k, v) → db.Upsert(k, v) → ack In write-behind: caller → cache.Set(k, v) → dirty-queue.Enqueue(k, v) → ack ↓ (async) flush-worker → db.Upsert(k, v) The caller sees lower latency. The database sees batched, coalesced writes. The system absorbs burst write load without proportional DB connection pressure. What you lose: any window between the cache write and the flush is a durability gap. A crash or eviction during that window loses data unless you build explicit recovery. ## Dirty Queue Design The dirty queue is the central structure. Its semantics determine everything downstream. **Keyed coalescing** is the first decision. If the same key is written three times before a flush, you only need to write the latest value to the database. A naive FIFO queue produces three DB writes. A keyed map collapses them to one but requires a lock or concurrent map with careful memory ordering. type DirtyEntry struct { Value any DirtyAt time.Time SeqNum uint64 // monotonic, per-key } type DirtyQueue struct { mu sync.Mutex entries map[string]*DirtyEntry seq atomic.Uint64 } func (q *DirtyQueue) Mark(key string, value any) { seq := q.seq.Add(1) q.mu.Lock() q.entries[key] = &DirtyEntry{Value: value, DirtyAt: time.Now(), SeqNum: seq} q.mu.Unlock() } func (q *DirtyQueue) Drain(limit int) map[string]*DirtyEntry { q.mu.Lock() defer q.mu.Unlock() out := make(map[string]*DirtyEntry, min(limit, len(q.entries))) count := 0 for k, v := range q.entries { if count >= limit { break } out[k] = v delete(q.entries, k) count++ } return out } The sequence number matters for a subtle reason: if a flush worker drains a key and then a concurrent `Mark` call re-dirtifies it before the DB write completes, you need to know whether the in-flight value is still current. Compare `SeqNum` at drain time against the sequence at write completion; if a newer write arrived during the flush, re-enqueue rather than considering the key clean. ## Flush Worker Mechanics A single flush goroutine avoids lock contention on the drain path but becomes a bottleneck under high write velocity. A pool of workers requires partitioning by key hash to preserve per-key ordering—two workers racing to flush the same key against MongoDB can produce last-write-wins anomalies that violate your update semantics. func (c *Cache) flushWorker(ctx context.Context, partitionKeys <-chan string) { ticker := time.NewTicker(c.flushInterval) defer ticker.Stop() for { select { case <-ticker.C: batch := c.dirty.Drain(c.batchSize) if len(batch) == 0 { continue } c.flushBatch(ctx, batch) case <-ctx.Done(): // Drain remaining before exit final := c.dirty.Drain(math.MaxInt) c.flushBatch(context.Background(), final) return } } } The `context.Done()` drain is not optional. When your service receives SIGTERM, Kubernetes gives you a grace period (typically 30s). If you skip the final flush, every dirty key in the queue is lost. Most implementations miss this. ## Ordering Hazards Ordering breaks in at least three ways in write-behind systems: **Cross-key ordering.** If write A to key `user:1` causally precedes write B to key `order:99` (e.g., a balance deduction before an order creation), and your flush batches them independently, the database may reflect the order before the balance deduction. A reader hitting the DB directly during the flush window sees an inconsistent state. Mitigation: coerce related keys into the same flush batch by grouping them on a correlation ID, or accept that read-your-writes consistency requires reading from the cache layer, not the DB. **Retry reordering.** When a DB write fails and you retry with exponential backoff, writes that entered the dirty queue after the failed key may flush before the retry succeeds. If the second write depends on the first (a foreign key, a version check), the retry produces a constraint error. Mitigation: per-key retry queues with head-of-line semantics—a failing key blocks its own subsequent writes but not unrelated keys. **Eviction before flush.** Redis under memory pressure evicts keys. If your dirty-queue map lives in-process but the cache value lives in Redis, an eviction loses the value you intended to write. You must either store the value in the dirty queue itself (not just the key reference) or pin dirty keys with a Redis `PERSIST` or TTL extension. Storing the full value in the dirty queue increases heap pressure—a real tradeoff at high write volume. ## Flush Failure and the Durability Boundary A failed flush leaves a key in a limbo state: the cache holds the new value, the database holds a stale value. Your retry policy determines the exposure window. Three strategies: 1. **Requeue on failure.** Re-mark the key as dirty with its current value. Simple, but if the failure is persistent (DB down), the dirty queue grows unbounded. Add a max-retry cap with a dead-letter channel that pages on-call. 2. **Circuit breaker on the flush path.** Wrap the DB write in a circuit breaker. When the breaker opens, stop draining the dirty queue entirely rather than accumulating retry failures. Resume drain when the breaker half-opens. This bounds DB connection exhaustion during an outage. 3. **WAL-backed dirty queue.** Write the dirty entry to an append-only log (a local file, Redis Stream, or SQS queue) before acknowledging the cache write. The flush worker reads from the WAL. Crash recovery replays unacknowledged entries. This is the only approach that provides durable write-behind; everything else accepts data loss on hard failure. The operational cost is a second write per cache mutation—evaluate whether the latency savings still justify write-behind over write-through at that point. ## Batching Strategy and DB Pressure Write-behind's value proposition is batch efficiency. MongoDB's `bulkWrite` with `ordered: false` processes independent writes in parallel server-side. A flush of 200 coalesced writes over one `bulkWrite` call is fundamentally cheaper than 200 individual upserts—fewer round-trips, fewer index writes if updates are coalesced, lower oplog pressure. Batch size is a tuning parameter with a ceiling. A batch of 2000 documents saturates the MongoDB write path and causes latency spikes for concurrent reads. In practice, 50–200 documents per flush at 100–500ms intervals is a reasonable starting range. Measure oplog lag and secondary replication latency as you increase batch size—they reveal when the primary is saturated before connection count does. ## Observability Requirements Write-behind adds invisible lag to your write path. Without instrumentation, a growing dirty queue looks like healthy batching until it becomes a data loss event. Track: * **Dirty queue depth** (gauge): sustained growth indicates flush worker can't keep up. * **Flush latency** (histogram): p99 flush duration against the DB; spikes predict backpressure. * **Keys requeued on failure** (counter): a non-zero rate is an active durability gap. * **Eviction-before-flush events** (counter): requires Redis keyspace notification hooks on eviction of dirty keys—`notify-keyspace-events` with `Ke` flag. * **Coalescing ratio** : `(marks / db-writes)`. A ratio near 1.0 means you're getting no coalescing benefit; reconsider whether write-behind is justified. ## Decision Framework Before adopting write-behind caching: **Accept write-behind when:** * Write volume is high and bursty; DB write latency is the dominant bottleneck. * Data loss of the flush window is tolerable under SLA (e.g., counters, analytics events, session metadata where eventual consistency is acceptable). * You can afford WAL infrastructure for durability or can define an explicit loss boundary in your runbook. **Reject write-behind when:** * Reads hit the DB directly (not the cache); you cannot reason about the consistency window across all readers. * The data is financial, transactional, or carries regulatory durability requirements without WAL. * Your cache eviction policy is aggressive; you will lose dirty values under memory pressure without value-in-queue storage. * You lack observability tooling to detect a silently growing dirty queue. Write-behind is not a drop-in latency optimization. It is a durability tradeoff that requires explicit contracts, failure mode handling, and ongoing observability. Implemented with those constraints in view, it is one of the highest-leverage write optimizations available to a Go backend service under sustained write pressure.

via asphnxma

카페 무드 속 자연스러운 셀카로 일상 공유. (사진=걸그룹 레이턴시 지지원(김지원) 인스타그램) 그룹 LATENCY 지지원(김지원, 26세)이 카페 분위기 속에서 촬영한 사진으로 근황을 전했다. 긴 머리와 캐주얼한 스타일을 살린 셀카로 밝은 모습을 드러냈다.   10월 1일 올라온 게시물에는 실내 테이블에 앉아 카메라를 향해 미소를 짓는 지지원의 모습이 담겼다. 그는 "제로네이트 조와요 I love ZERONATE 본 콘텐츠는 '제로네이트'의 글로벌 브랜딩을 위해 제작되었습니다"라는 글을 남기며 이날 촬영 현장을 소개했다.   카페 무드 속 자연스러운 셀카로 일상 공유. (사진=걸그룹 레이턴시 지지원(김지원) 인스타그램) 사진 속 지지원은 레터링이 새겨진 상의와 아우터를 자연스럽게 매치한 채 한 손으로 머리카락을 넘기며 포즈를 취했다. 따뜻한 조명이 비치는 실내 배경이 어우러져 편안한 일상 장면을 완성했다.   지지원은 2017년 굿데이 EP 1집 'ALL DAY GOOD DAY'로 팀 활동을 시작한 뒤, 2020년 시그니처의 데뷔 리드 싱글 'NUN NU NAN NA'로 다시 한번 걸그룹 멤버로 나서며 이름을 알렸다. 이후 여러 팀을 거치며 활동 영역을 넓힌 그는 2024년 디지털 싱글 '바다 가자'를 내고 솔로 가수로도 정식 출발했다.   솔로 활동에서는 2024년 발표한 'Eternal Time'과 '바다 가자'를 통해 특유의 보컬 톤과 캐릭터를 드러냈다. 2025년에는 첫 솔로곡 'Devil's Jam'을 선보이며 기존 팀 이미지와는 다른 콘셉트를 시도했고, 단독 아티스트로서도 존재감을 보여줬다.   연기와 예능에서도 활발히 움직였다. 2024년 공개된 드라마 '내짝남X날짝남'에서 박서아 역을 맡아 10부작 이야기에 참여했고, '노빠꾸탁재훈' 시즌 2·3, '탁재훈의 압박면접', '피지컬갤러리', '꼰대희', '그냥 조현영' 등 다양한 프로그램에 출연해 유머 감각과 토크 실력으로 시청자와 호흡했다.   특히 '노빠꾸탁재훈' 시즌 3에서는 지하 취조실 콘셉트의 코너에서 공동 MC로 나서 진행을 이끌었다. 게스트로 등장하던 초반과 달리 진행자로서 프로그램의 흐름을 조율하며, 예능 진행 능력까지 인정받는 계기를 만들었다.   지지원은 2026년 1월 8일 걸밴드 LATENCY의 데뷔 싱글 '사랑이었는데'를 통해 기타리스트 겸 보컬로 새로운 활동을 시작했다. LATENCY에서는 희연, 하은, 현진, 세미와 함께 악기 연주와 보컬을 겸하며 밴드 사운드와 무대 퍼포먼스를 선보였고, 기존 걸그룹 경험에 밴드 이미지를 더하며 음악적 폭을 넓혔다.   또한 그는 게임과 방탈출, 보드게임을 즐기는 취향으로도 잘 알려져 있다. 스팀 게임 보유량이 100개를 넘고, '스타듀 밸리' 플레이 시간이 120시간을 돌파한 경험, 150회 이상 방탈출 카페를 찾은 이력 등이 소개돼 팬들 사이에서 대표적인 '게임 덕후'로 꼽힌다. 온라인·오프라인 방탈출과 크라임씬 게임, 팬 굿즈를 직접 기획·제작해 선물하는 등 팬들을 위한 체험형 콘텐츠 제작에도 적극적이다.   한편, 지지원은 2026년 LATENCY 데뷔 싱글 '사랑이었는데'를 선보인 이후에도 솔로곡 'Devil's Jam'을 비롯한 개인 음악 활동과 예능·웹 콘텐츠 출연을 통해 다채로운 행보를 이어가고 있다. 팀 활동과 솔로 프로젝트를 병행해 온 경험을 바탕으로, 기타 연주와 보컬, 진행 능력을 두루 갖춘 아티스트로서 앞으로의 행보에 관심이 모이고 있다.