Caching Patterns: Write-Through, Write-Back, and Cache-Aside

Introduction

Caching is an architectural decision that changes consistency, latency, and failure behavior. The three most common patterns are write-through, write-back, and cache-aside. Each pattern has distinct tradeoffs that must align with your data consistency requirements.

Write-Through Cache

Writes go to the cache and the database synchronously. Reads are always served from the cache.

Advantages

• Strong consistency between cache and database
• Predictable reads

Disadvantages

• Higher write latency
• Cache becomes a critical dependency

public async Task UpdateOrderAsync(Order order)
{
    _dbContext.Orders.Update(order);
    await _dbContext.SaveChangesAsync();
    await _redis.StringSetAsync(CacheKey(order.Id), JsonSerializer.Serialize(order));
}

Write-Back (Write-Behind) Cache

Writes go to the cache first and are asynchronously flushed to the database.

Advantages

• Low write latency
• Batch writes reduce database load

Disadvantages

• Risk of data loss if cache fails
• Requires durable queue or background worker

public async Task UpdateOrderAsync(Order order)
{
    await _redis.StringSetAsync(CacheKey(order.Id), JsonSerializer.Serialize(order));
    await _queue.PublishAsync(new PersistOrderMessage(order));
}

Cache-Aside (Lazy Loading)

The application reads from the cache, and on a miss it loads from the database and populates the cache.

Advantages

• Simple to implement
• Cache is optional on reads

Disadvantages

• Cache stampede risk
• Data can become stale without invalidation

public async Task<Order> GetOrderAsync(long orderId)
{
    var cached = await _redis.StringGetAsync(CacheKey(orderId));
    if (cached.HasValue)
    {
        return JsonSerializer.Deserialize<Order>(cached);
    }

    var order = await _dbContext.Orders.FindAsync(orderId);
    if (order != null)
    {
        await _redis.StringSetAsync(CacheKey(orderId), JsonSerializer.Serialize(order), TimeSpan.FromMinutes(10));
    }

    return order;
}

Choosing the Right Pattern

• Write-through for data that must be consistent across reads.
• Write-back for high write throughput with eventual consistency.
• Cache-aside for read-heavy workloads with tolerable staleness.

Best Practices

• Use TTLs to prevent unbounded growth.
• Add cache stampede protection with distributed locks.
• Monitor cache hit ratio and eviction rates.

Conclusion

Caching patterns are not interchangeable. Map the pattern to your consistency requirements first, then validate with load testing to ensure the desired latency gains.