Write-Through Caching - Learning Module

Loading content...

0/273

Performance Trade-offs

The Price of Consistency

Every engineering decision involves trade-offs. Write-through caching is no exception. In exchange for its strong consistency guarantees, you pay a price measured in milliseconds, reduced throughput, and increased database load.

For some systems, this price is negligible—a few extra milliseconds on writes is invisible to users when the read path is 100x faster. For others, the cost is prohibitive—a high-write-volume system might be bottlenecked by database write capacity.

This page provides a comprehensive analysis of write-through's performance characteristics. You'll learn where the time goes, how to measure the impact, and—critically—how to mitigate the costs while preserving consistency benefits.

What You Will Learn

By the end of this page, you will understand the exact performance costs of write-through caching, be able to benchmark and measure these costs in your system, and know the optimization techniques that can reduce latency and increase throughput without sacrificing consistency.

Latency Analysis

The fundamental performance cost of write-through caching is write latency. Let's break down exactly where time is spent in a write-through operation.

Latency Breakdown:

┌─────────────────────────────────────────────────────────────────────────────┐
│                    WRITE-THROUGH LATENCY ANATOMY                            │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  App → Cache Proxy   │   Proxy → Database   │   Database Processing        │
│  ─────────────────   │   ─────────────────   │   ─────────────────           │
│  Network: 0.1-1ms    │   Network: 0.5-5ms   │   Write: 2-20ms              │
│  Serialization: 0.1ms│   Protocol: 0.1ms     │   Commit: 1-10ms             │
│                      │                       │                               │
│  ────────────────────┼───────────────────────┼───────────────────────────── │
│                      │                       │                               │
│  Database → Proxy    │   Proxy → Cache       │   Cache → App                │
│  ─────────────────   │   ─────────────────   │   ─────────────────           │
│  Network: 0.5-5ms    │   Network: 0.1-1ms   │   Network: 0.1-1ms            │
│  Deserialization: 0.1ms│  Write: 0.2-2ms     │   Response: 0.1ms            │
│                      │                       │                               │
└─────────────────────────────────────────────────────────────────────────────┘

  TOTAL: 5-50ms (typical), 100ms+ (degraded conditions)

Latency Components in Write-Through
Component	Best Case	Typical	Worst Case	Controllable?
Application serialization	0.1ms	0.5ms	5ms	Yes - optimize serialization format
Network to database	0.2ms	1ms	50ms	Partially - co-location, connection pooling
Database write	1ms	5ms	100ms	Partially - indexing, query optimization
Database commit/fsync	0.5ms	2ms	50ms	Limited - hardware dependent
Network to cache	0.1ms	0.5ms	10ms	Yes - co-location
Cache write	0.1ms	0.5ms	5ms	Yes - proper cache sizing
Response to application	0.1ms	0.5ms	5ms	Yes - efficient response handling

Comparing Write Patterns:

To understand the cost, compare write-through to alternatives:

Pattern	Write Latency	Why
Direct DB Write	3-30ms	No cache overhead
Write-Through	5-50ms	DB write + cache write
Write-Back	0.5-2ms	Only cache write; DB async
Cache-Aside Invalidate	3-35ms	DB write + cache delete

Write-through adds 2-20ms compared to direct database writes, primarily due to the cache write operation. This is the "consistency tax."

The 10ms Threshold

Research suggests users perceive responses under 100ms as 'instant' and those under 10ms as 'truly instantaneous.' If your write-through latency is under 50ms, most users won't notice. If it exceeds 200ms, users will perceive sluggishness. Optimize to stay under 50ms for interactive operations.

Throughput Implications

Beyond latency, write-through caching affects the total number of writes your system can handle per second.

Throughput Limiting Factors:

