🧠 What is Caching?

Simple Definition

Caching is storing expensive-to-compute results so you can reuse them later. Instead of doing the same work repeatedly, you save the result and reuse it when needed.

Real-World Example

Think of a restaurant kitchen:

• Without Caching: Chef starts from scratch for every order
• With Caching: Chef prepares popular ingredients in advance

In Web Applications

• Database Queries: Store query results instead of hitting database repeatedly
• API Responses: Cache external API calls for faster responses
• Computed Results: Store expensive calculations for reuse
• Session Data: Cache user sessions and preferences

Why Caching Matters

• Speed: 10-100x faster responses
• Efficiency: Reduces CPU and database load
• Scalability: Handle more users with same hardware
• Cost: Lower hosting costs

What to Cache vs What NOT to Cache

🚀 Node.js Caching Basics

What Node.js Provides

Node.js doesn’t come with built-in caching, but it has excellent ecosystem support. You can use in-memory caching, Redis, or other cache stores.

Cache Stores

Basic Setup

// Install Redis client
npm install redis

// Install memory cache
npm install node-cache

// Install Express cache middleware
npm install express-cache-controller

Quick Examples

// Memory caching
const NodeCache = require('node-cache');
const cache = new NodeCache({ stdTTL: 600 }); // 10 minutes default

// Simple cache usage
const getUser = async (id) => {
  const cacheKey = `user:${id}`;
  let user = cache.get(cacheKey);
  
  if (!user) {
    user = await db.users.findById(id);
    cache.set(cacheKey, user, 3600); // Cache for 1 hour
  }
  
  return user;
};

// Redis caching
const redis = require('redis');
const client = redis.createClient();

const getProducts = async () => {
  const cacheKey = 'products:all';
  let products = await client.get(cacheKey);
  
  if (!products) {
    products = await db.products.findAll();
    await client.setex(cacheKey, 3600, JSON.stringify(products));
  }
  
  return JSON.parse(products);
};

Key Concepts

• Cache Keys: user:123 or products:featured
• TTL (Time To Live): 3600 seconds – Cache expires after 1 hour
• Manual Delete: cache.del("key") – Delete specific cache
• Clear All: cache.flushAll() – Delete all cache

💾 Memory Caching

What is Memory Caching?

Memory caching stores data in your application’s RAM. It’s the fastest type of caching but data is lost when the server restarts. Perfect for development and simple applications.

Basic Setup

const NodeCache = require('node-cache');

// Create cache instance
const cache = new NodeCache({
  stdTTL: 600,        // Default TTL: 10 minutes
  checkperiod: 120,   // Check for expired keys every 2 minutes
  useClones: false    // Don't clone objects (faster)
});

Pros & Cons

Common Use Cases

1. API Response Caching

const express = require('express');
const NodeCache = require('node-cache');
const app = express();

const cache = new NodeCache({ stdTTL: 300 }); // 5 minutes

app.get('/api/products', async (req, res) => {
  const cacheKey = 'products:all';
  let products = cache.get(cacheKey);
  
  if (!products) {
    // Cache miss - fetch from database
    products = await Product.find({});
    cache.set(cacheKey, products);
    console.log('Cache miss - fetched from database');
  } else {
    console.log('Cache hit - served from memory');
  }
  
  res.json(products);
});

2. Computed Results Caching

const cache = new NodeCache({ stdTTL: 3600 }); // 1 hour

const calculateUserStats = async (userId) => {
  const cacheKey = `user:stats:${userId}`;
  let stats = cache.get(cacheKey);
  
  if (!stats) {
    // Expensive calculation
    const user = await User.findById(userId);
    const orders = await Order.find({ userId });
    const totalSpent = orders.reduce((sum, order) => sum + order.total, 0);
    
    stats = {
      totalOrders: orders.length,
      totalSpent,
      averageOrderValue: totalSpent / orders.length,
      lastOrderDate: orders[0]?.createdAt
    };
    
    cache.set(cacheKey, stats);
  }
  
  return stats;
};

3. Session Data Caching

const cache = new NodeCache({ stdTTL: 1800 }); // 30 minutes

// Store user session
const storeUserSession = (userId, sessionData) => {
  const cacheKey = `session:${userId}`;
  cache.set(cacheKey, sessionData);
};

