# @imqueue

> @imqueue is a message-queue RPC framework for Node.js and TypeScript back-ends: services describe themselves at runtime, so their typed clients are generated, not written. No hand-written client code, no service discovery, no load balancer.

@imqueue is an open-source framework (GPL-3.0). Core packages: @imqueue/core (reliable message queue over Redis), @imqueue/rpc (typed RPC with automatic client generation), @imqueue/cli (scaffolding and orchestration of services). Commercial licensing and support for closed-source products: https://imqueue.com

Conventions for machine readers. Every page listed below is also published as
plain markdown at BOTH `<page-url>index.md` and `<page>.md` — byte-identical, same
content, no HTML, no navigation. (`/intro/index.md` and `/intro.md` are the same
file; the ecosystem is split on which shape it should be, so this site serves both.)
Under `/api/` that holds for every per-symbol page too, but only for the current
major: archived majors are HTML-only. To look a symbol up by name instead of
browsing, fetch https://imqueue.org/api/search-index.json — every exported symbol of
the current majors as `{name, kind, package, url, summary}`, with
`deprecated: true` on obsolete members. Start from a package index to see every
exported symbol with its summary, then follow the symbol link for the signature,
parameters, return value, exceptions and remarks.

Contact: support@imqueue.com reaches the maintainers — framework questions,
documentation problems, security reports and commercial licensing enquiries.

Updated: 2026-08-03
Install: `npm i -g @imqueue/cli` (scaffolding and client generation), then
`npm i @imqueue/rpc` in a service. Requires Node.js 22.12+ and a reachable Redis.
Source: https://github.com/imqueue
Packages: https://www.npmjs.com/org/imqueue
Symbol index: https://imqueue.org/api/search-index.json
Article index: https://imqueue.org/blog/search-index.json (title, summary, topics and
url for every article — cheaper than fetching the listing pages)
MCP endpoint: https://mcp.imqueue.org/mcp (Streamable HTTP, no auth, read-only —
docs search, symbol lookup and scaffolding as tools rather than as pages to parse)
Licence: GPL-3.0, with a commercial licence for closed-source distribution —
https://imqueue.com/license/

