Node.js is a powerhouse for building scalable applications, but writing efficient and maintainable code requires more than just asynchronous magic. To truly level up, you need design patterns — proven solutions to common software architecture challenges.

Whether you’re working on a microservices system, an API backend, or a real-time application, using the right design patterns will make your codebase more scalable, maintainable, and performant.

1. The Singleton Pattern

Ever wondered how to share a single instance of an object across an application? That’s exactly what the Singleton pattern does. This is particularly useful for database connections, caching, or logging where creating multiple instances would be inefficient.

Example: Singleton Database Connection

Using a singleton for a MongoDB connection prevents multiple connections from being established unnecessarily.

class Database {
  constructor() {
    if (!Database.instance) {
      this.connection = this.connect();
      Database.instance = this;
    }
    return Database.instance;
  }

  connect() {
    console.log("Connecting to database...");
    return { /* mock connection object */ };
  }
}

const db1 = new Database();
const db2 = new Database();
console.log(db1 === db2); // true (same instance)

Why use it?

• Prevents redundant instances (e.g., multiple DB connections).
• Saves memory and optimizes resource usage.

2. The Factory Pattern

The Factory pattern creates objects dynamically without specifying the exact class. This is great for situations where you need to instantiate different types of objects based on conditions.

Example: Factory for Different Payment Methods

Let’s say you’re integrating Stripe and PayPal in your app. Instead of hardcoding the payment logic, you can use a factory to generate the right payment processor dynamically.

class StripePayment {
  process() {
    console.log("Processing payment via Stripe");
  }
}

class PayPalPayment {
  process() {
    console.log("Processing payment via PayPal");
  }
}

class PaymentFactory {
  static createPaymentMethod(type) {
    if (type === "stripe") return new StripePayment();
    if (type === "paypal") return new PayPalPayment();
    throw new Error("Invalid payment method");
  }
}

// Usage
const payment = PaymentFactory.createPaymentMethod("stripe");
payment.process(); // Processing payment via Stripe

Why use it?

• Decouples object creation from the main logic.
• Easily extendable for new payment methods.

3. The Observer Pattern

The Observer pattern is perfect for event-driven applications, such as real-time notifications, messaging apps, or pub/sub systems. It allows one part of the app to “observe” changes in another without tightly coupling them.

Example: Event Emitter for Notifications

const EventEmitter = require("events");

class NotificationService extends EventEmitter {
  sendEmail(email) {
    console.log(`Sending email to ${email}`);
    this.emit("emailSent", email);
  }
}

const notificationService = new NotificationService();

// Add observers
notificationService.on("emailSent", (email) => {
  console.log(`Email successfully sent to ${email}`);
});

// Usage
notificationService.sendEmail("user@example.com");

Why use it?

• Ideal for real-time applications (e.g., WebSockets, microservices).
• Reduces coupling between modules.

4. The Middleware Pattern

If you’ve ever worked with Express.js, you’ve already used the Middleware pattern! It chains functions together so they process requests in a sequence. This makes it easy to handle authentication, logging, and validation separately.

Example: Express Middleware for Authentication

const express = require("express");
const app = express();

// Middleware function
const authMiddleware = (req, res, next) => {
  if (req.headers.authorization === "Bearer my-secret-token") {
    next(); // Proceed to the next middleware
  } else {
    res.status(401).send("Unauthorized");
  }
};

app.use(authMiddleware);

app.get("/", (req, res) => {
  res.send("Welcome, authenticated user!");
});

app.listen(3000, () => console.log("Server running on port 3000"));

Why use it?

• Clean separation of concerns.
• Reusable logic for logging, authentication, and validation.

5. The Proxy Pattern

The Proxy pattern acts as a placeholder for another object, controlling access to it. This is especially useful for caching, rate-limiting, and API requests to reduce unnecessary computations.

Example: Caching API Calls

class API {
  fetchData() {
    console.log("Fetching data from API...");
    return { data: "API response" };
  }
}

class CachedAPI {
  constructor() {
    this.api = new API();
    this.cache = null;
  }

  fetchData() {
    if (!this.cache) {
      this.cache = this.api.fetchData();
    }
    return this.cache;
  }
}

// Usage
const api = new CachedAPI();
console.log(api.fetchData()); // Fetches from API
console.log(api.fetchData()); // Returns cached data

Why use it?

• Reduces API calls, improving performance.
• Useful for caching expensive operations.

Wrapping Up

Design patterns are game-changers for building scalable applications in Node.js. Here’s a quick recap:

→ Singleton — One instance shared across the app (e.g., database connections).

→ Factory — Creates objects dynamically (e.g., different payment processors).

→ Observer — Event-driven programming (e.g., notifications, WebSockets).

→ Middleware — Chainable logic execution (e.g., Express.js middlewares).

→ Proxy — Controls access to objects (e.g., caching API responses).

By using these patterns, you’ll write cleaner, scalable, and more efficient Node.js applications.