Server Fundamentals

A backend server is a long-running process that listens for network requests, runs application code, and sends responses. The core loop is simple: parse the request, choose a route, run a handler, produce a response. Production quality comes from making each step explicit and predictable.

The Request Lifecycle

Most web servers follow the same flow:

1. Accept an HTTP request from a client.
2. Match the method and path to a route.
3. Parse path params, query params, headers, and body.
4. Validate input.
5. Call domain or data access code.
6. Serialize the response.

type RequestContext = {
  method: "GET" | "POST";
  path: string;
  body?: unknown;
};

type HttpResponse<T> = {
  status: number;
  body: T;
};

function route(req: RequestContext): HttpResponse<{ message: string }> {
  if (req.method === "GET" && req.path === "/health") {
    return { status: 200, body: { message: "ok" } };
  }

  return { status: 404, body: { message: "Not found" } };
}

Keep Handlers Thin

A route handler should translate HTTP concerns into application calls. It should not contain every business rule, database query, and response format in one function.

type CreateUserInput = { email: string; name: string };

function createUser(input: CreateUserInput) {
  return {
    id: crypto.randomUUID(),
    email: input.email.toLowerCase(),
    name: input.name.trim(),
  };
}

Failure Paths Matter

Every server path needs a clear answer for invalid input, missing resources, permission failures, and unexpected exceptions. Consistent responses make client code easier to write and support teams easier to help.

Further Learning

Search these terms to go deeper:

• “HTTP request lifecycle backend” — how servers receive, route, and respond to requests
• “thin controllers service layer pattern” — keeping route handlers small
• “Node.js event loop server requests” — how JavaScript servers handle concurrent work
• “backend input validation patterns” — validating unknown request data

Server Fundamentals

A backend server is a program that sits and waits for requests (like a waiter waiting for orders), does some work, and sends back a response. Every server, no matter how fancy, follows the same basic loop.

The loop

1. A request arrives (“give me user #5”).
2. The server figures out which code should handle it (routing).
3. It reads the details of the request (path, query, body).
4. It checks the input makes sense (validation).
5. It does the actual work (talks to a database, etc).
6. It sends back a response.

function route(req) {
  if (req.method === 'GET' && req.path === '/health') {
    return { status: 200, body: { message: 'ok' } }
  }
  return { status: 404, body: { message: 'Not found' } }
}

Keep the “web part” separate from the “business part”

A common mistake is cramming everything into one function — parsing the request, validating it, doing the database work, and formatting the reply, all mixed together. Better: keep the HTTP-handling thin, and hand off the real work to plain functions:

function createUser(input) {
  return { id: crypto.randomUUID(), email: input.email.toLowerCase() }
}

Now createUser doesn’t know or care that it was called from an HTTP request — you could call it from a script, a test, or a queue job too.

Never trust the input

In one sentence

A server’s job is always the same loop — receive, route, validate, process, respond — and keeping the “handle the HTTP part” code separate from “do the actual work” code makes it much easier to test and reuse.

Want to go deeper?

Switch to Expert mode above for the full request-context typing and thin-handler patterns.