// Get user session
const getUserSession = (userId) => {
  const cacheKey = `session:${userId}`;
  return cache.get(cacheKey);
};

// Clear user session
const clearUserSession = (userId) => {
  const cacheKey = `session:${userId}`;
  cache.del(cacheKey);
};

Cache Management

1. Cache Statistics

// Get cache statistics
const stats = cache.getStats();
console.log('Cache stats:', stats);
// {
//   keys: 0,
//   ksize: 0,
//   vsize: 0,
//   hits: 0,
//   misses: 0,
//   keyCount: 0,
//   hitRate: 0
// }

// Monitor cache performance
setInterval(() => {
  const stats = cache.getStats();
  console.log(`Cache hit rate: ${(stats.hitRate * 100).toFixed(2)}%`);
}, 60000); // Every minute

2. Cache Events

// Listen to cache events
cache.on('set', (key, value) => {
  console.log(`Cache set: ${key}`);
});

cache.on('del', (key) => {
  console.log(`Cache deleted: ${key}`);
});

cache.on('expired', (key, value) => {
  console.log(`Cache expired: ${key}`);
});

cache.on('flush', () => {
  console.log('Cache flushed');
});

Best Practices

🔴 Redis Caching

What is Redis Caching?

Redis is an in-memory data structure store that can be used as a cache. It’s fast, persistent, and supports complex data types. Perfect for production applications that need high performance and data persistence.

Basic Setup

const redis = require('redis');

// Create Redis client
const client = redis.createClient({
  host: 'localhost',
  port: 6379,
  password: process.env.REDIS_PASSWORD,
  retry_strategy: (options) => {
    if (options.error && options.error.code === 'ECONNREFUSED') {
      return new Error('Redis server refused connection');
    }
    if (options.total_retry_time > 1000 * 60 * 60) {
      return new Error('Retry time exhausted');
    }
    if (options.attempt > 10) {
      return undefined;
    }
    return Math.min(options.attempt * 100, 3000);
  }
});

// Handle Redis events
client.on('connect', () => {
  console.log('Connected to Redis');
});

client.on('error', (err) => {
  console.error('Redis error:', err);
});

Pros & Cons

Common Use Cases

1. Simple Key-Value Caching

const getUser = async (userId) => {
  const cacheKey = `user:${userId}`;
  
  try {
    // Try to get from cache
    let user = await client.get(cacheKey);
    
    if (user) {
      return JSON.parse(user);
    }
    
    // Cache miss - fetch from database
    user = await User.findById(userId);
    
    if (user) {
      // Cache for 1 hour
      await client.setex(cacheKey, 3600, JSON.stringify(user));
    }
    
    return user;
  } catch (error) {
    console.error('Redis error:', error);
    // Fallback to database
    return await User.findById(userId);
  }
};

2. Hash Caching (Complex Objects)

const cacheUserProfile = async (userId, profile) => {
  const cacheKey = `user:profile:${userId}`;
  
  try {
    // Store profile as hash
    await client.hmset(cacheKey, {
      name: profile.name,
      email: profile.email,
      avatar: profile.avatar,
      preferences: JSON.stringify(profile.preferences)
    });
    
    // Set expiration
    await client.expire(cacheKey, 1800); // 30 minutes
    
  } catch (error) {
    console.error('Redis error:', error);
  }
};

const getUserProfile = async (userId) => {
  const cacheKey = `user:profile:${userId}`;
  
  try {
    const profile = await client.hgetall(cacheKey);
    
    if (Object.keys(profile).length > 0) {
      return {
        ...profile,
        preferences: JSON.parse(profile.preferences)
      };
    }
    
    // Cache miss - fetch from database
    const user = await User.findById(userId);
    if (user) {
      await cacheUserProfile(userId, user.profile);
    }
    
    return user?.profile;
  } catch (error) {
    console.error('Redis error:', error);
    return await User.findById(userId)?.profile;
  }
};

3. List Caching (Collections)

const cacheProductList = async (categoryId, products) => {
  const cacheKey = `products:category:${categoryId}`;
  
  try {
    // Clear existing list
    await client.del(cacheKey);
    
    // Add products to list
    for (const product of products) {
      await client.rpush(cacheKey, JSON.stringify(product));
    }
    
    // Set expiration
    await client.expire(cacheKey, 3600); // 1 hour
    
  } catch (error) {
    console.error('Redis error:', error);
  }
};

