Node.js API Performance: How We Cut Response Time by 60% (800ms → 300ms)

The Performance Challenge

Our API was struggling with response times averaging 800ms. After optimization, we brought this down to 300ms. Here's how.

Why This Matters

In production, every 100ms of latency costs engagement. At scale, inefficient APIs compound into infrastructure costs and poor user experience.

1. Database Query Optimization

Use Indexes Wisely

// Before: Full table scan
db.users.find({ email: "user@example.com" });

// After: Create an index
db.users.createIndex({ email: 1 });

Select Only What You Need

// Bad: Fetching entire documents
const users = await User.find({});

// Good: Projection
const users = await User.find({}, { name: 1, email: 1 });

2. Implement Caching

We used Redis for multi-level caching:

const Redis = require('ioredis');
const redis = new Redis();

async function getUserWithCache(userId) {
  const cacheKey = "user:" + userId;

  const cached = await redis.get(cacheKey);
  if (cached) return JSON.parse(cached);

  const user = await User.findById(userId);
  await redis.setex(cacheKey, 300, JSON.stringify(user));

  return user;
}

3. Parallelize Independent Operations

// Bad: Sequential, 1200ms total
const user = await getUser(id);
const posts = await getPosts(id);
const notifications = await getNotifications(id);

// Good: Parallel, 400ms total
const [user, posts, notifications] = await Promise.all([
  getUser(id),
  getPosts(id),
  getNotifications(id)
]);

Results

Metric	Before	After
Avg Response Time	800ms	300ms
P95 Latency	2s	500ms
Throughput	500 req/s	2000 req/s

Key Lessons

1. Measure first: Use APM tools to identify actual bottlenecks
2. Cache aggressively: But invalidate correctly
3. Think parallel: Most operations can run concurrently
4. Monitor continuously: Performance degrades over time without attention

Performance optimization is iterative. Start with the biggest wins and work your way down.