What Is Serverless? A Complete Guide to Serverless Computing (2025)

Serverless computing lets you run code without provisioning or managing servers. You write a function, deploy it, and the cloud provider handles everything else — scaling, patching, availability, and billing by the millisecond.

Despite the name, there are servers — you just never see them. The "serverless" refers to the developer experience: zero server management.

Serverless in 30 seconds

Traditional servers vs serverless

Before serverless, deploying an API meant:

1. Provision a server — pick instance size, OS, runtime
2. Install dependencies — Node.js, Python, packages
3. Configure scaling — load balancer, auto-scaling groups
4. Pay 24/7 — even when zero traffic hits your app
5. Patch and update — OS patches, security updates
6. Monitor the host — CPU, memory, disk alerts

With serverless:

1. Write a function — just the business logic
2. Deploy — one command
3. It scales automatically — from 0 to millions of requests
4. Pay per request — zero traffic = zero cost
5. No patching — provider manages the runtime

How serverless actually works

User Request
     │
     ▼
┌─────────────┐
│  API Gateway │  ← Receives HTTP request
└──────┬──────┘
       │ Triggers
       ▼
┌─────────────┐
│   Function  │  ← Your code runs here (Lambda, Cloud Function, etc.)
│  Container  │
└──────┬──────┘
       │ Reads/Writes
       ▼
┌─────────────────────────────────────────┐
│  Cloud Services: DB, Storage, Queue...  │
└─────────────────────────────────────────┘
       │
       ▼
  Response to User

Lifecycle of a serverless invocation:

1. Event triggers the function (HTTP request, S3 upload, SQS message…)
2. Cloud provider allocates a container (or reuses a warm one)
3. Your function code executes
4. Function returns a response
5. Container stays warm briefly, then is recycled
6. You're billed only for execution duration + memory used

Types of serverless

FaaS vs BaaS

Major serverless platforms compared

Your first serverless function

AWS Lambda (Node.js)

// handler.js
export const handler = async (event) => {
  const name = event.queryStringParameters?.name ?? 'World';

  return {
    statusCode: 200,
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ message: `Hello, ${name}!` }),
  };
};

Deploy with Serverless Framework:

# serverless.yml
service: hello-api
provider:
  name: aws
  runtime: nodejs20.x
  region: us-east-1

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

npm install -g serverless
serverless deploy
# → Endpoint: GET - https://xyz.execute-api.us-east-1.amazonaws.com/hello

Google Cloud Functions (Python)

# main.py
import functions_framework
from flask import jsonify

@functions_framework.http
def hello(request):
    name = request.args.get('name', 'World')
    return jsonify(message=f'Hello, {name}!')

gcloud functions deploy hello \
  --runtime python312 \
  --trigger-http \
  --allow-unauthenticated

Cloudflare Workers

// worker.js
export default {
  async fetch(request) {
    const url = new URL(request.url);
    const name = url.searchParams.get('name') ?? 'World';

    return new Response(JSON.stringify({ message: `Hello, ${name}!` }), {
      headers: { 'Content-Type': 'application/json' },
    });
  },
};

npx wrangler deploy

Common serverless triggers

Cold starts explained

A cold start happens when there is no warm container ready for your function:

First request (cold start):
─────────────────────────────────────────────────
   Init container  │  Download code  │  Execute
      ~200ms       │     ~100ms      │  ~50ms
─────────────────────────────────────────────────
Total: ~350ms+

Subsequent requests (warm start):
─────────────────
      Execute
       ~50ms
─────────────────
Total: ~50ms

What causes cold starts?

How to minimize cold starts

Serverless pricing models

AWS Lambda pricing (2025)

Example cost calculation:

10 million requests/month
Average duration: 200ms per invocation
Memory: 256 MB

GB-seconds = 10,000,000 × 0.2s × 0.25GB = 500,000 GB-s

Cost = (10M - 1M free) × $0.20/M        = $1.80
     + (500k - 400k free) × $0.0000166  = $1.67
Total = ~$3.47/month

Compare to: 1× t3.small EC2 instance = ~$15/month (always on)