const getProductsByCategory = async (categoryId) => {
  const cacheKey = `products:category:${categoryId}`;
  
  try {
    const products = await client.lrange(cacheKey, 0, -1);
    
    if (products.length > 0) {
      return products.map(product => JSON.parse(product));
    }
    
    // Cache miss - fetch from database
    const productsFromDb = await Product.find({ categoryId });
    await cacheProductList(categoryId, productsFromDb);
    
    return productsFromDb;
  } catch (error) {
    console.error('Redis error:', error);
    return await Product.find({ categoryId });
  }
};

4. Set Caching (Unique Collections)

const cacheUserFriends = async (userId, friends) => {
  const cacheKey = `user:friends:${userId}`;
  
  try {
    // Clear existing set
    await client.del(cacheKey);
    
    // Add friends to set
    for (const friend of friends) {
      await client.sadd(cacheKey, JSON.stringify(friend));
    }
    
    // Set expiration
    await client.expire(cacheKey, 1800); // 30 minutes
    
  } catch (error) {
    console.error('Redis error:', error);
  }
};

const getUserFriends = async (userId) => {
  const cacheKey = `user:friends:${userId}`;
  
  try {
    const friends = await client.smembers(cacheKey);
    
    if (friends.length > 0) {
      return friends.map(friend => JSON.parse(friend));
    }
    
    // Cache miss - fetch from database
    const friendsFromDb = await Friend.find({ userId });
    await cacheUserFriends(userId, friendsFromDb);
    
    return friendsFromDb;
  } catch (error) {
    console.error('Redis error:', error);
    return await Friend.find({ userId });
  }
};

Advanced Redis Features

1. Pipeline Operations

const cacheMultipleUsers = async (users) => {
  const pipeline = client.pipeline();
  
  for (const user of users) {
    const cacheKey = `user:${user.id}`;
    pipeline.setex(cacheKey, 3600, JSON.stringify(user));
  }
  
  try {
    await pipeline.exec();
    console.log(`Cached ${users.length} users`);
  } catch (error) {
    console.error('Pipeline error:', error);
  }
};

const getMultipleUsers = async (userIds) => {
  const pipeline = client.pipeline();
  
  for (const userId of userIds) {
    const cacheKey = `user:${userId}`;
    pipeline.get(cacheKey);
  }
  
  try {
    const results = await pipeline.exec();
    return results.map(([err, result]) => 
      err ? null : (result ? JSON.parse(result) : null)
    );
  } catch (error) {
    console.error('Pipeline error:', error);
    return await User.find({ _id: { $in: userIds } });
  }
};

2. Pattern-based Deletion

const clearUserCache = async (userId) => {
  try {
    // Delete all keys matching pattern
    const keys = await client.keys(`user:${userId}:*`);
    if (keys.length > 0) {
      await client.del(keys);
      console.log(`Cleared ${keys.length} cache entries for user ${userId}`);
    }
  } catch (error) {
    console.error('Clear cache error:', error);
  }
};

const clearProductCache = async (productId) => {
  try {
    // Clear product-specific cache
    await client.del(`product:${productId}`);
    
    // Clear category cache (since product changed)
    const product = await Product.findById(productId);
    if (product) {
      await client.del(`products:category:${product.categoryId}`);
    }
    
    // Clear featured products cache
    await client.del('products:featured');
    
  } catch (error) {
    console.error('Clear product cache error:', error);
  }
};

Redis Configuration

1. Production Configuration

const redis = require('redis');

const createRedisClient = () => {
  return redis.createClient({
    host: process.env.REDIS_HOST || 'localhost',
    port: process.env.REDIS_PORT || 6379,
    password: process.env.REDIS_PASSWORD,
    db: process.env.REDIS_DB || 0,
    retry_strategy: (options) => {
      if (options.error && options.error.code === 'ECONNREFUSED') {
        return new Error('Redis server refused connection');
      }
      if (options.total_retry_time > 1000 * 60 * 60) {
        return new Error('Retry time exhausted');
      }
      if (options.attempt > 10) {
        return undefined;
      }
      return Math.min(options.attempt * 100, 3000);
    },
    max_attempts: 3,
    connect_timeout: 10000,
    command_timeout: 5000
  });
};

// Create client
const client = createRedisClient();

