FIXED SCOPEone-off build
Ship a Node.js product, end-to-end.
A defined product, a fixed price, a senior-only team. From RFC to launch in 8–14 weeks.
$15k–$30k
FIXED SCOPE
- Senior engineers only
- Fixed quote in week 1
- Code, infra, runbook — yours
Real-time, high-performance backends.Shipped in Node.js.
We don't follow tutorials — we ship Node.js in production. Ten years of it. Event loop discipline, streaming pipelines, real-time systems at scale. The boring decisions that decide whether year three of your API still handles load without a 2am incident.
- Non-blocking I/O
- Sub-20ms p99
- Edge-ready
- Typed end-to-end
Why Entalogics for Node.js
Four things every
Node.js app
actually needs.
Most teams treat Node like a thread-per-request server and wonder why it slows under load. We build around how Node actually works — not how people assume it works.
Performance01
Protect the event loop. It's your only thread.
One synchronous CPU-heavy operation stalls every pending request. We audit for event loop blockers from day one and offload CPU-bound work to Worker Threads before it becomes a production incident.
Architecture02
Module boundaries, not a monolithic routes folder.
Thin route handlers, domain logic in pure functions, data access behind typed repositories. A new engineer finds the right file in thirty seconds — not thirty minutes of grepping.
State03
Async patterns that don't lie to you.
An omitted `await` passes a Promise instead of a value. Sequential awaits that could run in parallel double your latency for free. We enforce async discipline with TypeScript and ESLint rules that catch this before the integration test does.
Type safety04
TypeScript strict, end to end.
Zod at every external boundary. tRPC or typed OpenAPI at the API layer. The runtime is dynamic — the codebase doesn't have to be. A schema change surfaces every broken callsite in seconds.
When Node.js, when not
Node.js is a tool.
Not a religion.
An honest decision matrix. We'll tell you on the first call whether Node.js is the right call — or whether your problem needs a different runtime entirely.
PICK NODE.JS WHEN
- High-concurrency I/O — thousands of simultaneous connections, WebSockets, streaming
- Real-time is first-class — live collaboration, AI token streaming, event feeds
- Edge or serverless deployment where cold start time is a real constraint
- JavaScript everywhere matters — shared types and validation across the full stack
CONSIDER OTHERS WHEN
- CPU-intensive workloads without I/O — Go or Rust will outperform Node regardless
- Large enterprise with existing Java or .NET infrastructure already in production
- Data-science-adjacent product where Python has a decade head start in libraries
WE SAY NO WHEN
- "We want Node because JavaScript is everywhere." That's convenience, not architecture.
- "Rewrite our Python ML service in Node." The inference libraries don't exist.
- "We need this in two weeks and the API contract is still being negotiated." That ship has sailed.
What we build with Node.js
Six product surfaces.
One quality bar.
The shapes of Node.js work we ship most often. Each slots cleanly into your existing infrastructure if you already have one.
- S01
Real-time APIs & WebSocket servers
Real-time APIs & WebSocket serversLive collaboration, event feeds, AI token streaming. Node's event loop handles ten thousand concurrent connections where a thread-per-request server needs ten machines.
HONOWSSOCKET.IOREDIS - S02
High-throughput REST & GraphQL APIs
High-throughput REST & GraphQL APIsFastify for Node-native performance, Hono for edge-deployed APIs. Built-in schema validation, typed contracts from route definition to client.
FASTIFYHONODRIZZLETRPC - S03
Streaming data pipelines
Streaming data pipelinesProcess multi-gigabyte files and database exports without loading them into memory. Streams used correctly — not the `data` event antipattern from 2014.
NODE STREAMSBULLMQKAFKAS3 - S04
Edge-deployed services
Edge-deployed servicesHono on Cloudflare Workers, Vercel Edge, AWS Lambda@Edge. Sub-millisecond cold starts, global distribution, zero infrastructure to manage.
HONOCLOUDFLARE WORKERSVERCEL EDGEWRANGLER - S05
Background processing & queues
Background processing & queuesBullMQ for job queues with retry logic and a real dashboard. Worker Threads for CPU-bound jobs that can't leave the process.
BULLMQWORKER THREADSREDISTEMPORAL - S06
Developer tooling & CLIs
Developer tooling & CLIsInternal CLIs, build tools, migration scripts. Node's ecosystem is the richest in the world for this surface — when it's typed and structured properly.
COMMANDERINQUIRERZODTSX
The playbook
Patterns we
ship on repeat.
The Node.js patterns that show up on almost every engagement. Not invention — convention, applied carefully.
P01
Event loop first
Every handler stays async. CPU-bound work goes to a Worker Thread pool. Clinic.js in CI to catch event loop regressions before production does.
P02
Typed contracts
tRPC for full-stack TypeScript. Zod schemas that become the types — one definition, no drift between what the API sends and what the client expects.
P03
Stream-first data
Large payloads streamed, never buffered into memory first. `pipeline()` over manual `pipe()` for proper error propagation. Memory that stays flat under load.
P04
Structured error handling
Typed error classes, not string messages. Global error handler that logs, traces, and returns consistent shapes. Unhandled rejections wired to alerting — not swallowed by a catch block.
P05
Graceful shutdown
`SIGTERM` handler that drains in-flight requests, closes database pools, and flushes logs before exit. Zero dropped requests during rolling deploys.
P06
Strangler-fig migrations
New Fastify or Hono routes behind a reverse proxy alongside the old Express app. One route at a time. Express keeps serving until the new code has earned every path.
Signature case
A real-time platform,
rebuilt around the event loop..
A B2B collaboration platform on Express.js — 450ms p99 on the WebSocket broadcast path, synchronous JSON processing blocking the event loop, memory climbing 40MB per hour until the daily restart. Rebuilt on Fastify with Worker Threads and Redis pub/sub in 9 weeks. Without a downtime window.
Before
p99 broadcast 450ms · event loop blocked 18% · memory +40MB/hr · daily restart required
After
p99 broadcast 22ms · event loop block 4% · memory stable · zero scheduled restarts
- p99 broadcast latency−95%
- Event loop block time−78%
- To fully migrated9wk
- Shipped regressions0
Engagement shape
Eight to ten weeks
to a measurable ship.
A typical Node.js engagement, end-to-end. We migrate route by route — never flag-day. The current app keeps shipping while we work.
- W01
Audit + RFC
Two senior engineers in the codebase. Event loop profiling with Clinic.js, async antipattern inventory, memory leak audit. You leave week one with a ranked, dollarized RFC.
- W02–03
Foundation + first route
TypeScript strict, Fastify or Hono wired in, Zod at every boundary, one production route migrated end-to-end. Real p99 numbers in your dashboards — not a local benchmark.
- W04–08
Migrate by route, not flag-day
Route by route behind a reverse proxy. Old and new run side-by-side. Kill-switch on every cutover. Your roadmap keeps moving throughout.
- W09+
Cleanup + handoff
Decommission the old. Integration tests with Testcontainers. Runbook handed to your team — or we stay on retainer.
Stack
Tools we
reach for first.
Picked by problem, not by resume. Happy to slot into your stack — but greenfield, this is the default.
- FrameworkHono · Fastify · Node.js 22 LTS · tRPC
- LanguageTypeScript (strict) · Zod · ESLint · biome
- DataDrizzle · Prisma · Redis · PostgreSQL · BullMQ
- TestingVitest · Testcontainers · Supertest · Playwright
- InfraCloudflare Workers · Vercel · AWS Lambda · Docker · Datadog · Sentry
Engagement
Three ways
to work with us.
No hourly retainer that bills for "thinking time." Pick a lane that matches your stage; everything is fixed-quote or transparently rated.
DEDICATED TEAMmonthly
Hire dedicated Node.js engineers.
Embedded engineers in your Slack, your Linear, your standups. A scaled pod of senior Node.js engineers, augmenting your team. Pause, resize, end with 30 days' notice.
$5k / eng / mo
PER ENGINEER
- Same senior bar as fixed-scope
- Embedded in your team
- Founder-direct escalation
ENGAGEMENTcustom
Strategic Node.js partnership.
A long-term partner for product orgs that need both delivery and judgement — event loop program, migration roadmap, hiring help.
custom
PROCUREMENT-FRIENDLY
- Multi-quarter roadmap
- Architecture & hiring partner
- Procurement-friendly paper
FAQ
Sharp questions,
straight answers.
Express vs Fastify vs Hono, CPU work, Go comparisons — the questions we get on every Node.js discovery call.Express for existing codebases where migration cost isn't justified. Fastify for new Node-native APIs — 2x faster than Express with built-in schema validation. Hono for anything edge-deployed or multi-runtime. Don't use Express for greenfield — you're paying a performance tax with no return.
Worker Threads. The main thread handles I/O and coordination — CPU-bound work like document processing, image resizing, and large JSON transformations runs in a typed Worker Thread pool without touching the event loop.
For I/O-bound APIs the gap is small enough that language choice won't be your bottleneck. For CPU-bound workloads Go wins measurably. Most SaaS APIs are I/O-bound — we'll tell you which side your workload sits on before you've committed to either.
Yes. The engineers who write the RFC ship the code. No mid-engagement handoff. Direct access to the people doing the work throughout.
Yes. Route by route behind a reverse proxy — never flag-day. Express keeps serving until every route has earned its migration. Your team keeps shipping the whole time.
Founder-direct
Tell us whatyou're building.
Thirty minutes with the founder. We'll bring a senior Node.js engineer, the relevant playbook, and a candid read on whether Node.js is the right runtime — or whether your workload needs something else.