Node.js
One thread. Thousands of concurrent ops.
Node.js runs JavaScript server-side on a non-blocking event loop. The single request you're handling doesn't wait for the database — it starts the query, moves to the next task, picks the result up when ready. Perfect for I/O-heavy APIs, real-time apps, and anything that orchestrates many services.
Event loop · POST /api/checkout
tick 000
Incoming
request
Non-blocking I/O · parallel ops
auth.verify(jwt)
—
db.users.find(id)
—
redis.get(cart)
—
api.stripe.rates()
—
db.stock.count()
—
Response
200 OK
Single thread
One worker handles everything — no thread-per-request overhead.Parallel I/O
5 ops issued at once; event loop picks each up as it completes.Total ~155ms
If sequential: 233ms. Non-blocking saves ~33%.I/O-heavy workloads
Where Node.js is the right tool.
REST + GraphQL APIs
Express / Fastify / tRPC / NestJS / Apollo Server. Node's ecosystem for HTTP APIs is unmatched. Low latency, high concurrency.
Real-time apps
WebSockets (Socket.io), Server-Sent Events, WebRTC signaling. Chat, live dashboards, collaborative editing, gaming — Node's native ground.
Orchestration services
Talking to 5 databases, 3 APIs, Stripe, email service, and returning unified responses. Node's async story shines here.
Backend-for-frontend (BFF)
Thin aggregation layer between React/Vue app and microservices. Often paired with Next.js's API routes or separate Node service.
Build tooling + CLIs
Vite, ESBuild, Webpack, your project's internal tools. The JS runtime underneath modern dev tooling.
Event-driven / stream processing
Kafka consumers, Redis pub/sub, webhook receivers, queue workers. Node's streams API handles continuous data well.
Framework choices
Which Node framework for which job.
Node.js is just the runtime — a framework on top determines how you structure applications. These are the ones we actually use, with honest positioning.
Express
The classic, unopinionated workhorse
Small-to-mid APIs, simple backends, prototypes. Everyone knows it; endless middleware; zero ceremony.
Fastify
Express's faster, typed cousin
Performance-sensitive APIs where Express feels dated. JSON Schema validation built in. ~2× Express throughput.
NestJS
Angular-flavoured enterprise structure
Large teams, complex apps needing modules/DI/decorators. Great for Angular devs crossing to backend.
Hono
Lightweight, edge-first
Cloudflare Workers, Vercel Edge Functions, Deno. Builds APIs that run at edge locations globally.
tRPC
End-to-end type-safe APIs
When frontend and backend are in one monorepo. No API spec files, no codegen — types flow directly.
Apollo Server / GraphQL Yoga
GraphQL backends done right
Complex data graphs, multiple clients consuming same backend. Apollo for enterprise, Yoga for lighter setups.
The runtime landscape
Node.js vs Bun vs Deno — what to actually use.
Node.js
v22 LTS
The default, production-grade
Everything — until you have a specific reason not to. Maximum compatibility, largest ecosystem, most hosting options.
Maturity★★★★★
Bun
v1.2
Faster drop-in replacement
CLI tools, build scripts, performance-sensitive services. Production use increasing but still younger than Node.
Maturity★★★
Deno
v2.0
TypeScript-first, secure-by-default
Edge functions, greenfield TypeScript projects, security-conscious environments. Smaller ecosystem.
Maturity★★★
Our default: Node.js 22 LTS for production backends. Bun for CLIs and build scripts. Deno where edge + TypeScript alignment matters.
The tradeoffs
Where Node.js is the wrong call.
CPU-heavy computation
Image processing, video encoding, ML inference, heavy maths. Node's single thread becomes the bottleneck. Use worker threads or drop to Go/Rust for these.
Team doesn't know JavaScript
Learning JS + async patterns + tooling is a stack. A PHP or Python shop adding Node for one project usually regrets it.
Deep financial / scientific precision
JS numbers are 64-bit floats. Money handling needs BigInt or decimal libraries; native Python/Java/.NET handle this more naturally.
Memory-intensive long-running jobs
Node isn't great at huge heap workloads. Job processors doing 4GB+ in-memory ops — Java or Go handle this better.
Multi-core CPU utilisation
Node runs on one core by default. Scaling needs cluster mode or PM2 — works but adds complexity vs Go/Elixir/JVM.
Regulated environments with Java mandates
Some enterprises / public sector require specific runtimes. Fighting procurement is worse than picking their preferred tech.
Frequently asked
Node.js questions.
TypeScript for any project bigger than a script. The type safety pays for itself quickly in backend code with many moving parts. We default to TypeScript unless there's a specific reason not to.
Is Node.js the right backend for your project?
Share the use case — the APIs, the integrations, the real-time needs — and we'll tell you honestly whether Node.js fits or if Python, PHP, or something else is better.