Node.js Backend Development in 2026: Patterns & Scaling

// Fastify — typed, schema-validated, fast
import Fastify from 'fastify';

const app = Fastify({ logger: true });

// JSON Schema for request validation — runs before the handler
const createOrderSchema = {
  body: {
    type: 'object',
    required: ['userId', 'items'],
    properties: {
      userId: { type: 'string', format: 'uuid' },
      items: {
        type: 'array',
        minItems: 1,
        items: {
          type: 'object',
          required: ['productId', 'quantity'],
          properties: {
            productId: { type: 'string' },
            quantity: { type: 'integer', minimum: 1 },
          },
        },
      },
    },
  },
};

app.post('/orders', { schema: createOrderSchema }, async (request, reply) => {
  const { userId, items } = request.body; // TypeScript knows the shape
  const order = await OrderService.create(userId, items);
  return reply.status(201).send({ orderId: order.id });
});

await app.listen({ port: 3000, host: '0.0.0.0' });

// This BLOCKS the event loop — all other requests wait
app.get('/blocking', async (request, reply) => {
  const result = expensiveSync(request.body.data); // 300ms of CPU work
  return { result };
});

// This does NOT block — I/O is non-blocking
app.get('/non-blocking', async (request, reply) => {
  const data = await db.query('SELECT * FROM orders WHERE id = $1', [request.params.id]);
  // While the DB query runs, other requests are handled
  return data.rows[0];
});

// workers/image-processor.ts
import { workerData, parentPort } from 'worker_threads';
import sharp from 'sharp';

// This runs in a separate thread — doesn't block the main event loop
async function processImage() {
  const { imageBuffer, width, height } = workerData;

  const result = await sharp(Buffer.from(imageBuffer))
    .resize(width, height)
    .webp({ quality: 85 })
    .toBuffer();

  parentPort?.postMessage({ result: result.toString('base64') });
}

processImage();

// In your route handler
import { Worker } from 'worker_threads';
import path from 'path';

function processImageInWorker(imageBuffer: Buffer, width: number, height: number): Promise<string> {
  return new Promise((resolve, reject) => {
    const worker = new Worker(path.join(__dirname, 'workers/image-processor.js'), {
      workerData: { imageBuffer: imageBuffer.buffer, width, height },
    });

    worker.on('message', (msg) => resolve(msg.result));
    worker.on('error', reject);
  });
}

app.post('/images/resize', async (request, reply) => {
  const { imageData, width, height } = request.body;
  const resized = await processImageInWorker(Buffer.from(imageData, 'base64'), width, height);
  return { image: resized };
});

import Piscina from 'piscina';

const pool = new Piscina({
  filename: path.resolve(__dirname, 'workers/image-processor.js'),
  maxThreads: 4, // limit based on CPU cores
});

// Reuses threads from the pool
const result = await pool.run({ imageBuffer, width, height });

import { createServer } from 'http';

const server = createServer(app.server); // Fastify's underlying http server

async function gracefulShutdown(signal: string) {
  console.log(`${signal} received — draining connections`);

  server.close(async () => {
    await app.close(); // close Fastify, database connections, etc.
    process.exit(0);
  });

  // Force exit after 30s if connections don't drain
  setTimeout(() => {
    console.error('Forced shutdown after timeout');
    process.exit(1);
  }, 30_000);
}

process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
process.on('SIGINT', () => gracefulShutdown('SIGINT'));

// Catch unhandled rejections — log and exit rather than continue in broken state
process.on('unhandledRejection', (reason) => {
  console.error('Unhandled rejection:', reason);
  process.exit(1);
});

// config/env.ts
import { z } from 'zod';

const envSchema = z.object({
  NODE_ENV: z.enum(['development', 'test', 'production']),
  PORT: z.coerce.number().default(3000),
  DATABASE_URL: z.string().url(),
  JWT_SECRET: z.string().min(32),
  REDIS_URL: z.string().url().optional(),
});

function validateEnv() {
  const result = envSchema.safeParse(process.env);

  if (!result.success) {
    console.error('Invalid environment variables:');
    console.error(result.error.flatten().fieldErrors);
    process.exit(1); // fail fast at startup, not later in production
  }

  return result.data;
}

export const env = validateEnv();

import pino from 'pino';

export const logger = pino({
  level: process.env.NODE_ENV === 'production' ? 'info' : 'debug',
  transport: process.env.NODE_ENV !== 'production'
    ? { target: 'pino-pretty' } // human-readable in development
    : undefined,               // JSON in production for log aggregators
});

// Usage
logger.info({ userId: '123', orderId: 'abc' }, 'Order created');
logger.error({ err, requestId: req.id }, 'Payment processing failed');