Jeff Bruchado
Back to blog

Serverless in 2025: Why Node.js Dominates (And How to Use It)

Remember when "serverless" seemed like just passing hype? In 2025, serverless isn't a trend anymore - it's mainstream. And there's a clear reason why Node.js has become the dominant language in this ecosystem: fast cold start, lightweight runtime, and massive ecosystem.

Companies like Netflix process billions of serverless requests per day. Coca-Cola reduced infrastructure costs by 65% migrating to serverless. And individual developers create applications that automatically scale from 0 to millions of users - without touching a single server.

But how do you actually build robust serverless applications with Node.js? Let's explore from basics to advanced patterns used in production.

What Is Serverless and Why Use Node.js

Serverless doesn't mean "no servers" - it means you don't manage servers. You write functions, deploy them, and the provider takes care of everything: scaling, availability, security, patches.

Node.js dominates serverless for solid technical reasons:

  1. Fast cold start: ~100-200ms vs seconds in Python/Java
  2. Lightweight runtime: Less memory = lower costs
  3. Native event-driven: Perfect for serverless architecture
  4. npm ecosystem: Millions of ready packages
  5. Universal JavaScript: Same code on front and backend

Your First Serverless Function with AWS Lambda

Let's start with the basics - a simple Lambda function:

// handler.js - Basic Lambda function
export const handler = async (event) => {
  console.log('Event received:', JSON.stringify(event, null, 2));

  const body = event.body ? JSON.parse(event.body) : event;

  const response = {
    message: 'Hello from Lambda!',
    input: body,
    timestamp: new Date().toISOString()
  };

  return {
    statusCode: 200,
    headers: {
      'Content-Type': 'application/json',
      'Access-Control-Allow-Origin': '*'
    },
    body: JSON.stringify(response)
  };
};

Deploy with Serverless Framework

# serverless.yml
service: my-api

provider:
  name: aws
  runtime: nodejs20.x
  region: us-east-1
  memorySize: 256
  timeout: 10

functions:
  hello:
    handler: handler.handler
    events:
      - http:
          path: /hello
          method: POST
          cors: true

  processUser:
    handler: users.process
    events:
      - http:
          path: /users/{id}
          method: GET
      - sns:
          topicName: user-updates

plugins:
  - serverless-offline
  - serverless-webpack
// users.js - More complex function
import AWS from 'aws-sdk';

const dynamodb = new AWS.DynamoDB.DocumentClient();
const TABLE_NAME = process.env.USERS_TABLE || 'users';

export const process = async (event) => {
  const userId = event.pathParameters?.id;

  if (!userId) {
    return {
      statusCode: 400,
      body: JSON.stringify({ error: 'User ID is required' })
    };
  }

  try {
    const result = await dynamodb.get({
      TableName: TABLE_NAME,
      Key: { userId }
    }).promise();

    if (!result.Item) {
      return {
        statusCode: 404,
        body: JSON.stringify({ error: 'User not found' })
      };
    }

    const processedUser = {
      ...result.Item,
      lastAccessed: new Date().toISOString(),
      processedBy: 'lambda'
    };

    await dynamodb.update({
      TableName: TABLE_NAME,
      Key: { userId },
      UpdateExpression: 'SET lastAccessed = :timestamp',
      ExpressionAttributeValues: {
        ':timestamp': processedUser.lastAccessed
      }
    }).promise();

    return {
      statusCode: 200,
      headers: {
        'Content-Type': 'application/json',
        'Cache-Control': 'max-age=300'
      },
      body: JSON.stringify(processedUser)
    };

  } catch (error) {
    console.error('Error processing user:', error);

    return {
      statusCode: 500,
      body: JSON.stringify({
        error: 'Internal server error',
        message: error.message
      })
    };
  }
};

Serverless deployment

Advanced Patterns: Production Serverless Architecture

Real serverless applications need robust patterns. Let's explore some:

1. Connection Pooling for Databases

A common mistake: creating new DB connection in each invocation. The solution? Global connection pooling:

// db.js - Optimized connection pooling
import mysql from 'mysql2/promise';

let pool = null;

export const getPool = () => {
  if (!pool) {
    pool = mysql.createPool({
      host: process.env.DB_HOST,
      user: process.env.DB_USER,
      password: process.env.DB_PASSWORD,
      database: process.env.DB_NAME,
      connectionLimit: 2, // Lambda: few connections!
      enableKeepAlive: true
    });

    console.log('Database pool created');
  }

  return pool;
};

export const handler = async (event) => {
  const pool = getPool(); // Reuses connection between invocations!

  try {
    const [rows] = await pool.execute(
      'SELECT * FROM users WHERE id = ?',
      [event.userId]
    );

    return {
      statusCode: 200,
      body: JSON.stringify(rows[0])
    };

  } catch (error) {
    console.error('Database error:', error);
    throw error;
  }
};

2. Middleware Pattern for Lambda Functions

Middleware makes functions cleaner and reusable:

