What are common design patterns in Node.js?

Question

IT Interview Practice · Accepted Answer

Node.js leans on a handful of design patterns that fit its module system, async model, and streaming I/O. The most common ones every backend developer should recognize:

## Creational

- **Module pattern** — each file is its own scope; you expose a public API via `module.exports` / `export`, keeping internals private. The foundation of code organization in Node.
- **Singleton** — a module's exports are **cached**, so exporting an instance gives every importer the same object. Perfect for a DB pool or config.

```js
// db.js — every `require("./db")` gets this same pool (singleton via module cache).
const pool = createPool(process.env.DATABASE_URL);
module.exports = pool;
```

- **Factory** — a function that creates and returns objects, hiding construction logic and letting you swap implementations.

```js
function createLogger(kind) {
  return kind === "json" ? new JsonLogger() : new TextLogger();
}
```

## Behavioral

- **Observer / EventEmitter** — the core Node async pattern: emit named events, attach listeners. `EventEmitter`, streams, and most core modules use it.

```js
const { EventEmitter } = require("node:events");
const bus = new EventEmitter();
bus.on("order:paid", (o) => sendReceipt(o));
bus.emit("order:paid", order);
```

- **Middleware** — a pipeline of functions each receiving `(ctx, next)`, popularized by Express/Koa. Great for cross-cutting concerns (auth, logging, validation).

```js
app.use((req, res, next) => { req.startedAt = Date.now(); next(); });
```

- **Strategy** — select an algorithm at runtime (e.g. pick a payment provider or a hashing strategy behind one interface).

## Structural

- **Adapter** — wrap a third-party API in your own interface so you can swap vendors without touching call sites.
- **Streams (pipeline)** — compose readable → transform → writable stages to process data incrementally with backpressure, instead of buffering everything in memory.

```js
const { pipeline } = require("node:stream/promises");
await pipeline(fs.createReadStream("in"), gzip(), fs.createWriteStream("out.gz"));
```

- **Dependency Injection** — pass collaborators (db, logger, clients) into a module instead of importing them directly; makes code testable and decoupled. Frameworks like **NestJS** build DI in; you can also do it by hand via constructor/function arguments.

## Rule of thumb

| Need | Pattern |
|---|---|
| One shared resource | Singleton (module cache) |
| Build objects, hide `new` | Factory |
| React to async events | Observer / EventEmitter |
| Cross-cutting request logic | Middleware |
| Process big data safely | Streams / pipeline |
| Testable, decoupled deps | Dependency Injection |

## Why it matters

Patterns are a shared vocabulary: saying "the config is a module-cached singleton" or "auth is middleware" communicates a design in a few words. Node's own core (EventEmitter, streams, the module system) is built from these, so recognizing them helps you read frameworks and structure your own services. Interviewers use this question to check that you don't just wire callbacks ad hoc, but reach for the pattern that fits — and know its trade-offs, like a singleton making global state harder to test.

Need	Pattern
One shared resource	Singleton (module cache)
Build objects, hide `new`	Factory
React to async events	Observer / EventEmitter
Cross-cutting request logic	Middleware
Process big data safely	Streams / pipeline
Testable, decoupled deps	Dependency Injection

Creational

Behavioral

Structural

Rule of thumb

Why it matters

Related questions