Serverless Architecture in 2025: Why Your Next API Should Be Serverless

Hello HaWkers, are you still maintaining servers running 24/7 waiting for requests? Paying for capacity you don't use 90% of the time? Spending sleepless nights configuring auto-scaling?

Serverless changed the game. In 2025, the question is no longer "should I use serverless?", but rather "why am I not using it yet?". I'll show you exactly how it works, when to use it, and real production code.

What Is Serverless (Really)?

Serverless DOES NOT mean "no servers". It means you don't manage servers.

Traditional model:

• You provision EC2/VPS
• Install Node.js, PM2, nginx
• Configure load balancer, auto-scaling
• Monitor CPU/RAM usage
• Pay 24/7, even without traffic

Serverless model:

• You write function
• Deploy with one command
• Platform manages everything
• Scales automatically (0 to millions of requests)
• Pay only for actual execution

Main Platforms in 2025

1. AWS Lambda (The Giant)

• Largest ecosystem (integration with 200+ AWS services)
• Supports Node.js, Python, Go, Java, .NET, Rust
• Cold start: ~100-200ms (improved a lot)
• Pricing: $0.20 per 1M requests + compute time

2. Vercel Functions (The Dev-Friendly)

• Deploy integrated with Git
• Global edge network
• Perfect for Next.js/React
• Cold start: ~50ms
• Pricing: 100k invocations free, then $0.40/1M

3. Cloudflare Workers (The Fastest)

• Edge computing (runs in 300+ cities)
• Cold start: ~0ms (always "warm")
• V8 isolates (not containers)
• Pricing: 100k/day free, then $0.50/1M

4. Netlify Functions (The Simple)

• Perfect integration with JAMstack
• Automatic deploy
• Good for startups
• Pricing: 125k/month free

Your First Function: Real Hello World

AWS Lambda + API Gateway:

// handler.js
exports.handler = async (event) => {
  const { name = 'World' } = event.queryStringParameters || {};

  return {
    statusCode: 200,
    headers: {
      'Content-Type': 'application/json',
      'Access-Control-Allow-Origin': '*'
    },
    body: JSON.stringify({
      message: `Hello, ${name}!`,
      timestamp: new Date().toISOString(),
      requestId: event.requestContext.requestId
    })
  };
};

Deploy with Serverless Framework:

# serverless.yml
service: hello-world-api

provider:
  name: aws
  runtime: nodejs20.x
  region: us-east-1

functions:
  hello:
    handler: handler.handler
    events:
      - httpApi:
          path: /hello
          method: get

# Deploy with one command
# serverless deploy

Result: API running at https://xxxxxxx.execute-api.us-east-1.amazonaws.com/hello?name=Jeff

Real Case: E-commerce API

Let's build complete products API with CRUD, validation and cache.

// api/products/index.js
import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
import { DynamoDBDocumentClient, ScanCommand } from '@aws-sdk/lib-dynamodb';

const client = new DynamoDBClient({});
const docClient = DynamoDBDocumentClient.from(client);

export const handler = async (event) => {
  const { httpMethod, pathParameters, body } = event;

  try {
    switch (httpMethod) {
      case 'GET':
        return pathParameters?.id
          ? await getProduct(pathParameters.id)
          : await listProducts();

      case 'POST':
        return await createProduct(JSON.parse(body));

      case 'PUT':
        return await updateProduct(pathParameters.id, JSON.parse(body));

      case 'DELETE':
        return await deleteProduct(pathParameters.id);

      default:
        return response(405, { error: 'Method not allowed' });
    }
  } catch (error) {
    console.error('Error:', error);
    return response(500, { error: error.message });
  }
};

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

// GET /products
async function listProducts() {
  const command = new ScanCommand({
    TableName: process.env.PRODUCTS_TABLE
  });

  const result = await docClient.send(command);

  return response(200, {
    products: result.Items,
    count: result.Count
  });
}

// GET /products/:id
async function getProduct(id) {
  const { GetCommand } = await import('@aws-sdk/lib-dynamodb');

  const command = new GetCommand({
    TableName: process.env.PRODUCTS_TABLE,
    Key: { id }
  });

  const result = await docClient.send(command);

  if (!result.Item) {
    return response(404, { error: 'Product not found' });
  }

  return response(200, result.Item);
}