// middleware.js - Middleware system for Lambda
export class LambdaMiddleware {
  constructor(handler) {
    this.handler = handler;
    this.middlewares = [];
  }

  use(middleware) {
    this.middlewares.push(middleware);
    return this;
  }

  async execute(event, context) {
    let index = 0;

    const next = async () => {
      if (index < this.middlewares.length) {
        const middleware = this.middlewares[index++];
        await middleware(event, context, next);
      } else {
        return this.handler(event, context);
      }
    };

    return await next();
  }
}

// Useful middlewares
export const jsonBodyParser = async (event, context, next) => {
  if (event.body && typeof event.body === 'string') {
    try {
      event.body = JSON.parse(event.body);
    } catch (error) {
      return {
        statusCode: 400,
        body: JSON.stringify({ error: 'Invalid JSON' })
      };
    }
  }
  return next();
};

export const cors = (origins = '*') => {
  return async (event, context, next) => {
    const result = await next();

    return {
      ...result,
      headers: {
        ...result.headers,
        'Access-Control-Allow-Origin': origins,
        'Access-Control-Allow-Methods': 'GET,POST,PUT,DELETE'
      }
    };
  };
};

export const errorHandler = async (event, context, next) => {
  try {
    return await next();
  } catch (error) {
    console.error('Error:', error);

    return {
      statusCode: error.statusCode || 500,
      body: JSON.stringify({
        error: error.message,
        requestId: context.requestId
      })
    };
  }
};

// Usage
import { LambdaMiddleware, jsonBodyParser, cors, errorHandler } from './middleware.js';

const mainHandler = async (event) => {
  const { name, email } = event.body;

  if (!name || !email) {
    const error = new Error('Name and email required');
    error.statusCode = 400;
    throw error;
  }

  return {
    statusCode: 200,
    body: JSON.stringify({
      message: 'User created',
      user: { name, email }
    })
  };
};

const middleware = new LambdaMiddleware(mainHandler);

middleware
  .use(jsonBodyParser)
  .use(cors())
  .use(errorHandler);

export const handler = (event, context) => middleware.execute(event, context);

3. Modern Providers: Beyond AWS

In 2025, there are excellent alternatives to AWS Lambda:

// Cloudflare Worker - Ultra-fast edge computing
export default {
  async fetch(request, env) {
    const url = new URL(request.url);

    if (url.pathname === '/api/users') {
      const cached = await env.KV_STORE.get('users', 'json');

      if (cached) {
        return new Response(JSON.stringify(cached), {
          headers: { 'Content-Type': 'application/json' }
        });
      }

      const users = await fetchUsers();

      await env.KV_STORE.put('users', JSON.stringify(users), {
        expirationTtl: 300
      });

      return new Response(JSON.stringify(users));
    }

    return new Response('Not found', { status: 404 });
  }
};
// Vercel Function
export default async function handler(request, response) {
  if (request.method !== 'POST') {
    return response.status(405).json({ error: 'Method not allowed' });
  }

  try {
    const data = request.body;

    const result = {
      message: 'Success',
      processed: data,
      timestamp: new Date().toISOString()
    };

    return response.status(200).json(result);

  } catch (error) {
    return response.status(500).json({ error: error.message });
  }
}

export const config = {
  runtime: 'edge',
};

Performance and Costs: Critical Optimization

Serverless can get expensive if poorly optimized. Essential strategies:

// Pre-load dependencies in global scope
import AWS from 'aws-sdk';
import database from './db.js';

const dynamodb = new AWS.DynamoDB.DocumentClient();
const pool = database.getPool();

// Warm-up connections
if (process.env.WARMUP) {
  console.log('Warming up...');
  pool.execute('SELECT 1').catch(console.error);
}

export const handler = async (event) => {
  // Connections ready - zero overhead!
  // Handler code...
};

The Future of Serverless and Node.js

In 2025, serverless is mature. Next evolutions include:

  • WebAssembly on edge: Native performance in Cloudflare/Vercel
  • Serverless containers: AWS Fargate and Cloud Run
  • AI-optimized functions: Serverless GPUs for ML
  • Multi-cloud orchestration: Terraform Cloud and Pulumi
  • Native observability: Integrated OpenTelemetry

Node.js will continue dominating because JavaScript is ubiquitous and the npm ecosystem is unbeatable. As a developer, mastering serverless with Node.js puts you in a privileged position to build the next generation of scalable applications.

If you want to explore more about modern architectures, I recommend reading my article about Microservices with Node.js: Modern Architecture in 2025 where I discuss patterns complementary to serverless.

Let's go! 🦅

📚 Want to Deepen Your JavaScript Knowledge?

This article covered serverless with Node.js, but there's much more to explore in modern development.

Developers who invest in solid, structured knowledge tend to have more opportunities in the market.

Complete Study Material

If you want to master JavaScript from basics to advanced, I've prepared a complete guide:

Investment options:

  • $4.90 (single payment)

👉 Learn About JavaScript Guide

💡 Material updated with industry best practices

Comments (0)

This article has no comments yet 😢. Be the first! 🚀🦅

Add comments