Express.js is the minimalist, unopinionated Node.js web framework that provides HTTP routing and middleware composition — enabling JavaScript/TypeScript developers to build REST APIs, web servers, and AI application backends using Node.js's event-driven, non-blocking I/O model, making it the standard backend framework for full-stack JavaScript applications and AI tools built with Next.js frontends.
What Is Express.js?
- Definition: A thin web application framework for Node.js that provides HTTP routing (matching URLs to handler functions), request/response helpers, and a middleware pipeline (chain of functions that process requests sequentially) — leaving all other architectural decisions to the developer.
- Middleware Pattern: Express's core abstraction is a chain of middleware functions (req, res, next) — each middleware can read/modify the request, send a response, or call next() to pass to the next middleware. This enables modular cross-cutting concerns (auth, logging, rate limiting).
- Unopinionated: Express imposes no project structure, no ORM, no auth system — developers compose their stack from npm packages (Passport.js for auth, Sequelize for ORM, multer for file uploads, etc.).
- Node.js Event Loop: Express inherits Node.js's single-threaded event loop — non-blocking I/O means a single process handles thousands of concurrent connections efficiently, ideal for I/O-bound workloads like concurrent LLM API calls.
- Ecosystem: Express is the foundation of dozens of meta-frameworks (Feathers, Sails, Loopback) and inspired Next.js API routes, Fastify, and Hono — the most downloaded web framework on npm.
Why Express Matters for AI/ML (JavaScript Stack)
- AI Application Backends: Full-stack AI applications with Next.js frontends often use Express (or Next.js API routes, which are Express-compatible) for backend logic — session management, API key proxying, and response caching.
- LLM API Proxy: Express servers commonly proxy requests to OpenAI/Anthropic APIs — adding authentication, rate limiting, and request logging between the frontend and the LLM provider without exposing API keys to the browser.
- Streaming Responses: Express supports streaming responses (res.write() + res.end()) for proxying LLM SSE streams — the Express server receives the OpenAI SSE stream and forwards it to the browser client.
- Webhook Receivers: AI pipeline webhook receivers (receiving GitHub events to trigger code review, Stripe events to update user compute credits) are simple Express POST handlers.
Core Express Patterns
Basic LLM API Proxy:
const express = require("express");
const OpenAI = require("openai");
const app = express();
app.use(express.json());
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
app.post("/api/chat", async (req, res) => {
const { messages } = req.body;
// Stream response back to client
const stream = await openai.chat.completions.create({
model: "gpt-4o",
messages,
stream: true
});
res.setHeader("Content-Type", "text/event-stream");
for await (const chunk of stream) {
const token = chunk.choices[0]?.delta?.content || "";
if (token) res.write(data: ${JSON.stringify({ token })}
);
}
res.write("data: [DONE]
");
res.end();
});
app.listen(3000);
Middleware Stack:
const rateLimit = require("express-rate-limit");
const morgan = require("morgan");
app.use(morgan("combined")); // Request logging
app.use(rateLimit({ max: 100 })); // Rate limiting
app.use(express.json()); // JSON body parsing
app.use(validateApiKey); // Custom auth middleware
app.use("/api", router); // Route mounting
Error Handling Middleware:
app.use((err, req, res, next) => {
console.error(err.stack);
res.status(500).json({ error: err.message });
});
Express vs Alternatives
| Framework | Language | Performance | Type Safety | Best For |
|-----------|----------|-------------|------------|---------|
| Express | JS/TS | Good | Optional | Node.js APIs, full-stack JS |
| Fastify | JS/TS | Very Good | Optional | High-performance Node APIs |
| FastAPI | Python | Very Good | Yes | ML serving, Python teams |
| NestJS | TypeScript | Good | Yes | Enterprise Node.js |
| Hono | JS/TS | Excellent | Yes | Edge/serverless |
Express.js is the flexible foundation for Node.js AI application backends — by providing routing and middleware composition without imposing framework opinions, Express enables JavaScript teams to build LLM API proxies, streaming backends, and AI webhook receivers with the same language as their frontend, leveraging Node.js's efficient handling of concurrent I/O-bound AI service calls.