Skip to content
JavaScript Backend: Node.js and Bun in Production
Build the JavaScript backend knowledge that frameworks hide, then take one multi-tenant system through Node.js, Bun, PostgreSQL, streams, jobs, security, observability, deployment, and rollback.
Stop treating the runtime as a black box
You already know JavaScript. This course teaches what changes when JavaScript becomes a long-running production service: who owns memory and resources, how asynchronous work fails, where boundaries belong, how concurrent writes stay correct, why streams apply backpressure, when workers help, and how operational evidence decides between Node.js and Bun.
Build Relay, not disconnected exercises
Multi-tenant order and fulfillment backend with APIs, transactions, streams, realtime updates, webhooks, and jobs.
Relay must preserve these invariants from the first module to the final defense: Every authenticated read and mutation preserves organization scope. A confirmed reservation never reduces inventory below zero. The same idempotent command produces exactly one domain effect. Streams and realtime channels enforce explicit memory and slow-consumer limits. Jobs separate confirmed effects from recoverable delivery and support reconciliation. Every runtime decision includes evidence, a canary, rollback, and a review trigger.
What you will be able to do
Model and debug the Node.js runtime; design explicit async ownership and cancellation; build native HTTP and Fastify boundaries; enforce multi-tenant PostgreSQL transactions; move bytes with bounded streams; choose workers, processes, and jobs; integrate security and test evidence; profile, observe, deploy, and recover; then evaluate Bun with a compatibility ledger, canary, and rollback instead of hype.
Current technical baseline
The tested baseline is Node.js 24.20.0 LTS Krypton, Bun 1.4.0, TypeScript 7.0.2, Fastify 5.12.1, postgres 3.4.9, and PostgreSQL 18.6. Runtime-sensitive claims were reviewed on 2026-08-30 and must be rechecked by 2026-11-28.
Ten modules, one production system
The recommended path is one module per week for ten weeks, about 60–70 hours in total. The sequence is designed so every Relay checkpoint preserves the invariants from earlier modules; the pace is guidance, not an access restriction.
Model the runtime before the framework
Understand the process that executes JavaScript, the state that stays alive, executable module boundaries, and controlled shutdown.
Control asynchrony and the event loop
Predict meaningful ordering, assign ownership to promises, propagate cancellation, and carry request context without unsafe globals.
Design boundaries with modules and types
Create explicit package surfaces, fail-fast configuration, runtime validation, bounded errors, and replaceable adapters.
Build HTTP from the connection to the domain
Trace the native request lifecycle, bound hostile bodies, introduce Fastify as an adapter, and handle disconnect ownership.
Persist data without losing correctness
Control connection budgets, tenant scope, constraints, transactions, concurrency, pagination, migrations, and idempotency.
Move bytes with streams and backpressure
Handle buffers, encodings, files, pipelines, bounded upload and download, WebSockets, and slow consumers.
Choose concurrency without lying to yourself
Measure CPU stalls, use worker threads deliberately, design durable jobs, bound retries, and shut workers down safely.
Integrate security and testing into the design
Connect authentication, authorization, secrets, signatures, rate limits, dependency risk, test levels, controlled time, and fault injection.
Measure, release, and recover the system
Profile CPU and memory, load test distributions, emit useful telemetry, define health, deploy reproducibly, roll back, and review incidents.
Evaluate Bun and make a deliberate runtime decision
Use Bun's runtime and toolchain, test real compatibility, evaluate native APIs, benchmark fairly, canary safely, and preserve rollback.
The evidence you keep
You finish with a runtime map, async budget, boundary map, API contract, transaction policy, stream budget, job policy, threat model, test strategy, capacity plan, deployment and rollback runbook, architecture decisions, a ten-entry Node.js/Bun compatibility ledger, and an incident review. These are operating artifacts tied to executable evidence, not résumé decoration.
Assessment that makes you explain the system
Each module ends with a six-scenario check. Five architecture reviews force decisions across boundaries. Ten debugging cases begin from incomplete evidence. The final production-defense bank contains twenty-four scenarios and presents fifteen per attempt. Questions test prediction, diagnosis, safety, and trade-offs—not syntax trivia.
The Node.js and Bun decision
Node.js is the primary production baseline. Bun is taught as a serious runtime and toolchain through the same commands, fixtures, workloads, failure drills, and operational constraints. You will finish with a documented decision: adopt, constrain, defer, or roll back—plus the evidence and expiry trigger behind it.