// POST /products
async function createProduct(data) {
  const { PutCommand } = await import('@aws-sdk/lib-dynamodb');

  // Validation
  const errors = validateProduct(data);
  if (errors.length > 0) {
    return response(400, { errors });
  }

  const product = {
    id: crypto.randomUUID(),
    ...data,
    createdAt: new Date().toISOString(),
    updatedAt: new Date().toISOString()
  };

  const command = new PutCommand({
    TableName: process.env.PRODUCTS_TABLE,
    Item: product
  });

  await docClient.send(command);

  return response(201, product);
}

// PUT /products/:id
async function updateProduct(id, data) {
  const { UpdateCommand } = await import('@aws-sdk/lib-dynamodb');

  const errors = validateProduct(data, true);
  if (errors.length > 0) {
    return response(400, { errors });
  }

  // Build update expression dynamically
  const updateExpressions = [];
  const expressionAttributeNames = {};
  const expressionAttributeValues = {};

  Object.keys(data).forEach((key, index) => {
    updateExpressions.push(`#field${index} = :value${index}`);
    expressionAttributeNames[`#field${index}`] = key;
    expressionAttributeValues[`:value${index}`] = data[key];
  });

  updateExpressions.push('#updatedAt = :updatedAt');
  expressionAttributeNames['#updatedAt'] = 'updatedAt';
  expressionAttributeValues[':updatedAt'] = new Date().toISOString();

  const command = new UpdateCommand({
    TableName: process.env.PRODUCTS_TABLE,
    Key: { id },
    UpdateExpression: `SET ${updateExpressions.join(', ')}`,
    ExpressionAttributeNames: expressionAttributeNames,
    ExpressionAttributeValues: expressionAttributeValues,
    ReturnValues: 'ALL_NEW'
  });

  const result = await docClient.send(command);

  return response(200, result.Attributes);
}

// DELETE /products/:id
async function deleteProduct(id) {
  const { DeleteCommand } = await import('@aws-sdk/lib-dynamodb');

  const command = new DeleteCommand({
    TableName: process.env.PRODUCTS_TABLE,
    Key: { id }
  });

  await docClient.send(command);

  return response(204, null);
}

// Product validation
function validateProduct(data, isUpdate = false) {
  const errors = [];

  if (!isUpdate && !data.name) {
    errors.push('Name is required');
  }

  if (data.name && data.name.length < 3) {
    errors.push('Name must be at least 3 characters');
  }

  if (!isUpdate && data.price === undefined) {
    errors.push('Price is required');
  }

  if (data.price !== undefined && (data.price < 0 || isNaN(data.price))) {
    errors.push('Price must be a positive number');
  }

  return errors;
}

Essential Optimizations

1. Reduce Cold Starts:

// ❌ Bad: Import inside function
export const handler = async () => {
  const AWS = require('aws-sdk'); // Import on each execution
  const db = new AWS.DynamoDB.DocumentClient();
  // ...
};

// ✅ Good: Import at top (reused)
const { DynamoDBDocumentClient } = require('@aws-sdk/lib-dynamodb');
const docClient = DynamoDBDocumentClient.from(new DynamoDBClient({}));

export const handler = async () => {
  // docClient is already instantiated
};

// ✅ Even better: Lazy loading
let docClient;

function getDocClient() {
  if (!docClient) {
    const { DynamoDBClient } = require('@aws-sdk/client-dynamodb');
    const { DynamoDBDocumentClient } = require('@aws-sdk/lib-dynamodb');
    docClient = DynamoDBDocumentClient.from(new DynamoDBClient({}));
  }
  return docClient;
}

2. Provisioned Concurrency (For critical APIs):

# serverless.yml
functions:
  api:
    handler: handler.handler
    provisionedConcurrency: 2 # Always 2 "warm" instances
    reservedConcurrency: 100 # Limits maximum concurrency

3. Smart Caching:

// In-memory cache (persists between invocations of same instance)
let cachedProducts = null;
let cacheExpiry = 0;

async function getProductsCached() {
  const now = Date.now();

  if (cachedProducts && now < cacheExpiry) {
    console.log('Cache hit!');
    return cachedProducts;
  }

  console.log('Cache miss, fetching...');
  const products = await fetchProductsFromDB();

  cachedProducts = products;
  cacheExpiry = now + (5 * 60 * 1000); // Cache for 5 minutes

  return products;
}

4. Optimized Bundle Size:

// ❌ Bad: Complete import
const _ = require('lodash');

