Who this is for
This guide is for engineering teams managing high-traffic applications, e-commerce platforms, or SaaS products where response times directly impact user experience and revenue. If you're dealing with slow page loads, high server costs, or inconsistent performance across regions, understanding how CDN and origin caching work together becomes critical for infrastructure performance optimization.
12 practices for effective caching strategies
1. Set appropriate TTL values based on content type
Static assets like images and CSS can have long TTLs (30 days), while API responses might need shorter ones (5-15 minutes). Dynamic content that changes frequently should have very short TTLs or use cache invalidation strategies. The key is matching the cache duration to how often your content actually changes, not setting arbitrary timeouts.
# Nginx example for different content types
location ~* \.(jpg|jpeg|png|css|js)$ {
expires 30d;
add_header Cache-Control "public, immutable";
}
location /api/ {
expires 5m;
add_header Cache-Control "public, max-age=300";
}2. Use cache-control headers to guide both CDN and browser behavior
Proper cache-control headers tell your CDN when to cache content and tell browsers when to request fresh copies. The s-maxage directive controls CDN caching separately from browser caching, while stale-while-revalidate allows serving cached content while fetching updates in the background.
# For content that changes daily
Cache-Control: public, max-age=3600, s-maxage=86400, stale-while-revalidate=3600
# For frequently changing API responses
Cache-Control: public, max-age=300, s-maxage=300, must-revalidate3. Implement cache warming for critical pages
Cache warming ensures your most important pages are always served from cache, not fetched fresh when the first user requests them. This prevents cache misses on high-traffic pages after deployments or cache purges. Set up automated scripts that request key URLs immediately after cache invalidation.
4. Configure origin caching layers strategically
Your origin server needs its own caching strategy independent of your CDN. Use Redis or Memcached for database query results, rendered page fragments, and computed values. This reduces database load even when CDN cache misses occur. Layer your caches so the CDN serves static content, application-level cache handles dynamic assembly, and database cache speeds up queries.
5. Set up proper cache invalidation workflows
Cache invalidation should be part of your deployment process, not a manual afterthought. Use versioned URLs for assets that change with deployments, and implement selective purging for content that updates independently. Your CI/CD pipeline should automatically invalidate relevant cache entries when code or content changes.
# Example cache invalidation in deployment script
# Purge specific paths
curl -X PURGE "https://cdn.example.com/api/products/*"
# Or use cache tags for more precise control
curl -X POST "https://api.cloudflare.com/client/v4/zones/ZONE_ID/purge_cache" \
-H "Authorization: Bearer TOKEN" \
-d '{"tags":["product-data"]}'6. Monitor cache hit ratios and optimize accordingly
Track cache hit ratios for both your CDN and origin caching layers. Low hit ratios indicate misconfigured TTLs, too much uncacheable content, or frequent cache invalidation. Aim for 80%+ cache hit ratios on static assets and 50%+ on dynamic content. Use these metrics to identify which content types need caching strategy adjustments.
7. Handle cache stampedes with request coalescing
When cached content expires on high-traffic sites, multiple requests can hit your origin simultaneously, creating load spikes. Implement request coalescing so only one request fetches fresh content while others wait for the result. This prevents your origin from being overwhelmed when popular cache entries expire.
8. Use edge-side includes (ESI) for mixed content
Pages with both cacheable and personalized content can use ESI to cache the common parts while dynamically inserting user-specific sections. This allows you to cache page shells for long periods while still serving personalized content. Configure your CDN to process ESI tags and fetch personalized fragments separately.
9. Configure geographic caching strategies
Different regions may need different caching approaches based on user behavior and content relevance. Set up region-specific TTLs and cache rules. Content that's popular in Europe might need longer caching there, while being cached less aggressively in regions where it's rarely accessed. This optimizes cache efficiency across your global infrastructure.
10. Implement cache bypass for authenticated users
Authenticated user content often can't be cached the same way as public content. Set up cache bypass rules for logged-in users, or implement cache segmentation based on user roles or subscription levels. This prevents serving cached personal data to the wrong users while still caching public content effectively.
# Nginx example for authenticated user bypass
set $skip_cache 0;
if ($http_cookie ~* "logged_in=true") {
set $skip_cache 1;
}
location / {
proxy_cache_bypass $skip_cache;
proxy_no_cache $skip_cache;
}11. Use cache hierarchies for cost optimization
Not all cache layers cost the same. Structure your caching so expensive CDN bandwidth handles the highest-traffic content, while cheaper origin caching handles medium-traffic content, and database caching handles the long tail. This can significantly reduce costs while maintaining performance, as detailed in our guide on cloud cost optimization strategies.
12. Set up cache performance alerts
Monitor cache performance metrics and alert when hit ratios drop, response times increase, or origin load spikes. These indicators often predict performance problems before users notice them. Set thresholds based on your normal performance patterns and investigate when metrics deviate significantly from baseline performance.
Rolling out these practices in existing teams
Start by auditing your current caching setup and measuring baseline performance metrics. Implement practices 1, 2, and 6 first since they provide immediate visibility and control. Then add cache invalidation workflows (practice 5) to your deployment process before optimizing more complex strategies like ESI or geographic caching.
Assign ownership of cache performance to specific team members and include cache hit ratios in your regular performance reviews. This ensures caching remains optimized as your application evolves. Document your caching strategies and TTL decisions so the team understands why specific configurations exist.
The approach we use for high availability infrastructure applies here: implement incrementally, measure the impact of each change, and optimize based on real performance data rather than theoretical best practices.
Measuring the impact
Track response times, server load, and bandwidth costs before and after implementing these practices. Cache optimization typically reduces origin server load by 60-80% and improves response times by 200-500ms for cached content. These improvements directly translate to better user experience and lower infrastructure costs.
Document which practices provide the biggest impact for your specific use case. E-commerce sites often see the most benefit from practices 3, 8, and 11, while SaaS applications typically gain more from practices 4, 7, and 10.
If implementing these yourself is not the best use of your engineering time, our managed services cover all of them by default.
