Node.js memory exhaustion: why apps crash on large files and how to prevent it

A script might run smoothly with modest fixtures in development, only to crash when faced with production data. The primary culprit is buffering complete files into memory rather than streaming them incrementally.

Node.js allocates heap memory within bounded limits. Loading massive payloads at once exhausts the V8 heap and triggers process termination. Streams solve this problem by handling data in continuous, bounded chunks.

The problem and production context

Node.js processes run on the V8 engine, which historically limits heap memory consumption to approximately 1.4 GB to 4 GB depending on architecture and host configuration flags. When background workers or HTTP handlers read files into contiguous memory buffers, the process memory footprint scales linearly with file size.

• Failure scenario: A batch import job executes fs.readFile on a 2.5 GB database dump or CSV file. The V8 heap allocation exceeds available limits, triggering an ERR_STRING_TOO_LONG or fatal JavaScript heap out of memory crash that terminates the Node.js process immediately.
• Why default approaches fall short: Convenience methods like fs.readFile and fs.readFileSync load the entire file payload into a single buffer or UTF-8 string before invoking callbacks or returning values. This creates immediate heap bloat and locks CPU cycles in garbage collection sweeps.
• Production impact: Unhandled heap exhaustion crashes background workers, drops active user connections, corrupts in-flight transaction pipelines, and causes Kubernetes pods to trigger repeated crash loops.

Adopting streaming architectures prevents these failures:

• Prevents ENOMEM errors and out-of-memory crashes in production.
• Keeps memory usage predictable even with multi-gigabyte files.
• Improves throughput and reliability for data pipelines, log processors, and media jobs.
• Reduces infrastructure requirements by avoiding artificial memory spikes.

Mental model and core concepts

1. Buffer accumulation failure in fs.readFile

fs.readFile buffers the entire file contents into RAM before passing the buffer or string to your callback:

import { readFile } from "node:fs";

readFile("./mega-database.sql", "utf8", (error, data) => {
  if (error) throw error;
  parseSQL(data);
});

This works for configuration files and small assets, but becomes dangerous when handling files larger than the available heap.

2. Stream-based incremental chunk processing

Readable streams emit chunks of data as they are read from disk. Processing data piece by piece allows the garbage collector to reclaim memory continuously:

import { createReadStream } from "node:fs";

const stream = createReadStream("./giant-dataset.csv", { encoding: "utf8" });

stream.on("data", (chunk) => {
  analyzeChunk(chunk);
});

stream.on("end", () => {
  console.log("Done without memory explosion");
});

3. Backpressure-safe stream pipelines

Using stream.pipeline automatically manages backpressure between readable and writable streams, closing resources properly if an error occurs:

import { createReadStream, createWriteStream } from "node:fs";
import { pipeline } from "node:stream";
import { createGzip } from "node:zlib";

pipeline(
  createReadStream("./server.log"),
  createGzip(),
  createWriteStream("./server.log.gz"),
  (error) => {
    if (error) {
      console.error("Pipeline failed", error);
      return;
    }

    console.log("Compression completed");
  }
);

4. Handling large JSON datasets with streaming formats

Standard JSON.parse requires the full payload in memory as a single string. For large exports, consider newline-delimited JSON (NDJSON) or streaming parsers like stream-json.

5. Chunk-aware parsing and record boundary framing

Splitting streams on record delimiters (such as newlines in CSV or log files) avoids accumulating partial chunks in memory and prevents parser buffer overflows.

6. File system API selection boundaries

Choosing between buffering and streaming depends on data predictability:

• Use readFile for small, bounded files such as local configuration files.
• Use streams for payloads that can scale arbitrarily, including user uploads, database dumps, and server logs.

Production implementation

The following implementation demonstrates memory-safe line-by-line processing using readline and an async iterator over an NDJSON export.

import { createReadStream } from "node:fs";
import { createInterface } from "node:readline";

async function importUsersFromNdjson(filePath) {
  const fileStream = createReadStream(filePath, { encoding: "utf8" });
  const reader = createInterface({ input: fileStream, crlfDelay: Infinity });

  for await (const line of reader) {
    if (!line.trim()) continue;
    const user = JSON.parse(line);
    await insertIntoDatabase(user);
  }
}

Memory consumption stays flat throughout execution regardless of whether the file contains ten rows or ten million rows.

Architectural trade-offs and edge cases

• Latency versus consistency: Streaming trades minimal overall execution latency improvements for strictly bounded memory consumption. Line-by-line streaming yields steady progressive throughput, whereas monolithic buffering requires high up-front memory before processing begins.
• Failure recovery: If a stream pipeline encounters an I/O read failure mid-file, partial data may have already been written downstream. Processing logic must use idempotent database operations, checkpoint cursors, or transaction boundaries to recover cleanly from mid-stream failures.
• Scale limitations: In high-concurrency environments, opening thousands of concurrent disk streams exhausts operating system file descriptors (EMFILE). Stream concurrency must be governed through bounded worker queues or p-limit throttles.

Common anti-patterns and gotchas

• Using readFile or readFileSync on unbounded inputs: Buffering files of unknown or user-supplied dimensions risks immediate V8 heap exhaustion and process death.
• Parsing gigabyte-scale JSON arrays with JSON.parse: Passing massive multi-megabyte string payloads into JSON.parse spikes heap allocations and locks the event loop during string parsing.
• Piping streams manually with stream.pipe(): Calling .pipe() directly does not automatically clean up destination file descriptors on source stream errors, causing silent memory and descriptor leaks. Always use stream.pipeline().
• Mixing synchronous file APIs into high-concurrency event loops: Using methods like fs.readFileSync blocks the single-threaded Node.js event loop, preventing all concurrent requests from progressing.
• Omitting memory monitoring during background batch jobs: Running large imports without observing memory footprints prevents detecting memory leaks caused by lingering global references.

Implementation checklist

1. Audit codebase to identify unbounded fs.readFile and fs.readFileSync invocations.
2. Replace monolithic file reads with fs.createReadStream pipelines.
3. Replace raw .pipe() invocations with stream.pipeline to ensure backpressure management and proper descriptor cleanup.
4. Structure large exports using Newline-Delimited JSON (NDJSON) rather than monolithic JSON arrays.
5. Track heap metrics using process.memoryUsage() inside long-running batch jobs.
6. Convert bulk export pipelines from monolithic JSON arrays to NDJSON.
7. Wrap stream pipelines with structured retries and cleanup hooks.
8. Stress-test file processors against multi-gigabyte datasets during integration testing.