Pricing comparison

Real-world use cases

Serverless vs containers vs VMs

Serverless vs microservices

These are often confused. They solve different problems:

You can have: serverless microservices (small functions per domain) or container-based microservices.

Serverless architecture patterns

1. Simple API

Client → API Gateway → Lambda function → Database

2. Async processing

Client → API → SQS Queue → Lambda worker → Database
                                         → Notify user

3. Event-driven pipeline

S3 upload → Lambda (resize) → S3 output
           → Lambda (extract metadata) → DynamoDB
           → Lambda (send notification) → SNS/SQS

4. Saga pattern (distributed transactions)

Lambda A → publishes event
         → Lambda B handles event
                → publishes event
                → Lambda C handles event
                      → success or compensating transaction

5. Fan-out

SNS topic → Lambda A (send email)
          → Lambda B (update DB)
          → Lambda C (log analytics)

Serverless frameworks and tools

Serverless Framework example (full stack)

# serverless.yml
service: my-api
frameworkVersion: '3'

provider:
  name: aws
  runtime: nodejs20.x
  region: eu-west-1
  environment:
    TABLE_NAME: !Ref UsersTable

functions:
  getUser:
    handler: src/users.get
    events:
      - httpApi:
          path: /users/{id}
          method: GET
  createUser:
    handler: src/users.create
    events:
      - httpApi:
          path: /users
          method: POST

resources:
  Resources:
    UsersTable:
      Type: AWS::DynamoDB::Table
      Properties:
        TableName: users
        BillingMode: PAY_PER_REQUEST
        AttributeDefinitions:
          - AttributeName: id
            AttributeType: S
        KeySchema:
          - AttributeName: id
            KeyType: HASH

Observability in serverless

Since you can't SSH into a server, observability is critical:

Key metrics to watch:

Limitations and trade-offs

When to use serverless (and when not to)

Use serverless when:

Don't use serverless when:

Serverless security best practices

Serverless vs traditional: cost comparison

Scenario: API handling 10M requests/month, 200ms avg, 128MB memory

Tipping point: For sustained high traffic (millions of req/hour), containers become cheaper. For bursty or low traffic, serverless wins.

Serverless vs serverless containers

Cloud Run example:

# Dockerfile
FROM node:20-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --production
COPY . .
EXPOSE 8080
CMD ["node", "server.js"]

gcloud run deploy my-api \
  --source . \
  --region us-central1 \
  --allow-unauthenticated
# Scales from 0 to N automatically

Serverless design principles

Common mistakes

Serverless vs related terms

FAQ

Q: Is serverless really serverless? No — there are physical servers somewhere. "Serverless" means you don't manage any servers. The cloud provider owns, patches, and scales the infrastructure.

Q: Can I run a database serverless? Yes. Options include: DynamoDB (on-demand mode), Aurora Serverless v2, PlanetScale, Neon (serverless Postgres), Turso (SQLite at the edge), and MongoDB Atlas Serverless.

Q: Is serverless cheaper than containers? Depends on traffic. For low/bursty traffic: serverless wins (scales to zero). For sustained high RPS (e.g. 1000 req/sec 24/7): containers are often cheaper. Run the math for your specific workload.

Q: How do I test serverless functions locally?

• AWS Lambda: AWS SAM CLI (sam local invoke), LocalStack
• Cloud Functions: Functions Framework (functions-framework --target=hello)
• Cloudflare Workers: Wrangler (wrangler dev)
• Any: Write pure functions with no cloud SDK dependencies, then test with unit tests

Q: What languages can I use for serverless? AWS Lambda natively supports Node.js, Python, Java, Go, Ruby, .NET, and PowerShell. Via custom runtimes, you can use any language (Rust, PHP, Swift, etc.). Cloud Run/Fargate support any language that runs in Docker.

Q: Is serverless good for machine learning inference? For lightweight models: yes. AWS Lambda supports up to 10GB memory and 10GB ephemeral storage — enough for small models. For heavy inference (large LLMs, GPUs), use SageMaker, GPU instances, or dedicated containers.