Write-Behind

How Write-Behind Works

Write-Behind (also called Write-Back) writes to cache immediately and asynchronously persists to the database.

Flow Diagram

Write-Behind Flow:

App → Write to Cache → Return Success (immediate)
                         ↓
              [Background] → Batch write to DB

Fast writes, eventual persistence!

Implementation

class WriteBehindCache:
    def __init__(self, cache_client, db_client):
        self.cache = cache_client
        self.db = db_client
        self.write_queue = Queue()
        self.start_background_writer()
    
    def set(self, key, value, ttl=3600):
        """Write-behind: write to cache immediately, queue DB write"""
        # Write to cache (fast)
        self.cache.set(key, value, ttl)
        
        # Queue database write (async)
        self.write_queue.put({'key': key, 'value': value})
        
        return True  # Return immediately
    
    def start_background_writer(self):
        """Background thread to persist queued writes"""
        def writer():
            while True:
                batch = []
                # Collect batch of writes
                while not self.write_queue.empty() and len(batch) < 100:
                    batch.append(self.write_queue.get())
                
                if batch:
                    # Batch write to database
                    self.db.batch_upsert(batch)
                
                time.sleep(0.1)  # Small delay between batches
        
        thread = threading.Thread(target=writer, daemon=True)
        thread.start()

Characteristics

1. Immediate cache write (fast response)
2. Async database persistence
3. Batch writes for efficiency
4. Eventual consistency with database

Async Persistence in Write-Behind

Persistence Strategies

Strategy Options:

1. Immediate Async:
   Write to cache → Queue for immediate DB write
   Pros: Low latency, simple
   Cons: Many small DB writes

2. Batched Async:
   Write to cache → Batch queue → Periodic DB write
   Pros: Efficient DB writes
   Cons: More data at risk

3. Time-Based Flush:
   Write to cache → Flush every N seconds
   Pros: Predictable DB load
   Cons: Fixed interval may not be optimal

Batch Implementation

class BatchedWriteBehind:
    def __init__(self, cache, db, batch_size=100, flush_interval=1.0):
        self.cache = cache
        self.db = db
        self.batch_size = batch_size
        self.flush_interval = flush_interval
        self.buffer = []
        self.lock = threading.Lock()
    
    def set(self, key, value, ttl=3600):
        # Immediate cache write
        self.cache.set(key, value, ttl)
        
        # Buffer for batch DB write
        with self.lock:
            self.buffer.append({'key': key, 'value': value})
            if len(self.buffer) >= self.batch_size:
                self.flush()
    
    def flush(self):
        """Flush buffer to database"""
        with self.lock:
            if self.buffer:
                self.db.batch_upsert(self.buffer)
                self.buffer = []

Durability Considerations

• WAL (Write-Ahead Log): Persist to disk before acknowledging
• Replication: Replicate cache to multiple nodes
• Checkpointing: Periodic full snapshots to DB
• Recovery: Rebuild cache from DB on failure

Risk Management in Write-Behind

Data Loss Scenarios

Risk Analysis:

1. Cache Failure:
   - Risk: Unpersisted writes lost
   - Mitigation: WAL, replication, short flush intervals

2. DB Failure:
   - Risk: Writes pile up in queue
   - Mitigation: Overflow to disk, circuit breaker

3. Process Crash:
   - Risk: In-memory buffer lost
   - Mitigation: Persistent queue, WAL

4. Network Partition:
   - Risk: Can't reach DB
   - Mitigation: Local persistence, retry with backoff

Safety Implementation

class SafeWriteBehind:
    def __init__(self, cache, db, wal_path='/data/wal'):
        self.cache = cache
        self.db = db
        self.wal = WriteAheadLog(wal_path)
    
    def set(self, key, value, ttl=3600):
        # 1. Write to WAL first (durability)
        self.wal.append({'op': 'set', 'key': key, 'value': value})
        
        # 2. Write to cache (performance)
        self.cache.set(key, value, ttl)
        
        # 3. Queue DB write (async)
        self.queue.put({'key': key, 'value': value})
    
    def recover(self):
        """Recover from WAL after crash"""
        pending = self.wal.replay()
        for entry in pending:
            self.cache.set(entry['key'], entry['value'])
            self.queue.put(entry)

When to Use Write-Behind

Good for:

• High write throughput requirements
• Write-heavy workloads
• When slight data loss is acceptable
• Analytics and logging
• Session storage

Not ideal for:

• Financial transactions
• Critical data requiring strong consistency
• Low-latency write requirements
• Systems that can't tolerate data loss