// ✅ Good: Specific import
const debounce = require('lodash/debounce');

// ✅ Even better: Tree-shaking with ES modules
import { debounce } from 'lodash-es';

Powerful Integrations

1. S3 Triggers (Process uploads):

// Automatically resize images
export const handler = async (event) => {
  const s3 = new S3Client({});
  const sharp = require('sharp');

  for (const record of event.Records) {
    const bucket = record.s3.bucket.name;
    const key = record.s3.object.key;

    // Download image
    const { Body } = await s3.send(new GetObjectCommand({
      Bucket: bucket,
      Key: key
    }));

    const buffer = await streamToBuffer(Body);

    // Resize
    const resized = await sharp(buffer)
      .resize(800, 600, { fit: 'inside' })
      .jpeg({ quality: 80 })
      .toBuffer();

    // Upload resized version
    await s3.send(new PutObjectCommand({
      Bucket: bucket,
      Key: `thumbnails/${key}`,
      Body: resized,
      ContentType: 'image/jpeg'
    }));

    console.log(`✓ Resized ${key}`);
  }
};

2. EventBridge Scheduled (Cron jobs):

functions:
  sendDailyReport:
    handler: handlers/reports.daily
    events:
      - schedule:
          rate: cron(0 9 * * ? *) # Every day at 9am UTC
          enabled: true

// handlers/reports.js
export const daily = async () => {
  const users = await fetchActiveUsers();
  const report = generateReport(users);

  await sendEmail({
    to: 'admin@example.com',
    subject: 'Daily Report',
    body: report
  });

  console.log(`✓ Sent report to ${users.length} users`);
};

3. SQS Queues (Asynchronous processing):

// Producer: Sends messages to queue
export const createOrder = async (event) => {
  const sqs = new SQSClient({});
  const order = JSON.parse(event.body);

  await sqs.send(new SendMessageCommand({
    QueueUrl: process.env.ORDERS_QUEUE_URL,
    MessageBody: JSON.stringify(order)
  }));

  return response(202, { message: 'Order queued for processing' });
};

// Consumer: Processes messages from queue
export const processOrder = async (event) => {
  for (const record of event.Records) {
    const order = JSON.parse(record.body);

    try {
      await processPayment(order);
      await sendConfirmationEmail(order);
      await updateInventory(order);

      console.log(`✓ Order ${order.id} processed`);
    } catch (error) {
      console.error(`✗ Order ${order.id} failed:`, error);
      // Message goes back to queue (automatic retry)
      throw error;
    }
  }
};

Real Costs: Comparison

Scenario: API with 1M requests/month, 200ms average

Solution	Cost/month	Details
EC2 t3.small (24/7)	$17	+ $5 Load Balancer = $22
AWS Lambda	$0.40	$0.20 req + $0.20 compute
Vercel Functions	$0.40	After 100k free
Cloudflare Workers	$5	Paid plan ($5/month)

Serverless advantage: Saves 80-90% on low/medium traffic.

When serverless gets expensive:

• Constant high traffic (>10M req/month)
• Long-running functions (>15min)

When NOT to Use Serverless

Avoid for:

1. Persistent WebSockets (use EC2/ECS)
2. Heavy processing (ML training, video encoding)
3. Critical latency (<10ms consistent)
4. Persistent in-memory state (large caches)

Hybrid alternative:

// Serverless API + Traditional Worker
// Lambda for endpoints
export const api = async (event) => {
  // Process light request
  // For heavy tasks, send to queue
  await sqs.sendMessage({
    queueUrl: WORKER_QUEUE,
    body: JSON.stringify({ task: 'heavy-compute' })
  });
};

// EC2 worker processes queue
// Runs 24/7, optimized for heavy tasks

The Future of Serverless

2025 Trends:

• Edge computing (Cloudflare Workers, Vercel Edge)
• Serverless containers (AWS Fargate, Cloud Run)
• Streaming responses (progressive data)
• Integrated AI (embeddings, summarization)

To better understand async patterns essential in serverless, check out Discovering the Power of Async/Await in JavaScript.

Let's go! 🦅

💻 Master JavaScript for Real

The knowledge you gained in this article is just the beginning. There are techniques, patterns, and practices that transform beginner developers into sought-after professionals.

Invest in Your Future

I've prepared complete material for you to master JavaScript:

Payment options:

• $4.90 (single payment)

📖 View Complete Content