// Handle connection events
client.on('connect', () => {
  console.log('Connected to Redis');
});

client.on('ready', () => {
  console.log('Redis client ready');
});

client.on('error', (err) => {
  console.error('Redis error:', err);
});

client.on('end', () => {
  console.log('Redis connection ended');
});

client.on('reconnecting', () => {
  console.log('Reconnecting to Redis...');
});

2. Redis Cluster (High Availability)

const redis = require('redis');

// For Redis Cluster
const cluster = redis.createCluster({
  rootNodes: [
    {
      socket: {
        host: process.env.REDIS_HOST1,
        port: process.env.REDIS_PORT1
      }
    },
    {
      socket: {
        host: process.env.REDIS_HOST2,
        port: process.env.REDIS_PORT2
      }
    }
  ],
  defaults: {
    socket: {
      connectTimeout: 5000,
      lazyConnect: true
    }
  }
});

// Handle cluster events
cluster.on('connect', () => {
  console.log('Connected to Redis cluster');
});

cluster.on('error', (err) => {
  console.error('Redis cluster error:', err);
});

// Use cluster like regular client
const getUser = async (userId) => {
  const cacheKey = `user:${userId}`;
  let user = await cluster.get(cacheKey);
  
  if (user) {
    return JSON.parse(user);
  }
  
  user = await User.findById(userId);
  if (user) {
    await cluster.setex(cacheKey, 3600, JSON.stringify(user));
  }
  
  return user;
};

Best Practices

⚡ Express.js Caching

What is Express.js Caching?

Express.js caching involves storing HTTP responses, API results, or computed data to avoid expensive operations on subsequent requests. It can be implemented at the middleware level or within individual route handlers.

Basic Setup

const express = require('express');
const redis = require('redis');
const app = express();

// Create Redis client
const client = redis.createClient({
  host: process.env.REDIS_HOST || 'localhost',
  port: process.env.REDIS_PORT || 6379
});

// Basic cache middleware
const cacheMiddleware = (duration = 300) => {
  return async (req, res, next) => {
    const cacheKey = `express:${req.originalUrl}`;
    
    try {
      const cachedResponse = await client.get(cacheKey);
      
      if (cachedResponse) {
        const data = JSON.parse(cachedResponse);
        return res.json(data);
      }
      
      // Store original send method
      const originalSend = res.json;
      
      // Override send method to cache response
      res.json = function(data) {
        client.setex(cacheKey, duration, JSON.stringify(data));
        return originalSend.call(this, data);
      };
      
      next();
    } catch (error) {
      console.error('Cache middleware error:', error);
      next();
    }
  };
};

Pros & Cons

Common Use Cases

1. Route-Level Caching

// Cache specific routes
app.get('/api/products', cacheMiddleware(1800), async (req, res) => {
  try {
    const products = await Product.find({}).populate('category');
    res.json(products);
  } catch (error) {
    res.status(500).json({ error: 'Failed to fetch products' });
  }
});

// Cache with custom key
const customCacheMiddleware = (duration, keyGenerator) => {
  return async (req, res, next) => {
    const cacheKey = keyGenerator(req);
    
    try {
      const cachedResponse = await client.get(cacheKey);
      
      if (cachedResponse) {
        return res.json(JSON.parse(cachedResponse));
      }
      
      const originalSend = res.json;
      res.json = function(data) {
        client.setex(cacheKey, duration, JSON.stringify(data));
        return originalSend.call(this, data);
      };
      
      next();
    } catch (error) {
      console.error('Custom cache middleware error:', error);
      next();
    }
  };
};

// Usage with custom key
app.get('/api/users/:id', 
  customCacheMiddleware(3600, (req) => `user:${req.params.id}`),
  async (req, res) => {
    const user = await User.findById(req.params.id);
    res.json(user);
  }
);

2. Conditional Caching

// Cache based on conditions
const conditionalCacheMiddleware = (duration, condition) => {
  return async (req, res, next) => {
    // Check if caching should be applied
    if (!condition(req)) {
      return next();
    }
    
    const cacheKey = `express:${req.originalUrl}`;
    
    try {
      const cachedResponse = await client.get(cacheKey);
      
      if (cachedResponse) {
        return res.json(JSON.parse(cachedResponse));
      }
      
      const originalSend = res.json;
      res.json = function(data) {
        client.setex(cacheKey, duration, JSON.stringify(data));
        return originalSend.call(this, data);
      };
      
      next();
    } catch (error) {
      console.error('Conditional cache middleware error:', error);
      next();
    }
  };
};

