Handling Next.js Serverless + MongoDB

Learn how to prevent database connection overloads in serverless environments by reusing MongoDB connections efficiently.

Next.js and MongoDB make a powerful combo—especially when you deploy them serverlessly via platforms like Vercel. However, using MongoDB incorrectly (like opening a new connection on each request) can trigger “connection storming,” where too many simultaneous connections overwhelm your database.

⚠️ What Is Connection Storming?

Connection storming occurs when serverless functions create a new MongoDB connection every time they run. In high-concurrency scenarios, this behavior can quickly reach connection limits, slow down responses, or even cause timeouts:

• MongoServerSelectionError or MongoNetworkError
• MongoTimeoutError or MongoTopologyClosedError
• Mongo Atlas alerts you when connections exceed your configured limits

🌐 Why It Happens in Serverless

Serverless platforms launch isolated function instances without shared memory. Each new instance opens a fresh MongoDB connection—leading to rapid connection buildup during traffic spikes.

✅ The Simple Fix: Use a Global Client Cache

Thanks to reusable containers in serverless environments, you can store your MongoDB client globally. This strategy allows one connection per container lifecycle instead of one per request:

// lib/mongodb.js
import { MongoClient } from 'mongodb';

const uri = process.env.MONGODB_URI;
let client;
let clientPromise;

if (!uri) throw new Error('Please define MONGODB_URI');

if (process.env.NODE_ENV === 'development') {
  if (!global._mongoClientPromise) {
    client = new MongoClient(uri);
    global._mongoClientPromise = client.connect();
  }
  clientPromise = global._mongoClientPromise;
} else {
  client = new MongoClient(uri);
  clientPromise = client.connect();
}

export default clientPromise;

// pages/api/users.js
import clientPromise from '../../lib/mongodb';

export default async function handler(req, res) {
  const client = await clientPromise;
  const db = client.db('mydatabase');
  const users = await db.collection('users').find({}).toArray();
  res.json(users);
}

🔁 Why This Works

• You store the clientPromise globally.
• Serverless containers reuse active connections between requests.
• The app avoids opening a new MongoDB connection every time the function runs.

📊 Real Results

This approach significantly lowers your connection count, avoids cold-start spikes, and keeps your MongoDB server stable. In development, the app opens one connection per run, but production workloads consistently benefit from reusing the client.

🛡️ Advanced Tips

• Set the appropriate maxPoolSize in your MongoClient configuration.
• Monitor backend logs and Atlas metrics to catch unusual patterns early.
• Use indexes and optimize queries to reduce database load further.

🔚 Bottom Line

When you build with Next.js on serverless platforms, avoid connection storms by caching your MongoDB client globally. One client per container is enough—cleaner, faster, and more efficient for your database.

At Web Expert Solution, we focus on building robust, scalable web architectures. Our guides help developers build high-performance apps with modern stacks like Next.js and MongoDB. Subscribe for more backend best practices!