++++Caching is the technique of storing frequently accessed data in a faster storage layer (usually in-memory) to reduce data retrieval time.
Caching for Speed & Optimization 🚰
This content is adapted from Mastering System Design from Basics to Cracking Interviews (Udemy). It has been curated and organized for educational purposes on this portfolio. No copyright infringement is intended.
It is a critical component in building low-latency, high-throughput architectures.
🚀 Types of Caching
Caching can be applied at multiple layers of a system's architecture:
- Client-side: Browser memory (localStorage, Service Workers) to avoid network calls.
- Server-side: Application-level memory or in-memory stores like Redis or Memcached.
- CDN Caching: Edge servers (Cloudflare, Akamai) that cache static assets close to the user.
- Database Caching: Materialized views or internal result-set caching.
🛠️ Caching Strategies
How you write data to the cache vs. the database defines your system's consistency and performance.
1. Cache-Aside (Lazy Loading)
The most common strategy. The application checks the cache first; if empty (miss), it fetches from the DB and populates the cache.
- Best for: Read-heavy workloads where data changes infrequently.
2. Write-Through
Data is written to the cache and the database simultaneously.
- Pros: Data is always consistent; cache is always up-to-date.
- Cons: Slower write performance due to dual writes.
3. Write-Back (Write-Behind)
Data is written to the cache immediately, and the database is updated asynchronously later.
- Pros: Extremely fast writes; low latency for write-heavy applications.
- Cons: Risk of data loss if the cache fails before the database persistence completes.
🧹 Cache Eviction Policies
Since memory is expensive and limited, caches must eventually "forget" old data to make room for new data.
- LRU (Least Recently Used): Removes the item that hasn't been accessed for the longest time.
- LFU (Least Frequently Used): Removes the item with the lowest access count.
- FIFO (First-In, First-Out): Removes the oldest item added, regardless of how often it's used.
- TTL (Time To Live): Automatically expires items after a fixed duration (e.g., 1 hour).
🏮 Redis: The Industry Standard
Redis is an open-source, in-memory key-value store used by millions of applications for ultra-fast data access.
- Fast: High-performance read/write operations (microsecond latency).
- Versatile: Supports strings, hashes, lists, sets, and sorted sets.
- Reliable: Supports persistence, replication, and high availability.
Real-World Examples 🏢
- CDNs: Caching static assets (images, JS, CSS) at the edge.
- Product Pages: Caching popular catalog search results to reduce DB load.
- User Sessions: Storing session tokens in Redis for sub-millisecond authentication.
- API Responses: Microservices caching responses to avoid expensive recomputation.
Interview Questions & Answers 💡
1. What is caching and why is it important?
Caching is storing frequently accessed data in a faster layer (like RAM) to minimize latency, reduce database load, and improve system scalability.
- Latency Reduction: Serves data faster than disk-based databases. - Load Reduction: Offloads expensive reads from primary databases. - Throughput Efficiency: Handles more requests by reusing pre-computed results.
2. What are the risks of aggressive caching?
While powerful, caching introduces complexities that must be managed.
- Stale Data: Cached values may be outdated and inconsistent with the database. - Cache Stampede: Multiple requests for uncached data hitting the backend at once. - Memory Overuse: Poor eviction can lead to resource exhaustion and performance degradation.
3. How do you keep the cache and database in sync?
Maintaining consistency between the cache and the source of truth is a core challenge.
- Write-Through: Synchronous updates to both cache and DB. - Cache Invalidation: Explicitly purging records on database updates. - Time-to-Live (TTL): Automatic expiration for self-refreshing data. - Change Data Capture (CDC): Using database logs to trigger cache updates.
4. How can you prevent "Cache Stampedes"?
Cache stampedes occur when a heavily used cache key expires, causing a flood of traffic to the database.
- Locking/Mutexes: Only one request populates the cache while others wait.
- Stale-while-revalidate: Serving slightly outdated data while refreshing in the background. - Jitter in TTLs: Randomizing expiration times to prevent multiple keys from expiring at once.
Final Thoughts
Caching is a double-edged sword: it offers incredible performance gains but introduces the headache of data consistency. Always choose your eviction policy and sync strategy based on your application's read-to-write ratio.
Next up? Deep dive into performance at scale — Performance Measurement: SLAs & SLOs