// Cache only for authenticated users
app.get('/api/profile', 
  conditionalCacheMiddleware(1800, (req) => req.user),
  async (req, res) => {
    const profile = await User.findById(req.user.id).select('-password');
    res.json(profile);
  }
);

// Cache only for public data
app.get('/api/products/:id', 
  conditionalCacheMiddleware(3600, (req) => !req.user?.isAdmin),
  async (req, res) => {
    const product = await Product.findById(req.params.id);
    res.json(product);
  }
);

3. Cache Invalidation

// Cache invalidation middleware
const invalidateCache = (pattern) => {
  return async (req, res, next) => {
    try {
      const keys = await client.keys(pattern);
      if (keys.length > 0) {
        await client.del(keys);
        console.log(`Invalidated ${keys.length} cache entries`);
      }
      next();
    } catch (error) {
      console.error('Cache invalidation error:', error);
      next();
    }
  };
};

// Invalidate product cache when product is updated
app.put('/api/products/:id', 
  invalidateCache('express:/api/products*'),
  async (req, res) => {
    const product = await Product.findByIdAndUpdate(
      req.params.id, 
      req.body, 
      { new: true }
    );
    res.json(product);
  }
);

// Invalidate user cache when user is updated
app.put('/api/users/:id', 
  invalidateCache(`express:/api/users/${req.params.id}*`),
  async (req, res) => {
    const user = await User.findByIdAndUpdate(
      req.params.id, 
      req.body, 
      { new: true }
    );
    res.json(user);
  }
);

Advanced Express Caching

1. Response Caching with Headers

// Cache with HTTP headers
const cacheWithHeaders = (duration) => {
  return async (req, res, next) => {
    const cacheKey = `express:${req.originalUrl}`;
    
    try {
      const cachedResponse = await client.get(cacheKey);
      
      if (cachedResponse) {
        const { data, headers } = JSON.parse(cachedResponse);
        
        // Set cached headers
        Object.keys(headers).forEach(key => {
          res.set(key, headers[key]);
        });
        
        return res.json(data);
      }
      
      const originalSend = res.json;
      const originalSet = res.set;
      const headers = {};
      
      // Capture headers
      res.set = function(key, value) {
        headers[key] = value;
        return originalSet.call(this, key, value);
      };
      
      res.json = function(data) {
        const responseData = {
          data,
          headers
        };
        client.setex(cacheKey, duration, JSON.stringify(responseData));
        return originalSend.call(this, data);
      };
      
      next();
    } catch (error) {
      console.error('Cache with headers error:', error);
      next();
    }
  };
};

// Usage
app.get('/api/products', cacheWithHeaders(1800), async (req, res) => {
  res.set('X-Total-Count', '100');
  const products = await Product.find({});
  res.json(products);
});

2. Cache Warming

// Cache warming middleware
const warmCache = (routes) => {
  return async (req, res, next) => {
    try {
      for (const route of routes) {
        const cacheKey = `express:${route.path}`;
        const cachedResponse = await client.get(cacheKey);
        
        if (!cachedResponse) {
          console.log(`Warming cache for ${route.path}`);
          
          // Simulate request to warm cache
          const response = await route.handler();
          await client.setex(cacheKey, route.duration || 1800, JSON.stringify(response));
        }
      }
      
      next();
    } catch (error) {
      console.error('Cache warming error:', error);
      next();
    }
  };
};

// Define routes to warm
const routesToWarm = [
  {
    path: '/api/products',
    duration: 1800,
    handler: async () => {
      return await Product.find({}).populate('category');
    }
  },
  {
    path: '/api/categories',
    duration: 3600,
    handler: async () => {
      return await Category.find({});
    }
  }
];

// Apply cache warming
app.use(warmCache(routesToWarm));

3. Cache Statistics

// Cache statistics middleware
const cacheStats = {
  hits: 0,
  misses: 0,
  errors: 0
};

