Fredrick Oladipupo

Posted on Mar 18 • Edited on Mar 31

Optimizing API Performance - Part 1: Caching

#webdev #caching #devops #programming

Why Caching Matters for API Performance

Ever waited too long for an app to load? Slow APIs frustrate users and cost businesses millions in lost revenue. The good news? Caching can cut response times from seconds to milliseconds.

APIs handle thousands (or even millions) of requests daily, often fetching the same data repeatedly. Speed is a value on its own and without caching, APIs can suffer from:

High database load – Unnecessary queries for frequently accessed data.
Slow API response times – Every request has to process everything from scratch, boot your whole application and framework service providers.
Increased infrastructure costs – More server power needed to handle the same traffic.

By implementing caching, APIs can return precomputed responses instantly, reducing workload and boosting speed.

Types of Caching in APIs

1. Client-Side Caching (Browser & Frontend Cache)

APIs can instruct clients (browsers, mobile apps) to temporarily store data instead of refetching it repeatedly. This is done via HTTP headers like:

Cache-Control – Defines how long the client should keep the response.
ETag (Entity Tag) – Helps determine if data has changed before refetching.

Minimal Example: Client-Side Caching with Local Storage

const cacheKey = "popular_articles";
let cachedData = localStorage.getItem(cacheKey);

if (!cachedData) {
  fetch("/api/popular-articles")
    .then(response => response.json())
    .then(data => {
      localStorage.setItem(cacheKey, JSON.stringify(data)); // Cache response
    });
} else {
  console.log(JSON.parse(cachedData)); // Use cached data
}

Use Case: Reducing unnecessary API calls for static content like product details or user profiles.

2. Server-Side Caching (Memory-Based Cache)

Instead of querying the database every time, APIs can store frequently requested data in-memory using Redis or Memcached or Memory based cache of your choice.

Minimal Example: Server-Side Caching with Redis (Node.js)

const redis = require("redis");
const client = redis.createClient();

app.get("/api/popular-articles", async (req, res) => {
  client.get("popular_articles", async (err, data) => {
    if (data) {
      return res.json(JSON.parse(data)); // Return cached response
    } else {
      const articles = await fetchPopularArticlesFromDB();
      client.setex("popular_articles", 3600, JSON.stringify(articles)); // Cache for 1 hour
      return res.json(articles);
    }
  });
});

Use Cases:

Caching user authentication sessions to reduce database lookups.
Storing popular API responses (e.g., trending articles, weather forecasts).
Reducing third-party API calls by storing results instead of re-fetching.

💡 Real-World Example: Twitter caches user timelines in Redis to reduce database queries by 95% while keeping user feeds responsive.

3. Database Query Caching

Instead of executing expensive SQL queries every time, APIs can cache query results in memory.

Minimal Example: MySQL Query Caching with Redis (PHP)

$cacheKey = "exchange_rates";
$cachedRates = $redis->get($cacheKey);

if (!$cachedRates) {
    $result = $db->query("SELECT * FROM exchange_rates");
    $rates = $result->fetchAll();
    $redis->setex($cacheKey, 3600, json_encode($rates)); // Cache for 1 hour
} else {
    $rates = json_decode($cachedRates, true);
}

Best practices:

Cache frequently accessed but rarely changing data (e.g., country lists, exchange rates).
Set expiration times (e.g., 1 hour) to prevent serving stale data.
Use cache invalidation to refresh data when updates occur.

Use Case: An e-commerce platform caching product categories to avoid database overload.

4. Full-Page Caching (Reverse Proxy Caching)

For read-heavy traffic, solutions like Varnish, Nginx, or Cloudflare can cache entire API responses and serve them instantly.

Minimal Example: Reverse Proxy Caching with Nginx

location /api/ {
    proxy_pass http://backend_server;
    proxy_cache my_cache;
    proxy_cache_valid 200 1h;
}

💡 Real-World Example: A news API used Cloudflare's cache to serve headlines, cutting response times from 300ms to under 50ms globally.

When Not to Use Caching

While caching is powerful, it’s not a silver bullet. Avoid caching:

Highly dynamic data (e.g., real-time stock prices, chat messages, frequently changing data, financial data - wallet balance, transaction history).
User-specific content unless using per-user cache keys.
Data that must always be fresh (e.g., real-time analytics, transaction records).

Best Practices for Implementing API Caching

Cache strategically – Not everything should be cached.
Set expiration policies – Define how long data stays cached before refreshing.
Handle cache invalidation – Clear outdated data when updates occur.
Monitor cache hit rates – Track performance to ensure caching is effective.

- Use multiple cache layers – Combine client-side, memory-based, and database caching for maximum speed.

Conclusion

Caching isn’t just an optimization—it’s a necessity for scaling APIs. Whether you’re building a small app or a global platform, smart caching can make the difference between an API that struggles and one that scales.

Resources

🚀 Next up in the API Performance Series: Load Balancing read here!

Have you used caching in your projects? What worked (or failed)? Let’s discuss in the comments! 🚀

Get n8n VPS hosting 3x cheaper than a cloud solution

Get fast, easy, secure n8n VPS hosting from $4.99/mo at Hostinger. Automate any workflow using a pre-installed n8n application and no-code customization.

Start now

DEV Community