Database Write Capacity
- The database must handle every write synchronously
- No opportunity for batching or coalescing writes
- Database becomes the bottleneck under high write load
Connection Pool Exhaustion
- Each write holds a database connection for the full latency duration
- Pool size limits concurrent writes
- Formula: max_concurrent_writes = pool_size × (1000ms / avg_latency_ms)
- Example: 50 connections × (1000 / 20ms) = 2,500 writes/sec maximum
Cache Write Capacity
- Usually not the bottleneck (caches are fast)
- Can become limiting with very large values or limited cache resources
Network Bandwidth
- Rarely limiting for typical payloads
- Can matter with large objects (images, documents)

throughput_calculator.py
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
class ThroughputCalculator:
    """
    Calculate theoretical and practical write-through throughput limits.
    """
    
    def calculate_theoretical_max(
        self,
        db_connection_pool_size: int,
        avg_write_latency_ms: float,
        cache_write_latency_ms: float = 1.0
    ) -> dict:
        """
        Calculate theoretical maximum throughput.
        
        Args:
            db_connection_pool_size: Size of database connection pool
            avg_write_latency_ms: Average database write latency
            cache_write_latency_ms: Average cache write latency
            
        Returns:
            Dictionary with throughput calculations
        """
        total_latency = avg_write_latency_ms + cache_write_latency_ms
        
        # Maximum writes per second per connection
        writes_per_conn_per_sec = 1000 / total_latency
        
        # Total theoretical throughput
        max_throughput = db_connection_pool_size * writes_per_conn_per_sec
        
        # Practical throughput (accounting for overhead, ~70% efficiency)
        practical_throughput = max_throughput * 0.7
        
        return {
            'total_latency_ms': total_latency,
            'writes_per_connection_per_second': writes_per_conn_per_sec,
            'theoretical_max_writes_per_second': max_throughput,
            'practical_max_writes_per_second': practical_throughput,
            'utilization_at_practical_max': 0.7,
        }
    
    def calculate_required_resources(
        self,
        target_writes_per_second: int,
        avg_write_latency_ms: float,
        safety_factor: float = 1.5
    ) -> dict:
        """
        Calculate resources needed to achieve target throughput.
        """
        # Connections needed (with safety factor)
        connections_needed = int(
            (target_writes_per_second * avg_write_latency_ms / 1000) 
            * safety_factor
        )
        
        # If single DB can't handle it, calculate shards
        max_connections_per_db = 200  # Typical limit
        db_instances_needed = max(1, connections_needed // max_connections_per_db)
        
        return {
            'target_writes_per_second': target_writes_per_second,
            'connections_needed': connections_needed,
            'db_instances_needed': db_instances_needed,
            'connections_per_db': connections_needed // db_instances_needed,
            'safety_factor_applied': safety_factor,
        }
 
# Example usage
calc = ThroughputCalculator()
 
# Scenario: 100 connection pool, 20ms average write, 1ms cache write
result = calc.calculate_theoretical_max(
    db_connection_pool_size=100,
    avg_write_latency_ms=20,
    cache_write_latency_ms=1
)
print(f"Practical max throughput: {result['practical_max_writes_per_second']:.0f} writes/sec")
# Output: Practical max throughput: 3333 writes/sec
 
# What if we need 10,000 writes/sec?
resources = calc.calculate_required_resources(
    target_writes_per_second=10000,
    avg_write_latency_ms=20
)
print(f"Need {resources['db_instances_needed']} DB instances with {resources['connections_per_db']} connections each")

The Write Amplification Problem

Write-through doubles your total write operations: every logical write becomes one database write plus one cache write. At high volumes, this amplification strains both systems. Monitor both database and cache write metrics—either could become saturated.

Database Impact

The database experiences significant impact from write-through caching. Understanding this impact is crucial for capacity planning and optimization.

Negative Database Impacts

•No write buffering — Every write hits DB immediately, no coalescing
•Full write latency exposed — Application waits for complete commit
•Increased connection usage — Connections held for full write cycle
•Replication lag pressure — Synchronous writes can stress replicas
•No traffic shaping — Write bursts hit database directly

Positive Database Impacts

•Read load reduced — Cache handles read traffic
•Consistent write pattern — Predictable, steady write load
•No catch-up storms — Unlike write-back, no batched flushes
•Simpler recovery — No in-flight writes to track
•Clear capacity planning — Write load = application writes

Database Sizing for Write-Through:

To properly size your database for write-through workloads:

Step 1: Measure baseline write latency (no cache, direct writes)
        → Typical: 5-20ms for single-row writes

Step 2: Estimate peak writes per second
        → Consider daily peaks, promotional events, batch processes

Step 3: Calculate required connection pool
        → pool_size = peak_writes_per_sec × avg_latency_sec × safety_factor
        → Example: 1000 writes/sec × 0.015s × 1.5 = 23 connections

Step 4: Verify database can sustain the write load
        → IOPS requirement = writes_per_sec × avg_writes_per_operation
        → CPU requirement: benchmark under load
        → Memory: ensure working set fits

Step 5: Plan for degradation
        → What happens if latency increases to 50ms? 100ms?
        → At what point does the system need to shed load?

Mitigation Strategies for Database Impact:

Connection Pooling Optimization
- Use connection poolers like PgBouncer (PostgreSQL) or ProxySQL (MySQL)
- Transaction-level pooling for maximum efficiency
- Tune pool sizes based on measured latency
Write Optimization
- Batch multiple field updates into single writes
- Use partial updates (UPDATE ... SET field = value) vs full row replacement
- Proper indexing to speed up update key lookups
Hardware/Infrastructure
- NVMe SSDs for fast commit/fsync
- Adequate memory to keep index in RAM
- Low-latency network between app and database

The Read Path Dividend

While write-through penalizes the write path, it provides significant benefits on the read path. Understanding this trade-off is essential for evaluating overall system performance.

Read Path Performance Comparison
Scenario	Without Cache	With Write-Through Cache	Improvement
Cache Hit Read	10-50ms (DB query)	0.5-2ms (cache)	10-50x faster
Cache Hit Rate 90%	Average 10ms	Average 1.5ms	6-7x faster
Cache Hit Rate 95%	Average 10ms	Average 1ms	10x faster
Cache Hit Rate 99%	Average 10ms	Average 0.6ms	16x faster

Calculating the Net Performance Impact:

Most systems have far more reads than writes. The read-to-write ratio determines whether write-through is a net performance win or loss.

performance_calculator.ts
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
interface PerformanceScenario {
  readsPerSecond: number;
  writesPerSecond: number;
  dbReadLatencyMs: number;
  dbWriteLatencyMs: number;
  cacheReadLatencyMs: number;
  cacheWriteLatencyMs: number;
  cacheHitRate: number;
}
 
function calculateNetPerformanceImpact(scenario: PerformanceScenario) {
  const {
    readsPerSecond,
    writesPerSecond,
    dbReadLatencyMs,
    dbWriteLatencyMs,
    cacheReadLatencyMs,
    cacheWriteLatencyMs,
    cacheHitRate,
  } = scenario;
 
  // Without write-through (direct DB)
  const directReadCostPerSec = readsPerSecond * dbReadLatencyMs;
  const directWriteCostPerSec = writesPerSecond * dbWriteLatencyMs;
  const totalDirectCost = directReadCostPerSec + directWriteCostPerSec;
 
  // With write-through
  const cachedReadCost = readsPerSecond * cacheHitRate * cacheReadLatencyMs;
  const cacheMissReadCost = readsPerSecond * (1 - cacheHitRate) * dbReadLatencyMs;
  const writeThroughCost = writesPerSecond * (dbWriteLatencyMs + cacheWriteLatencyMs);
  const totalWriteThroughCost = cachedReadCost + cacheMissReadCost + writeThroughCost;
 
  // Calculate savings
  const latencySavedMs = totalDirectCost - totalWriteThroughCost;
  const improvementPercent = (latencySavedMs / totalDirectCost) * 100;
 
  const readToWriteRatio = readsPerSecond / writesPerSecond;
  const breakEvenHitRate = calculateBreakEvenHitRate(scenario);
 
  return {
    directTotalLatencyMs: totalDirectCost,
    writeThroughTotalLatencyMs: totalWriteThroughCost,
    netLatencySavedMs: latencySavedMs,
    improvementPercent: improvementPercent.toFixed(1) + '%',
    readToWriteRatio,
    isNetPositive: latencySavedMs > 0,
    breakEvenHitRate: (breakEvenHitRate * 100).toFixed(1) + '%',
    recommendation: latencySavedMs > 0 
      ? 'Write-through provides net performance benefit' 
      : 'Consider write-back or cache-aside for this workload',
  };
}
 
function calculateBreakEvenHitRate(scenario: PerformanceScenario): number {
  // At what hit rate does write-through break even?
  // Solve for hitRate where total costs are equal
  const { 
    readsPerSecond, writesPerSecond,
    dbReadLatencyMs, dbWriteLatencyMs,
    cacheReadLatencyMs, cacheWriteLatencyMs,
  } = scenario;
 
  const writePenalty = writesPerSecond * cacheWriteLatencyMs;
  const readSavingsPerPoint = readsPerSecond * (dbReadLatencyMs - cacheReadLatencyMs);
  
  return writePenalty / readSavingsPerPoint;
}
 
// Example: E-commerce product page (high read, low write)
const ecommerceScenario: PerformanceScenario = {
  readsPerSecond: 10000,
  writesPerSecond: 100,       // 100:1 read-to-write ratio
  dbReadLatencyMs: 15,
  dbWriteLatencyMs: 20,
  cacheReadLatencyMs: 1,
  cacheWriteLatencyMs: 2,
  cacheHitRate: 0.95,
};
 
console.log(calculateNetPerformanceImpact(ecommerceScenario));
// Output: { improvementPercent: '93.2%', isNetPositive: true, ... }
 
// Example: High-write analytics (low read, high write)
const analyticsScenario: PerformanceScenario = {
  readsPerSecond: 100,
  writesPerSecond: 10000,     // 1:100 read-to-write ratio
  dbReadLatencyMs: 15,
  dbWriteLatencyMs: 20,
  cacheReadLatencyMs: 1,
  cacheWriteLatencyMs: 2,
  cacheHitRate: 0.95,
};
 
console.log(calculateNetPerformanceImpact(analyticsScenario));
// Output: { improvementPercent: '-9.1%', isNetPositive: false, ... }

The 10:1 Rule of Thumb

Write-through typically provides net performance benefit when your read-to-write ratio exceeds 10:1. Below this ratio, consider write-back (if you can tolerate data loss) or direct database writes (if cache consistency isn't critical).

Optimization Techniques

Even within the write-through model, several techniques can improve performance while maintaining consistency guarantees.

Technique 1: Parallel Cache Write

After the database confirms the write, the cache update can happen asynchronously (fire-and-forget) without waiting for confirmation:

parallel_cache.ts
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// Standard write-through: sequential
async function sequentialWriteThrough(key: string, value: any): Promise<any> {
  const result = await db.write(key, value);  // Wait for DB
  await cache.set(key, result);               // Then wait for cache
  return result;
  // Total latency: DB_latency + cache_latency
}
 
// Optimized: parallel cache update
async function parallelCacheWriteThrough(key: string, value: any): Promise<any> {
  const result = await db.write(key, value);  // Wait for DB
  
  // Fire-and-forget cache update
  cache.set(key, result).catch(err => {
    logger.error('Cache write failed', { key, error: err });
    metrics.increment('cache_write_failures');
  });
  
  return result;
  // Total latency: DB_latency only (cache happens in background)
}
 
// Note: This maintains read-after-write for most cases, but there's a small
// window where immediate reads might hit cache before it's updated.
// Use sequential version for strict read-after-write requirements.

Technique 2: Write Coalescing

For scenarios where multiple updates to the same key occur rapidly, coalesce them:

Without coalescing:
  T0: Write key=A, value=1 → DB write → cache write
  T1: Write key=A, value=2 → DB write → cache write  
  T2: Write key=A, value=3 → DB write → cache write
  Total: 3 DB writes, 3 cache writes

With coalescing (100ms window):
  T0: Write key=A, value=1 → buffer
  T1: Write key=A, value=2 → overwrite buffer
  T2: Write key=A, value=3 → overwrite buffer
  T100: Flush buffer → 1 DB write (value=3) → 1 cache write
  Total: 1 DB write, 1 cache write

Caution: Coalescing trades latency for throughput. Individual writes wait up to the coalescing window. Use only when acceptable.

Technique 3: Selective Write-Through

Not all data needs write-through consistency. Route writes based on data criticality:

selective_write_through.ts
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
type CachingStrategy = 'write-through' | 'write-back' | 'write-around';
 
interface EntityConfig {
  strategy: CachingStrategy;
  ttl: number;
  reason: string;
}
 
const entityConfigs: Record<string, EntityConfig> = {
  // Critical data: use write-through
  'user.balance': {
    strategy: 'write-through',
    ttl: 3600,
    reason: 'Financial data must be immediately consistent',
  },
  'order.status': {
    strategy: 'write-through', 
    ttl: 1800,
    reason: 'Customers need to see order updates immediately',
  },
  
  // Tolerance for staleness: use write-back
  'user.lastSeen': {
    strategy: 'write-back',
    ttl: 300,
    reason: 'High-frequency updates, staleness acceptable',
  },
  'analytics.pageViews': {
    strategy: 'write-back',
    ttl: 60,
    reason: 'Analytics can be eventually consistent',
  },
  
  // Rarely read after write: use write-around  
  'audit.log': {
    strategy: 'write-around',
    ttl: 0,  // No caching
    reason: 'Write-heavy, rarely read, archival data',
  },
};
 
class SmartCacheRouter {
  async write(entity: string, key: string, value: any): Promise<any> {
    const config = entityConfigs[entity] || { strategy: 'write-through', ttl: 3600 };
    
    switch (config.strategy) {
      case 'write-through':
        return this.writeThrough(key, value, config.ttl);
      case 'write-back':
        return this.writeBack(key, value, config.ttl);
      case 'write-around':
        return this.writeAround(key, value);
    }
  }
  
  private async writeThrough(key: string, value: any, ttl: number): Promise<any> {
    const result = await this.db.write(key, value);
    await this.cache.set(key, result, { ttl });
    return result;
  }
  
  private async writeBack(key: string, value: any, ttl: number): Promise<any> {
    await this.cache.set(key, value, { ttl });
    this.flushQueue.enqueue({ key, value });  // Async DB write
    return value;
  }
  
  private async writeAround(key: string, value: any): Promise<any> {
    const result = await this.db.write(key, value);
    // Don't update cache; will be populated on next read if ever
    return result;
  }
}

Technique 4: Optimistic Caching with Versioning

For data that changes infrequently, use optimistic caching with version checks:

1. Cache stores { value, version }
2. On read, check if version is current (quick metadata check)
3. If version matches, return cached value
4. If version differs, fetch fresh data
5. Write-through updates version along with value

This reduces cache write frequency for rarely-changed data while maintaining consistency.

Benchmarking and Monitoring

Performance characteristics vary based on your specific setup. Proper benchmarking and monitoring are essential.

Essential Performance Metrics:

Write-Through Performance Metrics
Metric	What It Tells You	Healthy Range	Action If Unhealthy
write_through_latency_p50	Typical write experience	<30ms	Optimize DB queries, check network
write_through_latency_p99	Worst-case latency	<100ms	Investigate outliers, check resource contention
db_write_latency_p99	Database bottleneck detection	<50ms	DB tuning, indexing, hardware upgrade
cache_write_latency_p99	Cache bottleneck detection	<5ms	Check cache capacity, network
writes_per_second	Current throughput	<80% of max capacity	Scale resources proactively
db_connection_pool_utilization	Connection pool pressure	<70%	Increase pool size or add DB capacity
cache_write_error_rate	Cache reliability	<0.1%	Investigate cache infrastructure

performance_monitor.ts
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
class WriteThroughPerformanceMonitor {
  private histogram: Histogram;
  private counters: Map<string, Counter> = new Map();
 
  async monitoredWriteThrough<T>(
    key: string,
    writeOperation: () => Promise<T>
  ): Promise<T> {
    const overallStart = performance.now();
    let dbLatency = 0;
    let cacheLatency = 0;
 
    try {
      // Database phase
      const dbStart = performance.now();
      const result = await writeOperation();
      dbLatency = performance.now() - dbStart;
      
      // Cache phase
      const cacheStart = performance.now();
      await this.cache.set(key, result);
      cacheLatency = performance.now() - cacheStart;
      
      // Record success metrics
      const totalLatency = performance.now() - overallStart;
      this.recordMetrics({
        status: 'success',
        totalLatency,
        dbLatency,
        cacheLatency,
        key,
      });
      
      return result;
      
    } catch (error) {
      const totalLatency = performance.now() - overallStart;
      this.recordMetrics({
        status: error instanceof DatabaseError ? 'db_failure' : 'cache_failure',
        totalLatency,
        dbLatency,
        cacheLatency,
        key,
      });
      throw error;
    }
  }
 
  private recordMetrics(data: MetricData): void {
    // Histograms for latency distribution
    this.histogram.observe({ operation: 'total' }, data.totalLatency);
    this.histogram.observe({ operation: 'database' }, data.dbLatency);
    this.histogram.observe({ operation: 'cache' }, data.cacheLatency);
    
    // Counters for throughput and errors
    this.getCounter('write_attempts').inc();
    this.getCounter(`write_${data.status}`).inc();
    
    // Log slow operations for investigation
    if (data.totalLatency > 100) {
      this.logger.warn('Slow write-through operation', {
        key: data.key,
        totalLatency: data.totalLatency,
        dbLatency: data.dbLatency,
        cacheLatency: data.cacheLatency,
      });
    }
  }
  
  // Periodic summary report
  reportSummary(): PerformanceSummary {
    return {
      throughput: this.getCounter('write_attempts').get(),
      successRate: this.calculateSuccessRate(),
      latencyP50: this.histogram.getPercentile(50),
      latencyP95: this.histogram.getPercentile(95),
      latencyP99: this.histogram.getPercentile(99),
      dbLatencyP99: this.histogram.getPercentile(99, { operation: 'database' }),
      cacheLatencyP99: this.histogram.getPercentile(99, { operation: 'cache' }),
    };
  }
}

Summary: Performance Trade-offs

We've thoroughly analyzed the performance implications of write-through caching. Let's consolidate the key insights:

Key Takeaways

•Write latency is the primary cost — Expect 5-50ms per write, dominated by database latency
•Throughput is database-bound — Connection pool size × (1/latency) determines max writes/sec
•Read path provides dividends — High cache hit rates dramatically improve overall system performance
•The 10:1 rule — Write-through typically nets positive performance with read-to-write ratios above 10:1
•Optimization is possible — Parallel cache writes, coalescing, and selective strategies can improve performance
•Measurement is essential — Benchmark your specific workload; generic advice may not apply

What's Next:

With a complete understanding of both consistency benefits and performance trade-offs, we're ready to explore use cases—the specific scenarios where write-through caching is the optimal choice, and where you should consider alternatives.

Page Complete

You now understand the performance characteristics of write-through caching in depth—the latency anatomy, throughput limits, optimization techniques, and monitoring practices. This knowledge enables you to make informed decisions about when the consistency benefits justify the performance costs.