DEV Community

Ramer Labs
Ramer Labs

Posted on

Performance Tuning for Node.js APIs with Redis Caching and CDN

#performance #backend #api

Why Performance Matters for Node.js APIs

As a full‑stack engineer, you’ve probably felt the sting of a slow API response: users abandon carts, monitoring alerts go red, and the team scrambles for a quick fix. In the world of JavaScript back‑ends, latency is often a product of three things – network round‑trips, expensive database calls, and synchronous processing. Tackling each layer with a pragmatic, data‑driven approach can shave milliseconds off every request, and those milliseconds add up to happier users and lower cloud bills.

Step 1: Identify Hot Endpoints

Before you start adding caches or workers, you need to know what to optimize. A few minutes with a profiling tool can save hours of guesswork.

Use Logging & Metrics

  • Request tracing – add a unique X-Request-ID header and log the start/end timestamps.
  • Histogram metrics – tools like Prometheus can bucket response times (e.g., 0.1s, 0.5s, 1s).
  • Error rates – spike in 5xx often signals a downstream bottleneck. 
// Example: simple request timer middleware for Express
app.use((req, res, next) => {
  const start = process.hrtime.bigint();
  res.on('finish', () => {
    const duration = Number(process.hrtime.bigint() - start) / 1e6; // ms
    console.log(`${req.method} ${req.originalUrl} – ${duration.toFixed(2)}ms`);
  });
  next();
});
Enter fullscreen mode Exit fullscreen mode

Run the service for a few minutes under realistic load and export the top 5 slowest routes. Those are your candidates for caching.

Step 2: Add Redis Caching

Redis shines as an in‑memory key/value store that can act as a read‑through cache for expensive lookups. The goal is to serve a response from Redis on the hot path and fall back to the database only on a miss.

Choose a Cache Key Strategy

  • Resource‑centric – user:{id} for user profile data.
  • Query‑centric – hash the request parameters: search:{md5(params)}.
  • TTL (time‑to‑live) – set a reasonable expiration (e.g., 5 minutes for trending feeds, 1 hour for static catalogs).

Node.js Integration with ioredis 

const Redis = require('ioredis');
const redis = new Redis({ host: 'localhost', port: 6379 });

async function getUserProfile(id) {
  const cacheKey = `user:${id}`;
  const cached = await redis.get(cacheKey);
  if (cached) return JSON.parse(cached);

  // Fallback to DB (pseudo‑code)
  const user = await db.users.findUnique({ where: { id } });
  await redis.setex(cacheKey, 300, JSON.stringify(user)); // 5‑minute TTL
  return user;
}
Enter fullscreen mode Exit fullscreen mode

Best practices

  • Cache after a successful DB read to avoid caching errors.
  • Use SETEX to guarantee expiration.
  • Invalidate on write: when a user updates their profile, delete the key (redis.del(cacheKey)).

Step 3: Leverage a CDN for Static & Edge Caching

While Redis handles dynamic payloads, a Content Delivery Network (CDN) can offload static assets and even API responses that are safe to cache at the edge.

Nginx as an Edge Proxy

If you run Nginx in front of your Node service, a few directives turn it into a smart cache layer:

# /etc/nginx/conf.d/api_cache.conf
proxy_cache_path /var/cache/nginx levels=1:2 keys_zone=api_cache:10m max_size=1g inactive=60m use_temp_path=off;

server {
  listen 80;
  location /api/ {
    proxy_pass http://localhost:3000;
    proxy_cache api_cache;
    proxy_cache_valid 200 302 10m;
    proxy_cache_valid 404 1m;
    add_header X-Cache-Status $upstream_cache_status;
  }
}
Enter fullscreen mode Exit fullscreen mode
  • proxy_cache_valid tells Nginx how long to keep a successful response.
  • X-Cache-Status helps you verify hits vs. misses in your logs.

Cloud‑Hosted CDNs

If you prefer a managed solution, configure Cache‑Control headers in your Node app:

app.get('/api/products', (req, res) => {
  res.set('Cache-Control', 'public, max-age=300, stale-while-revalidate=60');
  // fetch & return product list
});
Enter fullscreen mode Exit fullscreen mode

CDNs like Cloudflare or Fastly will honor these headers and serve the response from the nearest PoP, cutting round‑trip latency dramatically.

Step 4: Optimize Database Queries with Indexes

Caching is a band‑aid; the underlying database should still be tuned. For PostgreSQL (a common companion to Node.js), ensure that columns used in WHERE, JOIN, or ORDER BY clauses have appropriate indexes.

-- Example: index for a frequent search on `email`
CREATE INDEX idx_users_email ON users (email);

-- Composite index for pagination + filter
CREATE INDEX idx_orders_user_status ON orders (user_id, status);
Enter fullscreen mode Exit fullscreen mode

After adding an index, run EXPLAIN ANALYZE on the query to verify the planner uses it. Avoid over‑indexing – each index adds write overhead.

Step 5: Async Workers for Long‑Running Tasks

Not every operation belongs in the request‑response cycle. Offload heavy work (image processing, email sending, report generation) to a background queue.

BullMQ Example 

const { Queue, Worker } = require('bullmq');
const connection = { host: '127.0.0.1', port: 6379 };
const emailQueue = new Queue('email', { connection });

// Producer – enqueue a job
app.post('/api/send-welcome', async (req, res) => {
  await emailQueue.add('welcome', { userId: req.body.id });
  res.status(202).json({ status: 'queued' });
});

// Consumer – process jobs
const worker = new Worker('email', async job => {
  const user = await db.users.findUnique({ where: { id: job.data.userId } });
  await sendWelcomeEmail(user.email);
}, { connection });
Enter fullscreen mode Exit fullscreen mode

Benefits:

  • Immediate API response (202 Accepted).
  • Automatic retries and back‑off.
  • Visibility into job health via BullMQ UI or Prometheus.

Monitoring & Observability

A performance‑focused stack is only as good as its telemetry:

  • Metrics: Prometheus + Grafana dashboards for request latency, cache hit ratio, queue depth.
  • Tracing: OpenTelemetry to correlate a request through Express → Redis → Postgres.
  • Logging: Structured JSON logs with request ID, cache status, and error stack.
  • Alerting: Set thresholds (e.g., 95th‑percentile latency > 300 ms) to trigger PagerDuty or Slack notifications.

Regularly review these signals; performance is a moving target as traffic patterns evolve.

Wrap‑Up

By profiling hot endpoints, introducing a Redis read‑through cache, pushing static responses to a CDN, tightening your database indexes, and delegating heavy work to async workers, you can consistently keep Node.js API latency under 200 ms even under load. Remember to instrument every layer so you know when a change helps—or hurts.

If you need help shipping this, the team at https://ramerlabs.com can help.

Top comments (0)