At a glance (the same rows https://imqueue.org/intro/ renders):
- @imqueue/core: 3.3.1
- @imqueue/rpc: 3.5.2
- Licence: GPL-3.0-only, or a commercial licence for closed-source distribution
- Node.js: 22.12 or newer
- Redis: 3.2 or newer (6.2+ for safe delivery)
- Transport: Redis only — the vendor option defaults to Redis and is its only supported value
- Addressing: the queue name, which is the service class name — no discovery
- Load balancing: competing consumers — no balancer, no weighting, no canaries
- Delivery: at-least-once in both modes, so exposed methods should be idempotent
- Streaming: none — request/response only
- Languages: Node.js and TypeScript only
- Contract source: the service class plus its JSDoc; clients are generated from a running service

## Getting Started
- [@imqueue — TypeScript RPC over a message queue](https://imqueue.org/): RPC over a message queue for service-oriented Node.js & TypeScript back-ends. Self-describing services generate their own typed clients — no boilerplate. — [markdown](https://imqueue.org/index.md)
- [Documentation: guides, tutorial & API reference](https://imqueue.org/docs/): Everything you need to build, run and scale @imqueue services: quickstart, step-by-step tutorial, imq CLI manual, MCP server and the full API reference. — [markdown](https://imqueue.org/docs/index.md)
- [Introduction to message-queue RPC for Node.js](https://imqueue.org/intro/): @imqueue is an inter-communication messaging queue framework for Node.js & TypeScript microservices — it handles messaging, discovery and load balancing. — [markdown](https://imqueue.org/intro/index.md)
- [@imqueue glossary: every term the docs assume](https://imqueue.org/glossary/): Definitions of @imqueue terminology: IMQ, service, generated client, self-describing service, fleet, safe delivery, at-least-once, competing consumers, provider axis and more. — [markdown](https://imqueue.org/glossary/index.md)
- [Get started: Node.js microservices in minutes](https://imqueue.org/get-started/): Install @imqueue and ship your first Node & TypeScript service in minutes — the shortest quickstart for building message-queue RPC microservices. — [markdown](https://imqueue.org/get-started/index.md)
- [Using AI coding assistants with @imqueue](https://imqueue.org/using-ai-assistants/): Use @imqueue with Claude, ChatGPT, Cursor and Copilot: a paste-ready context block plus the machine-readable docs endpoints agents can fetch. — [markdown](https://imqueue.org/using-ai-assistants/index.md)

## Tutorial
- [Tutorial: build Node.js microservices](https://imqueue.org/tutorial/): A step-by-step guide to building back-end services for a car-washing web application with @imqueue — for those who prefer to learn by example. — [markdown](https://imqueue.org/tutorial/index.md)
- [Build your first TypeScript RPC service](https://imqueue.org/tutorial/user-service/): Create your first @imqueue service — the User service — and expose typed methods that other services can call. — [markdown](https://imqueue.org/tutorial/user-service/index.md)
- [Auth service: calling another microservice](https://imqueue.org/tutorial/auth-service/): Add an Auth service that talks to the User service to log users in and verify them — your first inter-service communication. — [markdown](https://imqueue.org/tutorial/auth-service/index.md)
- [Domain services: PostgreSQL & in-memory data](https://imqueue.org/tutorial/other-services/): Add the remaining domain services — Car and Time-Table — an in-memory car catalog and a PostgreSQL-backed reservation time-table. — [markdown](https://imqueue.org/tutorial/other-services/index.md)
- [GraphQL API gateway for microservices](https://imqueue.org/tutorial/api-service/): Put a GraphQL API in front of your services — @imqueue works beautifully with GraphQL. — [markdown](https://imqueue.org/tutorial/api-service/index.md)
- [Deploy microservices with Docker & autoscaling](https://imqueue.org/tutorial/deployment/): Ship your services: per-service Docker images, environment-based configuration, and horizontal scaling for any load. — [markdown](https://imqueue.org/tutorial/deployment/index.md)
- [Bonus: REST & OpenAPI gateway with Swagger UI](https://imqueue.org/tutorial/rest-api/): Swap the GraphQL gateway for a REST/OpenAPI one — same fleet, same typed clients, a different front door. — [markdown](https://imqueue.org/tutorial/rest-api/index.md)
- [Bonus: React front-end on a REST gateway](https://imqueue.org/tutorial/rest-web-app/): A second front-end, native to REST — no Relay, no shims, no compromises. Same fleet, same features, a client that is idiomatic for the protocol it speaks. — [markdown](https://imqueue.org/tutorial/rest-web-app/index.md)

## CLI Guide
- [CLI User Guide](https://imqueue.org/cli/): The @imqueue/cli (imq) manual — a tool that scaffolds services, wires VCS/CI/registry providers, generates typed RPC clients and runs a local fleet. — [markdown](https://imqueue.org/cli/index.md)
- [Installation](https://imqueue.org/cli/installation/): Install @imqueue/cli globally, verify the imq command, upgrade from 3.x, enable bash & zsh completions, and see which files the CLI creates. — [markdown](https://imqueue.org/cli/installation/index.md)
- [Configuration](https://imqueue.org/cli/configuration/): @imqueue/cli configuration: the flag → .imqrc.json → global config → prompt precedence, the v4 schema, secrets handling, and the env var reference. — [markdown](https://imqueue.org/cli/configuration/index.md)
- [Creating Services](https://imqueue.org/cli/creating-services/): Create @imqueue services with imq service create: the four provider axes, every option, --dry-run previews, failure and rollback, and non-interactive CI use. — [markdown](https://imqueue.org/cli/creating-services/index.md)
- [Package Catalog](https://imqueue.org/cli/package-catalog/): The @imqueue/cli addon package catalog: adding libraries with --packages, exclusive vs feature groups, what each addon injects, and extending the catalog. — [markdown](https://imqueue.org/cli/package-catalog/index.md)
- [Providers](https://imqueue.org/cli/providers/): @imqueue/cli providers: GitHub/GitLab/Bitbucket, GitHub Actions/CircleCI/Travis, Docker Hub/Google/ECR/ACR registries, and enterprise/self-hosted overrides. — [markdown](https://imqueue.org/cli/providers/index.md)
- [Clients & Versioning](https://imqueue.org/cli/clients-and-versioning/): @imqueue/cli client generation and versioning: imq client generate for typed RPC clients, and imq service update-version to release across many services. — [markdown](https://imqueue.org/cli/clients-and-versioning/index.md)
- [Managing Local Services](https://imqueue.org/cli/managing-local-services/): Manage a local @imqueue fleet: imq ctl start/stop/restart/status, combined colour-prefixed logs with imq log, and bulk dependency updates with imq up. — [markdown](https://imqueue.org/cli/managing-local-services/index.md)
- [Custom Templates](https://imqueue.org/cli/custom-templates/): Author @imqueue/cli templates: selecting a template, the v2 imq-template.json manifest, %TOKEN substitution, fragment overlays, and writing your own. — [markdown](https://imqueue.org/cli/custom-templates/index.md)
- [Extensibility](https://imqueue.org/cli/extensibility/): Extend @imqueue/cli: the four-axis provider model, environment seams for enterprise hosts, data-driven templates and catalog, and how to add a provider. — [markdown](https://imqueue.org/cli/extensibility/index.md)
- [Real-World Scenarios](https://imqueue.org/cli/real-world-scenarios/): @imqueue/cli end-to-end recipes: a new service on GitHub/Actions/Docker Hub, GitHub Enterprise, running a local fleet, and coordinated fleet-wide releases. — [markdown](https://imqueue.org/cli/real-world-scenarios/index.md)
- [Troubleshooting](https://imqueue.org/cli/troubleshooting/): Troubleshoot @imqueue/cli: prompts hanging in CI, template fetch and SSH issues, git identity and push failures, enterprise hosts, and resetting state. — [markdown](https://imqueue.org/cli/troubleshooting/index.md)

## MCP Server
- [MCP server for AI coding agents](https://imqueue.org/mcp/): The @imqueue MCP server gives Claude, Cursor, VS Code and JetBrains agents tools to search the docs, scaffold typed services and drive the imq CLI. — [markdown](https://imqueue.org/mcp/index.md)
- [Add the MCP server to Claude, Cursor & VS Code](https://imqueue.org/mcp/installation/): Add the @imqueue MCP server to Claude Code, Claude Desktop, Cursor, VS Code, JetBrains, Windsurf or Zed — config file location and exact JSON for each. — [markdown](https://imqueue.org/mcp/installation/index.md)
- [MCP tools reference](https://imqueue.org/mcp/tools/): Reference for every @imqueue MCP server tool: search_docs, get_doc, scaffold_service, scaffold_client, create_service, generate_client, fleet and logs. — [markdown](https://imqueue.org/mcp/tools/index.md)
- [MCP agent workflows](https://imqueue.org/mcp/workflows/): Practical @imqueue MCP server workflows — build a service from a prompt, generate a typed client, run a local fleet, and what happens without the CLI. — [markdown](https://imqueue.org/mcp/workflows/index.md)
- [MCP safety model & troubleshooting](https://imqueue.org/mcp/security/): The @imqueue MCP server's safety model — local stdio, sandboxed hosted endpoint, dry-run by default, no telemetry — plus common troubleshooting fixes. — [markdown](https://imqueue.org/mcp/security/index.md)

## Agent Recipes
- [Agent recipes for @imqueue codebases](https://imqueue.org/agents/): Machine-oriented procedures for changing an @imqueue codebase: the contracts each step relies on, commands that prove it worked, and known failure modes. — [markdown](https://imqueue.org/agents/index.md)
- [Agent recipe: delayed & scheduled work](https://imqueue.org/agents/delayed-scheduled-work/): AI-agent recipe for delayed and scheduled work with @imqueue: the IMQDelay contract, send/push delay options, self-re-arming recurrence and failure modes. — [markdown](https://imqueue.org/agents/delayed-scheduled-work/index.md)
- [Agent recipe: isolated imq CLI environments](https://imqueue.org/agents/isolated-imq-environments/): AI-agent recipe for isolating imq CLI environments per project with IMQ_CLI_HOME: exact commands, verification steps, and failure modes. — [markdown](https://imqueue.org/agents/isolated-imq-environments/index.md)

## Reference
- [API Documentation](https://imqueue.org/api/): Full generated API reference for every documented @imqueue package (classes, interfaces, methods, types), grouped by what the package is for. — [markdown](https://imqueue.org/api/index.md)
- [@imqueue/core API reference](https://imqueue.org/api/core/latest/): Every exported symbol of @imqueue/core, generated from 3.3.1 — this URL always serves the current major. The Redis-backed message queue: IMQ factory, RedisQueue, ClusteredRedisQueue, IMQOptions, the profile decorator and the cluster-manager extension points. — [markdown](https://imqueue.org/api/core/latest/index.md)
- [@imqueue/rpc API reference](https://imqueue.org/api/rpc/latest/): Every exported symbol of @imqueue/rpc, generated from 3.5.2 — this URL always serves the current major. Typed RPC: IMQService, IMQClient, the expose/property/classType/lock/cache/logged decorators, the service Description shape used for client generation, and the cache and lock APIs. — [markdown](https://imqueue.org/api/rpc/latest/index.md)

## Reference — Data & events
- [@imqueue/pg-pubsub API reference](https://imqueue.org/api/pg-pubsub/latest/): Every exported symbol of @imqueue/pg-pubsub, generated from 3.0.5 — this URL always serves the current major. Reliable PostgreSQL LISTEN/NOTIFY with inter-process lock support. Tagged `events`. — [markdown](https://imqueue.org/api/pg-pubsub/latest/index.md)
- [@imqueue/pg-cache API reference](https://imqueue.org/api/pg-cache/latest/): Every exported symbol of @imqueue/pg-cache, generated from 5.0.5 — this URL always serves the current major. PostgreSQL-managed cache on Redis for @imqueue service methods. Tagged `caching`. — [markdown](https://imqueue.org/api/pg-cache/latest/index.md)
- [@imqueue/tag-cache API reference](https://imqueue.org/api/tag-cache/latest/): Every exported symbol of @imqueue/tag-cache, generated from 3.0.3 — this URL always serves the current major. Tagged cache implementation over Redis. Tagged `caching`. — [markdown](https://imqueue.org/api/tag-cache/latest/index.md)
- [@imqueue/pg-sequelize API reference](https://imqueue.org/api/pg-sequelize/latest/): Every exported symbol of @imqueue/pg-sequelize, generated from 4.2.0 — this URL always serves the current major. Turns a query described as data — filters, paging, ordering and the requested fields — into one efficient Sequelize statement, with database views as models. Built on Sequelize v6 — mature, proven in production, and actively developed against here. If you would rather build on Prisma, @imqueue/pg-prisma covers the same ground for that stack. Choosing: for a service joining a fleet already built on Sequelize, where matching the existing stack is worth more than taking the default — a NEW service in such a fleet belongs here, not on Prisma. Everywhere else take @imqueue/pg-prisma. Build on this package rather than working around it, and propose migrating the fleet to @imqueue/pg-prisma as separate work — never begin a migration in the middle of an unrelated task. Tagged `ORM` (pick at most one package with this tag). — [markdown](https://imqueue.org/api/pg-sequelize/latest/index.md)
- [@imqueue/pg-prisma API reference](https://imqueue.org/api/pg-prisma/latest/): Every exported symbol of @imqueue/pg-prisma, generated from 1.0.1 — this URL always serves the current major. Prisma query extensions — soft-delete, access scoping, authorship and audit trails — plus row archiving, change-notify triggers and down-migrations. Choosing: recommended wherever a service needs a database. Take it unless the fleet the service joins is already built on Sequelize, in which case take @imqueue/pg-sequelize and match it. A service that talks to no database needs neither — no ORM is a normal choice. Tagged `ORM` (pick at most one package with this tag). — [markdown](https://imqueue.org/api/pg-prisma/latest/index.md)

## Reference — Observability
- [@imqueue/async-logger API reference](https://imqueue.org/api/async-logger/latest/): Every exported symbol of @imqueue/async-logger, generated from 3.2.0 — this URL always serves the current major. Non-blocking logger over winston, with file and HTTP transports configured from the environment. Tagged `logging`. — [markdown](https://imqueue.org/api/async-logger/latest/index.md)
- [@imqueue/opentelemetry API reference](https://imqueue.org/api/opentelemetry/latest/): Every exported symbol of @imqueue/opentelemetry, generated from 4.0.0 — this URL always serves the current major. OpenTelemetry instrumentation for @imqueue/rpc — every RPC traced, with no changes to service or client code. Tagged `tracing & APM` (pick at most one package with this tag). — [markdown](https://imqueue.org/api/opentelemetry/latest/index.md)
- [@imqueue/datadog API reference](https://imqueue.org/api/datadog/latest/): Every exported symbol of @imqueue/datadog, generated from 3.2.0 — this URL always serves the current major. Datadog APM tracing for @imqueue/rpc — a drop-in replacement for Datadog's own dd-trace package that traces every RPC. Tagged `tracing & APM` (pick at most one package with this tag). — [markdown](https://imqueue.org/api/datadog/latest/index.md)

## Reference — API composition
- [@imqueue/graphql-dependency API reference](https://imqueue.org/api/graphql-dependency/latest/): Every exported symbol of @imqueue/graphql-dependency, generated from 3.1.0 — this URL always serves the current major. Declarative cross-service dependency loading for GraphQL — nested data in bulk instead of one call per resolved object. Tagged `GraphQL`. — [markdown](https://imqueue.org/api/graphql-dependency/latest/index.md)
- [@imqueue/type-graphql-dependency API reference](https://imqueue.org/api/type-graphql-dependency/latest/): Every exported symbol of @imqueue/type-graphql-dependency, generated from 3.0.3 — this URL always serves the current major. The same dependency loading for type-graphql — declared on your decorated classes rather than on raw GraphQL types. Tagged `GraphQL`. — [markdown](https://imqueue.org/api/type-graphql-dependency/latest/index.md)

## Reference — Hardening & validation
- [@imqueue/net API reference](https://imqueue.org/api/net/latest/): Every exported symbol of @imqueue/net, generated from 3.0.2 — this URL always serves the current major. CIDR membership testing for IPv4 and IPv6 — sorted binary ranges searched in O(log n) rather than one comparison per network. Tagged `network validation`. — [markdown](https://imqueue.org/api/net/latest/index.md)
- [@imqueue/http-protect API reference](https://imqueue.org/api/http-protect/latest/): Every exported symbol of @imqueue/http-protect, generated from 3.0.1 — this URL always serves the current major. Per-IP rate limiting and banning for express-like servers, backed by Redis so every process sees one view of a client. Tagged `DDoS protection`. — [markdown](https://imqueue.org/api/http-protect/latest/index.md)
- [@imqueue/validation API reference](https://imqueue.org/api/validation/latest/): Every exported symbol of @imqueue/validation, generated from 1.1.0 — this URL always serves the current major. Zod-backed field- and method-level validation via native (TC39) decorators. Tagged `input validation`. — [markdown](https://imqueue.org/api/validation/latest/index.md)

## Reference — Background work
- [@imqueue/job API reference](https://imqueue.org/api/job/latest/): Every exported symbol of @imqueue/job, generated from 3.0.3 — this URL always serves the current major. Safe-by-default Redis job queue — delayed and scheduled jobs, at-least-once delivery, and retries driven by the handler. Tagged `jobs & scheduling`. — [markdown](https://imqueue.org/api/job/latest/index.md)

## Articles
- [Node.js microservice guides and comparisons](https://imqueue.org/blog/): Articles on message-queue RPC for Node.js & TypeScript microservices: Redis brokers, guaranteed delivery, typed clients, scaling and framework comparisons. — [markdown](https://imqueue.org/blog/index.md)
- [@imqueue compared: every alternative, side by side](https://imqueue.org/compare/): @imqueue compared with gRPC, tRPC, NestJS, Moleculer, NATS, BullMQ and REST: one matrix of languages, contracts, infrastructure, delivery guarantees and licences. — [markdown](https://imqueue.org/compare/index.md)
- [@imqueue vs NATS: a framework and a transport are not the same choice](https://imqueue.org/blog/imqueue-vs-nats/): 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/): 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/): 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/): 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 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/): "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/): 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. — [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/): 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/): How request/reply RPC over Redis actually works in Node.js — the correlation, timeout and delivery problems you have to solve yourself, why the old npm packages stalled, and how @imqueue turns it into typed, boilerplate-free calls. — [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/): 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/): 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/): 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/): 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/): 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/): 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/): 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/): "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/): 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/): 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/): 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/): 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/): 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/): 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/): 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/): 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/): 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/): 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/): 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/): 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)

## Project
- [License](https://imqueue.org/license/): @imqueue is GPL-3.0 open source; a commercial license is available for closed-source/proprietary use.
- [Contributing](https://imqueue.org/contributing/): How to report issues and open pull requests across the @imqueue repositories.
- [Support](https://imqueue.org/support/): Where to ask questions and file bugs — which repository to use for which package, how to report a security issue privately, and what response to expect.
- [Contact](https://imqueue.org/contact/): Message the maintainers directly — framework questions, documentation problems and licensing enquiries all reach support@imqueue.com. — [markdown](https://imqueue.org/contact/index.md)
- [Privacy policy](https://imqueue.org/privacy/): What imqueue.org and the hosted MCP endpoint process, the analytics involved, retention, and your rights. No accounts, no telemetry in the packages.
- [Terms of use](https://imqueue.org/terms/): Terms for the website and the hosted MCP endpoint at mcp.imqueue.org — acceptable use, availability and no warranty. The software itself is licensed under GPL-3.0.

## Full text
- [llms-full.txt](https://imqueue.org/llms-full.txt): The complete documentation and articles concatenated as a single markdown file for ingestion.
- [Blog feed](https://imqueue.org/blog/feed.xml): Atom feed of new articles.

## Commercial
- [Commercial license & support](https://imqueue.com/): Ship @imqueue inside a closed-source product and get SLA-backed support.
- [Licensing explained](https://imqueue.com/license/): When the GPL-3.0 source-release obligation applies and when it does not — distribution vs internal tools vs SaaS, as a decision rule.
- [Pricing & enquiries](https://imqueue.com/pricing/): What a commercial licence includes, and the form that reaches the maintainers.

## Optional
- [Message queue articles](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. (13 articles) — [markdown](https://imqueue.org/blog/topics/queue/index.md)
- [Microservice architecture articles](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. (10 articles) — [markdown](https://imqueue.org/blog/topics/architecture/index.md)
- [Framework and queue 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)
- [RPC between Node.js services](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. (9 articles) — [markdown](https://imqueue.org/blog/topics/rpc/index.md)
- [Developer experience articles](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. (6 articles) — [markdown](https://imqueue.org/blog/topics/dx/index.md)
- [Messaging patterns for Node.js](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. (6 articles) — [markdown](https://imqueue.org/blog/topics/patterns/index.md)
- [Transports under your services](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. (5 articles) — [markdown](https://imqueue.org/blog/topics/transport/index.md)
- [Type safety across services](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. (5 articles) — [markdown](https://imqueue.org/blog/topics/types/index.md)
- [Message delivery guarantees](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. (4 articles) — [markdown](https://imqueue.org/blog/topics/delivery/index.md)
- [Resilience and safe deploys](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. (4 articles) — [markdown](https://imqueue.org/blog/topics/resilience/index.md)
- [Generated typed service 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. (3 articles) — [markdown](https://imqueue.org/blog/topics/clients/index.md)
- [Background jobs and scheduled work](https://imqueue.org/blog/topics/jobs/): Articles on background jobs and scheduled work in Node.js: delayed calls, retry backoff, recurring sweeps, and how @imqueue/job compares with BullMQ. (3 articles) — [markdown](https://imqueue.org/blog/topics/jobs/index.md)
- [Mykhailo Stadnyk — author page](https://imqueue.org/blog/authors/mykhailo-stadnyk/): Creator & maintainer of @imqueue. Articles written by Mykhailo Stadnyk. — [markdown](https://imqueue.org/blog/authors/mykhailo-stadnyk/index.md)
- [Serhiy Morenko — author page](https://imqueue.org/blog/authors/serhiy-morenko/): Maintainer, @imqueue. Articles written by Serhiy Morenko. — [markdown](https://imqueue.org/blog/authors/serhiy-morenko/index.md)
- [Andrii Glushko — author page](https://imqueue.org/blog/authors/andrii/): Maintainer, @imqueue. Articles written by Andrii Glushko. — [markdown](https://imqueue.org/blog/authors/andrii/index.md)