const cacheStatsMiddleware = () => {
  return async (req, res, next) => {
    const cacheKey = `express:${req.originalUrl}`;
    
    try {
      const cachedResponse = await client.get(cacheKey);
      
      if (cachedResponse) {
        cacheStats.hits++;
        return res.json(JSON.parse(cachedResponse));
      }
      
      cacheStats.misses++;
      next();
    } catch (error) {
      cacheStats.errors++;
      console.error('Cache stats middleware error:', error);
      next();
    }
  };
};

// Statistics endpoint
app.get('/api/cache/stats', (req, res) => {
  const total = cacheStats.hits + cacheStats.misses;
  const hitRate = total > 0 ? (cacheStats.hits / total * 100).toFixed(2) : 0;
  
  res.json({
    hits: cacheStats.hits,
    misses: cacheStats.misses,
    errors: cacheStats.errors,
    hitRate: `${hitRate}%`,
    total
  });
});

// Apply stats middleware
app.use(cacheStatsMiddleware());

Best Practices

⏰ Cache Expiration Strategies

Time-based Expiration

Set an expiration time for cache entries. This is useful for data that changes frequently or needs to be refreshed regularly.

TTL (Time To Live)

// Set cache with expiration
await client.setex('key', 3600, JSON.stringify(data)); // 1 hour
cache.set('key', data, 1800); // 30 minutes (NodeCache)

Manual Expiration

Delete specific cache entries using client.del("key") or clear all cache using client.flushall().

Advanced Expiration

You can use more complex expiration strategies like time-based expiration for different parts of your application or custom expiration logic based on business rules.

🔒 Cache Security & Best Practices

Security Considerations

Caching can introduce security vulnerabilities if not implemented carefully. Understanding these risks and implementing proper safeguards is crucial for production applications.

Common Security Risks

1. Cache Poisoning

// VULNERABLE: User input in cache key
const cacheKey = `user_data_${req.params.userId}`;

// SECURE: Validate and sanitize input
const userId = parseInt(req.params.userId);
if (userId > 0) {
  const cacheKey = `user_data_${userId}`;
}

2. Information Disclosure

// VULNERABLE: Caching sensitive data
const userData = {
  email: user.email,
  password: user.password, // Never cache this!
  creditCard: user.creditCard // Never cache this!
};

// SECURE: Only cache non-sensitive data
const userData = {
  name: user.name,
  avatar: user.avatar,
  preferences: user.preferences
};

Security Best Practices

1. Input Validation

• Validate Inputs: Always validate and sanitize user inputs before using them in cache keys
• Use Type Checking: Ensure cache keys are of expected types
• Limit Key Length: Prevent very long cache keys that could cause issues

2. User-Specific Caching

• Include User Context: Always include user context for personalized data
• Separate Public Data: Be explicit about what data is shared vs user-specific
• Use Namespaces: Use namespaces to separate different types of cached data

3. Sensitive Data Protection

• Never Cache Passwords: Never cache passwords, tokens, or sensitive personal data
• Use Encryption: Consider encrypting sensitive cached data
• Set Short TTL: Use shorter expiration times for sensitive data

Performance Best Practices

1. Cache Key Optimization

• Use Descriptive Keys: Use clear, meaningful cache key names
• Keep Keys Short: Long cache keys consume more memory
• Include Dependencies: Add timestamps for automatic invalidation

2. Memory Management

• Set Expiration: Always set TTL to prevent memory leaks
• Monitor Size: Track cache store memory usage
• Use Compression: Enable compression for large cache entries

3. Cache Warming

• Warm Critical Data: Pre-populate frequently accessed cache entries
• Use Background Jobs: Use background jobs for cache warming
• Monitor Warming: Track cache warming performance

🚀 Production Deployment

Pre-Deployment Checklist

• Cache Store Selection: Choose Redis for production (fast, persistent, scalable)
• Memory Configuration: Set appropriate Redis memory limits and eviction policies
• Monitoring Setup: Configure cache monitoring and alerting
• Security Review: Ensure no sensitive data is being cached
• Performance Testing: Test cache performance under load

Redis Production Setup

1. Redis Configuration

// Production Redis configuration
const client = redis.createClient({
  host: process.env.REDIS_HOST,
  port: process.env.REDIS_PORT,
  password: process.env.REDIS_PASSWORD,
  retry_strategy: (options) => {
    if (options.error && options.error.code === 'ECONNREFUSED') {
      return new Error('Redis server refused connection');
    }
    return Math.min(options.attempt * 100, 3000);
  }
});

