All 15 Architecture & Design Patterns questions
More in Architecture & Design Patterns
What is the Module pattern in Node.js, and how does it enable encapsulation? How is the Factory pattern commonly applied in Node.js applications, and what problem does it solve? What is the Middleware (Chain of Responsibility) pattern as implemented by Express, and how does the 'next()' function drive it? What is Dependency Injection, and how is it typically implemented in Node.js given the language has no built-in DI container? What is the Strategy pattern, and how would you apply it to support multiple payment providers in a Node.js checkout service? What is a layered (n-tier) architecture in a Node.js/Express application, and what are its typical layers? What is the Repository pattern, and how does it help decouple business logic from a specific database technology? What is the Observer pattern, and how does Node.js's EventEmitter class implement it natively? What is Domain-Driven Design (DDD), and how do its concepts of entities, value objects, and aggregates apply to a Node.js codebase? What is a Hexagonal Architecture (Ports and Adapters), and what specific benefit does it provide for a Node.js API?
Advertisement
Back to results for “Architecture”
Node.js › Architecture & Design Patterns

What is the Singleton pattern, and what are the specific risks of using it in a Node.js application?

Intermediate

Answer

A Singleton ensures only one instance of a class or module-level object exists and is shared across the entire application -- in Node.js this is trivially achieved because a required module is cached and reused by reference after its first load, so a module that exports a single instantiated object naturally behaves as a singleton. The main risk is that singletons introduce hidden global state, making unit tests harder to isolate (state can leak between tests) and creating implicit coupling between unrelated parts of the codebase that all depend on the same shared instance.
// database.js -- naturally a singleton due to module caching
class Database {
  constructor() { this.connection = connectToDb(); }
}
module.exports = new Database(); // same instance returned on every require()
Real-world example A connection-pool manager is implemented as a module-level singleton so that every part of an application shares the same underlying pool of database connections, but this later complicates testing until the team refactors to inject the pool explicitly rather than importing the singleton directly.

Common follow-ups: How would you refactor a singleton-based module to be more testable via dependency injection?;What happens to a 'singleton' module if it's required from two different node_modules copies of the same package?

Design Patterns in JavaScript;Modules (CommonJS/ESM)
All 15 Architecture & Design Patterns questions