# Node.js microservice guides and comparisons

Source: https://imqueue.org/blog/

Articles on message-queue RPC for Node.js & TypeScript microservices: Redis
brokers, guaranteed delivery, typed clients, scaling and framework comparisons.

All 38 articles, newest first. Each is also served as
plain markdown at `<article-url>index.md`.

- [Fifty callers, one query: the cache stampede and the decorator that ends it](https://imqueue.org/blog/cache-stampede-single-flight-nodejs/) — 2026-09-08, Mykhailo Stadnyk: A cache is at its most useless in the one moment you need it: the key is cold, fifty requests miss it together, and fifty copies of the same query hit the database. Measured — and measured again with one line above the method that makes it one query, one result, fifty callers served. — [markdown](https://imqueue.org/blog/cache-stampede-single-flight-nodejs/index.md)
- [The contract your services already publish: contract testing for Node.js microservices](https://imqueue.org/blog/contract-testing-generated-clients/) — 2026-09-04, Serhiy Morenko: Contract testing exists because two services can agree on a shape today and disagree on it next Thursday, with nothing in either repository to notice. If your clients are generated, most of that machinery is already built for you — and the part that is left is not the part the tooling advertises. Here is what an @imqueue service publishes about itself, how to pin it in a test that needs no broker, and the one place the contract can quietly disagree with your TypeScript. — [markdown](https://imqueue.org/blog/contract-testing-generated-clients/index.md)
- [Meeting compliance: how to talk to your Redis broker over TLS](https://imqueue.org/blog/tls-redis-broker-nodejs/) — 2026-09-01, Mykhailo Stadnyk: The questionnaire asks whether data is encrypted in transit, and you know the answer for the edge. Then you remember the broker — the one connection every service holds open all day, carrying every argument and every return value, and speaking a protocol that puts them on the wire as text. Here is what encrypting it takes, what it costs, and the two places it is easy to get wrong. — [markdown](https://imqueue.org/blog/tls-redis-broker-nodejs/index.md)
- [Checking an IP against 10,000 networks without comparing it to 10,000 networks](https://imqueue.org/blog/ip-allow-lists-cidr-nodejs/) — 2026-08-28, Mykhailo Stadnyk: Every request asks the same question — is this one of ours? — and the loop you wrote to answer it gets slower every time someone adds a partner range. Here is how to answer it in logarithmic time instead, what an address really is once you stop treating it as a string, and the quiet precondition that a fast implementation must uphold or it will lie to you. — [markdown](https://imqueue.org/blog/ip-allow-lists-cidr-nodejs/index.md)
- [Typed at compile time, unchecked on the wire: runtime validation for TypeScript services](https://imqueue.org/blog/runtime-validation-typescript-services/) — 2026-08-25, Serhiy Morenko: Your service method has a signature. The message that arrives has none — it is JSON, and JSON does not remember what it was supposed to be. This is the story of the bug that leaves no stack trace, why your compiler was never in a position to catch it, and how to put a real check at the boundary without slowing anything down. — [markdown](https://imqueue.org/blog/runtime-validation-typescript-services/index.md)
- [Autoscale on queue depth, not CPU](https://imqueue.org/blog/autoscaling-nodejs-services-on-queue-depth/) — 2026-08-22, Mykhailo Stadnyk: CPU tells you a process is busy, not whether anyone is waiting. An @imqueue service's backlog is a Redis list, so KEDA can scale on it with no exporter, no Prometheus and no code change — and the metrics server covers the case where you need more. — [markdown](https://imqueue.org/blog/autoscaling-nodejs-services-on-queue-depth/index.md)
- [Nothing threw, and the job never ran: silent failures in a Node.js message queue](https://imqueue.org/blog/silent-failures-nodejs-message-queue/) — 2026-08-21, Andrii Glushko: A send() that resolves with a message id nobody will ever deliver. A push() that returns cleanly onto a queue redis refused to write. Neither throws, and neither can — the caller has already moved on by the time redis answers. That silence is over: here is what each of those failures now writes to the log instead, and the one upgrade note that costs you a stack trace. — [markdown](https://imqueue.org/blog/silent-failures-nodejs-message-queue/index.md)
- [Cache invalidation across services: a TTL, a tag, or the database](https://imqueue.org/blog/cache-invalidation-nodejs-microservices/) — 2026-08-18, Mykhailo Stadnyk: Caching a service method is one decorator. Deciding when the entry dies is the whole job. Here are the three mechanisms measured — a guessed TTL, a tag invalidated by an event, and PostgreSQL dropping the entry 6ms after the row changes — plus the four ways a cache goes on serving data it already knows is stale, and a fifth that got fixed while this was being written. — [markdown](https://imqueue.org/blog/cache-invalidation-nodejs-microservices/index.md)
- [The N+1 problem when GraphQL resolvers call microservices](https://imqueue.org/blog/graphql-n-plus-1-microservices/) — 2026-08-14, Andrii Glushko: A field resolver runs once per parent object. Put a service call inside it and one innocent-looking query becomes twenty-six. Here is the same query measured at 26 calls and at 3, why your latency chart will not show you the difference, and the two ways the fix comes back silently empty. — [markdown](https://imqueue.org/blog/graphql-n-plus-1-microservices/index.md)
- [Distributed tracing for Node.js services over a message queue](https://imqueue.org/blog/distributed-tracing-nodejs-message-queue/) — 2026-08-13, Serhiy Morenko: The standard objection to queue-based RPC is that you lose the trace: the caller sends, something else picks it up, and the connection between them is gone. It isn't — the trace context rides in the request metadata. Here is a measured three-process trace, and the four ways it silently comes out wrong. — [markdown](https://imqueue.org/blog/distributed-tracing-nodejs-message-queue/index.md)
- [@imqueue vs NATS: a framework and a transport are not the same choice](https://imqueue.org/blog/imqueue-vs-nats/) — 2026-08-03, Andrii Glushko: NATS is a messaging system; @imqueue is an RPC framework that happens to use one. Comparing them means deciding how much of the contract you want to write yourself — and whether your fleet is Node-only. — [markdown](https://imqueue.org/blog/imqueue-vs-nats/index.md)
- [How Node.js services talk to each other in 2026: the honest options](https://imqueue.org/blog/nodejs-service-communication-options-2026/) — 2026-08-03, Mykhailo Stadnyk: REST, gRPC, tRPC, NATS, a framework like NestJS or Moleculer, or RPC over a message queue. Six real approaches, what each one costs, and the two questions that actually decide it — including when @imqueue is the wrong answer. — [markdown](https://imqueue.org/blog/nodejs-service-communication-options-2026/index.md)
- [One notification, every replica: the LISTEN/NOTIFY duplicate problem](https://imqueue.org/blog/postgres-notify-duplicate-listeners/) — 2026-07-31, Serhiy Morenko: LISTEN/NOTIFY is a broadcast, not a queue. Scale a Node app to three replicas and the same notification gets handled three times — no error, no warning, three charges on the card. Here's why, and what an inter-process lock actually does about it. — [markdown](https://imqueue.org/blog/postgres-notify-duplicate-listeners/index.md)
- [Graceful shutdown and zero-drop deploys](https://imqueue.org/blog/graceful-shutdown-zero-drop-deploys/) — 2026-07-28, Andrii Glushko: Every deploy sends a kill signal to a process that is probably in the middle of something. Nothing 500s, no dashboard turns red, and the work is gone anyway. Here's what actually happens to an in-flight message on SIGTERM, and the built-in drain that keeps it. — [markdown](https://imqueue.org/blog/graceful-shutdown-zero-drop-deploys/index.md)
- [Delayed and scheduled work without adding a job system](https://imqueue.org/blog/scheduled-work-without-a-job-system/) — 2026-07-25, Mykhailo Stadnyk: "Send that email in 24 hours" usually turns into a second deployment, a second data model, and a job record shadowing a service method you already wrote. Often the message queue you already run can just do it. Here's how deferral works as a parameter, and what it costs. — [markdown](https://imqueue.org/blog/scheduled-work-without-a-job-system/index.md)
- [Auto-scaling Redis broker: with and without broadcast](https://imqueue.org/blog/horizontally-scalable-redis-broker/) — 2026-07-24, Serhiy Morenko: One Redis behind your message bus is a ceiling and a single point of failure. The promoter and unicaster modules turn a fleet of plain Redis instances into a horizontally auto-scaling broker — here are the recipes for networks that deliver broadcast and for clouds like GCP that don't, and how to encrypt the result when the brokers announce addresses no certificate can carry. — [markdown](https://imqueue.org/blog/horizontally-scalable-redis-broker/index.md)
- [One isolated imq CLI home per @imqueue project](https://imqueue.org/blog/isolated-imq-cli-environments/) — 2026-07-23, Andrii Glushko: Every imq invocation shares one ~/.imq — one config, one pid registry, one set of logs. Here's how to give each project its own isolated CLI environment with IMQ_CLI_HOME, plus recipes for direnv, shell wrappers, per-client tokens and disposable sandboxes. — [markdown](https://imqueue.org/blog/isolated-imq-cli-environments/index.md)
- [RPC over Redis in Node.js: patterns and pitfalls](https://imqueue.org/blog/rpc-over-redis-nodejs/) — 2026-07-23, Serhiy Morenko: How request/reply RPC over Redis actually works in Node.js — correlation, timeouts and at-least-once delivery, which of those @imqueue handles for you, and what it deliberately leaves to you: retrying a failed RPC call, coalescing duplicate concurrent calls with @lock, and the circuit breaker it does not ship. — [markdown](https://imqueue.org/blog/rpc-over-redis-nodejs/index.md)
- [BullMQ alternatives for Node.js: an honest 2026 guide](https://imqueue.org/blog/bullmq-alternatives/) — 2026-07-22, Mykhailo Stadnyk: BullMQ is the default Redis job queue for Node.js — but it isn't the only choice. Here's an even-handed map of the alternatives (Bee-Queue, pg-boss, Agenda, @imqueue/job and more), what each is actually good at, and how to pick. — [markdown](https://imqueue.org/blog/bullmq-alternatives/index.md)
- [RPC between Node.js microservices over a message queue](https://imqueue.org/blog/rpc-over-message-queue-nodejs/) — 2026-07-22, Mykhailo Stadnyk: Why route internal service-to-service calls through a message queue instead of HTTP or gRPC — and how @imqueue makes those calls fully typed with zero client boilerplate. — [markdown](https://imqueue.org/blog/rpc-over-message-queue-nodejs/index.md)
- [Type-safe service-to-service communication in TypeScript](https://imqueue.org/blog/type-safe-service-communication-typescript/) — 2026-07-19, Serhiy Morenko: End-to-end types across service boundaries are easy inside one process and hard the moment you cross a network. Here's how to keep them without hand-writing clients or maintaining a schema language. — [markdown](https://imqueue.org/blog/type-safe-service-communication-typescript/index.md)
- [Stop hand-writing and maintaining your microservice clients](https://imqueue.org/blog/stop-hand-writing-microservice-clients/) — 2026-07-17, Serhiy Morenko: Every service you call needs a client, and hand-maintained clients drift out of sync with the services they talk to. Here's why that happens, how to make the client fall out of the service, and what the generated approach costs. — [markdown](https://imqueue.org/blog/stop-hand-writing-microservice-clients/index.md)
- [Load balancing microservices without a load balancer](https://imqueue.org/blog/load-balancing-microservices-without-a-load-balancer/) — 2026-07-14, Mykhailo Stadnyk: For internal service-to-service traffic, the load balancer you run and operate is often solving a problem a message queue solves for free. Here's the competing-consumers pattern, why pull beats push, and what you give up. — [markdown](https://imqueue.org/blog/load-balancing-microservices-without-a-load-balancer/index.md)
- [Do your Node.js back-ends really need service discovery?](https://imqueue.org/blog/do-nodejs-backends-need-service-discovery/) — 2026-07-12, Mykhailo Stadnyk: Consul, etcd, DNS-SD — service discovery is a lot of machinery to stand up. Sometimes you genuinely need it; often you don't. Here's how to tell, and how a queue makes the question disappear. — [markdown](https://imqueue.org/blog/do-nodejs-backends-need-service-discovery/index.md)
- [Back-pressure for Node.js services](https://imqueue.org/blog/backpressure-nodejs-services/) — 2026-07-09, Mykhailo Stadnyk: When a downstream service slows down, HTTP tends to turn that into a cascading failure. A queue absorbs the spike instead. Here's the difference, and the trade-offs to watch. — [markdown](https://imqueue.org/blog/backpressure-nodejs-services/index.md)
- [Guaranteed message delivery: cost and when to use it](https://imqueue.org/blog/guaranteed-message-delivery-cost/) — 2026-07-07, Mykhailo Stadnyk: "Will I lose messages if a worker dies?" is the right question — and the answer is a trade-off, not a yes/no. Here's how guaranteed delivery works, what it costs, and how to choose per workload. — [markdown](https://imqueue.org/blog/guaranteed-message-delivery-cost/index.md)
- [Cutting the boilerplate out of Node.js microservices](https://imqueue.org/blog/cutting-boilerplate-nodejs-microservices/) — 2026-07-04, Serhiy Morenko: Most of a new service's first commit is ceremony — transport wiring, serialization, a client, CI, a Dockerfile. Here's where the boilerplate hides and how to stop writing it by hand. — [markdown](https://imqueue.org/blog/cutting-boilerplate-nodejs-microservices/index.md)
- [Versioning microservices without breaking every caller](https://imqueue.org/blog/versioning-microservices-without-breaking-callers/) — 2026-07-02, Serhiy Morenko: A change to one service's method quietly breaks the services that call it — and you find out in production. Here's how to make breaking changes loud at build time, which changes are actually safe, and how to handle the window where both versions are live. — [markdown](https://imqueue.org/blog/versioning-microservices-without-breaking-callers/index.md)
- [Testing services that call each other](https://imqueue.org/blog/testing-microservices-without-the-whole-stack/) — 2026-06-29, Serhiy Morenko: Integration tests that require every service and its infrastructure running are slow, flaky, and painful. Here's a layered approach that tests most of your logic without spinning up the world. — [markdown](https://imqueue.org/blog/testing-microservices-without-the-whole-stack/index.md)
- [Internal APIs don't need to be REST](https://imqueue.org/blog/internal-apis-dont-need-rest/) — 2026-06-27, Andrii Glushko: REST is a fine choice for public, resource-oriented APIs. For internal service-to-service calls it's often ceremony over a plain function call. Here's when to drop it and what to reach for instead. — [markdown](https://imqueue.org/blog/internal-apis-dont-need-rest/index.md)
- [From monolith to services: a low-risk first extraction](https://imqueue.org/blog/monolith-to-services-first-extraction/) — 2026-06-24, Andrii Glushko: You don't migrate a monolith by rewriting it. You extract one capability, keep everything else in place, and repeat. Here's a concrete, low-risk first step for a Node.js team. — [markdown](https://imqueue.org/blog/monolith-to-services-first-extraction/index.md)
- [Redis as a message bus: patterns beyond pub/sub](https://imqueue.org/blog/redis-message-bus-patterns/) — 2026-06-22, Mykhailo Stadnyk: Most people know Redis pub/sub and stop there. Redis has richer primitives — lists, blocking pops, and streams — that make it a capable message bus. Here's a tour, and where each fits. — [markdown](https://imqueue.org/blog/redis-message-bus-patterns/index.md)
- [@imqueue vs Moleculer: two takes on Node.js microservices](https://imqueue.org/blog/imqueue-vs-moleculer/) — 2026-06-19, Andrii Glushko: Moleculer is a full-featured microservices framework with many transporters; @imqueue is a focused, TypeScript-first RPC layer over a message queue. Here's an honest comparison to help you pick. — [markdown](https://imqueue.org/blog/imqueue-vs-moleculer/index.md)
- [@imqueue vs NestJS microservices: framework vs transport](https://imqueue.org/blog/imqueue-vs-nestjs/) — 2026-06-17, Andrii Glushko: NestJS is a full application framework with a microservices module; @imqueue is a focused RPC transport. They're not really competitors — here's how they differ, where each is stronger, and how to run them together. — [markdown](https://imqueue.org/blog/imqueue-vs-nestjs/index.md)
- [tRPC vs @imqueue: client–server types vs service–service RPC](https://imqueue.org/blog/imqueue-vs-trpc/) — 2026-06-14, Andrii Glushko: tRPC gives you end-to-end types between a frontend and its backend. @imqueue gives you typed RPC between backend services over a queue. They solve adjacent — not competing — problems. — [markdown](https://imqueue.org/blog/imqueue-vs-trpc/index.md)
- [@imqueue/job vs BullMQ: Redis job queues compared](https://imqueue.org/blog/imqueue-vs-bullmq/) — 2026-06-12, Andrii Glushko: Both are Redis-backed job queues for Node.js. @imqueue/job is small, safe-by-default and scheduling-capable; BullMQ is the feature-rich one. Here's an honest split — plus the thing @imqueue does that BullMQ doesn't. — [markdown](https://imqueue.org/blog/imqueue-vs-bullmq/index.md)
- [gRPC vs message-queue RPC for internal Node.js services](https://imqueue.org/blog/grpc-vs-message-queue-rpc/) — 2026-06-09, Mykhailo Stadnyk: gRPC is the default answer for typed RPC — and a great one, especially across languages. For an all-Node.js back-end, routing RPC through a queue trades some of gRPC's strengths for a lot less infrastructure. — [markdown](https://imqueue.org/blog/grpc-vs-message-queue-rpc/index.md)
- [Benchmarking @imqueue: throughput and delivery modes](https://imqueue.org/blog/benchmarking-imqueue-throughput/) — 2026-06-07, Mykhailo Stadnyk: Real measured throughput for @imqueue's message queue — ~200k msg/sec unreliable, ~120k guaranteed on a 24-core box — what the delivery modes cost, and a reproducible harness to measure the figures that matter: yours. — [markdown](https://imqueue.org/blog/benchmarking-imqueue-throughput/index.md)

## Topics

- [Message queues](https://imqueue.org/blog/topics/queue/) — Articles on running Node.js services over a message queue: work queues, competing consumers, guaranteed delivery, back-pressure, and Redis as the broker. (16 articles) — [markdown](https://imqueue.org/blog/topics/queue/index.md)
- [RPC](https://imqueue.org/blog/topics/rpc/) — Articles on RPC between Node.js microservices: request/reply over a message queue, typed clients, RPC over Redis, and why internal APIs need not be REST. (14 articles) — [markdown](https://imqueue.org/blog/topics/rpc/index.md)
- [Architecture](https://imqueue.org/blog/topics/architecture/) — Architecture articles on service-oriented Node.js back-ends: splitting a monolith, service boundaries, discovery, load balancing and inter-service calls. (11 articles) — [markdown](https://imqueue.org/blog/topics/architecture/index.md)
- [Patterns](https://imqueue.org/blog/topics/patterns/) — Messaging patterns for Node.js services: request/reply, competing consumers, work queues, delayed and recurring work, and Redis pub/sub versus streams. (11 articles) — [markdown](https://imqueue.org/blog/topics/patterns/index.md)
- [Comparisons](https://imqueue.org/blog/topics/comparison/) — Even-handed comparisons of @imqueue with BullMQ, Moleculer, NestJS microservices, tRPC and gRPC — what each one is for, and when to pick the other one. (9 articles) — [markdown](https://imqueue.org/blog/topics/comparison/index.md)
- [Developer experience](https://imqueue.org/blog/topics/dx/) — Articles on developer experience in Node.js microservices: cutting boilerplate, generated typed clients, running a local fleet, and isolated CLI environments. (8 articles) — [markdown](https://imqueue.org/blog/topics/dx/index.md)
- [Type safety](https://imqueue.org/blog/topics/types/) — Articles on end-to-end type safety between TypeScript microservices: generated clients, sharing types without a shared package, and versioning safely. (7 articles) — [markdown](https://imqueue.org/blog/topics/types/index.md)
- [Performance](https://imqueue.org/blog/topics/performance/) — Measured performance work on Node.js services: benchmarked queue throughput, what each cache invalidation strategy costs, one GraphQL query that became twenty-six service calls, and autoscaling on backlog rather than CPU. (6 articles) — [markdown](https://imqueue.org/blog/topics/performance/index.md)
- [Resilience](https://imqueue.org/blog/topics/resilience/) — Articles on keeping Node.js services healthy under load and during deploys: back-pressure, graceful shutdown, zero-drop deploys and delivery guarantees. (6 articles) — [markdown](https://imqueue.org/blog/topics/resilience/index.md)
- [Transports](https://imqueue.org/blog/topics/transport/) — Articles on the transport beneath your services: Redis as a message bus, RPC over Redis, message queues versus gRPC, and what each choice actually costs. (6 articles) — [markdown](https://imqueue.org/blog/topics/transport/index.md)
- [Message delivery](https://imqueue.org/blog/topics/delivery/) — Articles on message delivery guarantees: guaranteed versus unreliable delivery, what each costs in throughput, and delayed or scheduled delivery. (5 articles) — [markdown](https://imqueue.org/blog/topics/delivery/index.md)
- [Typed clients](https://imqueue.org/blog/topics/clients/) — Articles on generated typed service clients: why hand-written microservice SDKs rot, how self-describing services replace them, and using clients as test seams. (4 articles) — [markdown](https://imqueue.org/blog/topics/clients/index.md)
- [Jobs & scheduling](https://imqueue.org/blog/topics/jobs/) — Articles on background jobs and background tasks in Node.js and nodejs services: delayed calls, scheduled work, retry backoff, recurring sweeps, and how @imqueue/job compares with BullMQ. (4 articles) — [markdown](https://imqueue.org/blog/topics/jobs/index.md)

## Authors

- [Mykhailo Stadnyk](https://imqueue.org/blog/authors/mykhailo-stadnyk/) — Creator & maintainer of @imqueue — [markdown](https://imqueue.org/blog/authors/mykhailo-stadnyk/index.md)
- [Serhiy Morenko](https://imqueue.org/blog/authors/serhiy-morenko/) — Maintainer, @imqueue — [markdown](https://imqueue.org/blog/authors/serhiy-morenko/index.md)
- [Andrii Glushko](https://imqueue.org/blog/authors/andrii/) — Maintainer, @imqueue — [markdown](https://imqueue.org/blog/authors/andrii/index.md)