2. Environment Variables

// .env file
REDIS_HOST=your-redis-host
REDIS_PORT=6379
REDIS_PASSWORD=your-redis-password
REDIS_DB=0

Monitoring and Alerting

1. Cache Performance Monitoring

• Monitor Hit Rates: Track cache hit/miss ratios
• Memory Usage: Monitor Redis memory consumption
• Response Times: Track cache operation latency
• Error Rates: Monitor cache operation failures

2. Health Checks

• Connection Health: Monitor Redis connection status
• Memory Health: Check Redis memory usage
• Performance Health: Monitor cache operation performance

Deployment Strategies

1. Blue-Green Deployment

• Cache Warming: Pre-populate cache after deployment
• Gradual Rollout: Deploy to subset of servers first
• Rollback Plan: Have plan to rollback if issues occur

2. Cache Warming

• Critical Data: Warm up frequently accessed data
• Background Jobs: Use background jobs for cache warming
• Monitoring: Monitor cache warming progress

Troubleshooting Production Issues

1. High Memory Usage

• Check Large Keys: Use Redis commands to find large cache entries
• Review Expiration: Ensure all cache entries have appropriate TTL
• Enable Compression: Use compression for large cache entries

2. Cache Misses

• Monitor Hit Rates: Track cache hit/miss ratios
• Review Cache Keys: Ensure cache keys are consistent
• Check Expiration: Verify TTL values are appropriate

🎯 Interview Preparation

Common Interview Questions

1. Basic Concepts

• Q: What is caching and why is it important?
  A: Caching stores expensive-to-compute results for reuse, improving performance by reducing database queries, API calls, and computation time.
• Q: What are the different types of caching in Node.js?
  A: Memory caching (NodeCache), Redis caching, Express middleware caching, and various cache stores (Redis, Memcached, Memory).
• Q: How do you handle cache invalidation?
  A: Use TTL expiration, manual deletion, pattern-based deletion, or version-based invalidation depending on the use case.

2. Implementation Questions

• Q: How would you implement caching in an Express.js application?
  A: Use middleware patterns, Redis for persistence, custom cache keys, and proper error handling with fallback logic.
• Q: How do you handle cache failures?
  A: Implement fallback mechanisms, use circuit breakers, and ensure graceful degradation when cache is unavailable.
• Q: What cache store would you use in production?
  A: Redis – it’s fast, persistent, scalable, and feature-rich compared to alternatives.

3. Advanced Questions

• Q: How would you implement cache warming?
  A: Use background jobs to pre-populate frequently accessed cache entries after deployment or data changes.
• Q: How do you monitor cache performance?
  A: Track hit rates, memory usage, response times, and use tools like Redis Commander or custom metrics.
• Q: What are cache stampedes and how do you prevent them?
  A: Multiple requests generating the same cache simultaneously. Prevent with background jobs, locks, or staggered expiration.

System Design Questions

1. E-commerce Caching Strategy

// Design a caching strategy for an e-commerce site

// Product Catalog
- Cache product listings by category
- Cache individual product details
- Cache product search results
- Use Redis for persistence

// User Data
- Cache user profiles (non-sensitive data only)
- Cache user preferences and settings
- Cache user order history

// Analytics
- Cache daily/weekly sales reports
- Cache top-selling products
- Cache user purchase patterns

// Implementation
const cacheProduct = async (productId) => {
  const cacheKey = `product:${productId}`;
  const product = await Product.findById(productId);
  await client.setex(cacheKey, 3600, JSON.stringify(product));
};

2. API Caching Strategy

// Design caching for a REST API

// API Response Caching
- Cache GET requests with appropriate TTL
- Use conditional caching for user-specific data
- Implement cache invalidation for data updates

// Rate Limiting with Cache
- Use Redis for rate limiting counters
- Cache rate limit data per user/IP
- Implement sliding window rate limiting

// Implementation
const cacheApiResponse = async (endpoint, params, data) => {
  const cacheKey = `api:${endpoint}:${JSON.stringify(params)}`;
  await client.setex(cacheKey, 1800, JSON.stringify(data));
};

Performance Optimization Questions

1. Cache Key Optimization

• Q: How would you optimize cache keys?
  A: Use descriptive names, include dependencies, keep keys short, and use namespaces.
• Q: How do you handle cache memory usage?
  A: Set appropriate TTL, use compression, monitor memory usage, and implement eviction policies.
• Q: How would you implement cache warming?
  A: Use background jobs to pre-populate frequently accessed cache entries after deployment or data changes.

2. Scalability Questions

• Q: How would you scale caching for high traffic?
  A: Use Redis clustering, implement cache warming, optimize cache keys, and monitor performance metrics.
• Q: How do you handle cache failures?
  A: Implement fallback mechanisms, use circuit breakers, and ensure graceful degradation when cache is unavailable.

Practical Coding Questions

1. Cache Implementation

// Implement a caching service for user recommendations

const RecommendationService = {
  async getUserRecommendations(userId) {
    const cacheKey = `recommendations:user:${userId}`;
    
    try {
      let recommendations = await client.get(cacheKey);
      
      if (recommendations) {
        return JSON.parse(recommendations);
      }
      
      // Generate recommendations
      const user = await User.findById(userId);
      recommendations = await generateRecommendations(user);
      
      // Cache for 1 hour
      await client.setex(cacheKey, 3600, JSON.stringify(recommendations));
      
      return recommendations;
    } catch (error) {
      console.error('Cache error:', error);
      // Fallback to database
      const user = await User.findById(userId);
      return await generateRecommendations(user);
    }
  }
};

2. Cache Invalidation

// Implement cache invalidation for a blog system

const BlogService = {
  async updatePost(postId, data) {
    // Update post
    const post = await Post.findByIdAndUpdate(postId, data, { new: true });
    
    // Invalidate related caches
    await this.invalidatePostCache(postId);
    
    return post;
  },
  
  async invalidatePostCache(postId) {
    const patterns = [
      `post:${postId}`,
      `posts:category:*`,
      `posts:featured`,
      `api:posts:*`
    ];
    
    for (const pattern of patterns) {
      const keys = await client.keys(pattern);
      if (keys.length > 0) {
        await client.del(keys);
      }
    }
  }
};

🧪 Alternatives

Alternative Caching Solutions

While Redis and in-memory caching are popular choices, there are several alternatives that might be better suited for specific use cases.

Alternative Cache Stores

1. Memcached

• Pros: Simple, fast, mature, battle-tested
• Cons: No persistence, limited data types, older technology
• Use Case: Simple key-value caching, legacy applications

2. Hazelcast

• Pros: Distributed, in-memory, high availability
• Cons: Complex setup, resource intensive
• Use Case: Enterprise applications, distributed systems

3. Apache Ignite

• Pros: In-memory computing, SQL support, distributed
• Cons: Complex, resource intensive, learning curve
• Use Case: Big data applications, real-time analytics

Cloud-Based Solutions

1. AWS ElastiCache

• Pros: Managed service, auto-scaling, high availability
• Cons: Vendor lock-in, cost for large scale
• Use Case: AWS-based applications, managed infrastructure

2. Azure Cache for Redis

• Pros: Managed Redis, integration with Azure services
• Cons: Azure-specific, potential vendor lock-in
• Use Case: Azure-based applications, enterprise solutions

3. Google Cloud Memorystore

• Pros: Fully managed, high performance, global availability
• Cons: Google Cloud specific, cost considerations
• Use Case: Google Cloud applications, global deployments

Application-Level Alternatives

1. HTTP Caching

• Pros: Built into HTTP, works with CDNs, simple
• Cons: Limited control, browser-dependent
• Use Case: Static content, API responses

2. CDN Caching

• Pros: Global distribution, fast delivery, managed service
• Cons: Limited to static content, cost for large scale
• Use Case: Static assets, global content delivery

3. Database Query Caching

• Pros: Built into databases, automatic, no additional infrastructure
• Cons: Limited control, database-specific
• Use Case: Database-heavy applications, read-heavy workloads

When to Choose Alternatives

1. Choose Memcached When

• You need simple key-value caching
• You’re working with legacy systems
• You want minimal complexity
• You don’t need persistence

2. Choose Cloud Services When

• You want managed infrastructure
• You need auto-scaling capabilities
• You’re already using the cloud provider
• You want high availability out of the box

3. Choose HTTP/CDN Caching When

• You’re caching static content
• You need global distribution
• You want simple implementation
• You’re building a web application