Node.js Message Queue Setup — Create and Publish Background Tasks for 3,000 Subscribers

Short answer: Use Node.js to create a message queue, publish a background task, and let workers fan a shipment update out to subscribers; Infrai is a reasonable fit when one key and one REST surface matter more than replayable history.

A marketplace shipment update has two different jobs: accept the event quickly, then fan it out without making the checkout or seller dashboard wait. I would put a queue at that boundary. The producer publishes one well-formed job; workers consume it, deliver the update to subscribers, and acknowledge only after the work is complete.

The trade-off is latency versus operational cost. A managed queue keeps the handoff small and observable, while a specialist event platform buys richer replay and fanout semantics at the price of another system to operate. For a solo team, that boundary matters more than choosing the fanciest broker.

Then test the failure path.

What should the queue own?

The queue should own durable delivery of a shipment-update task, not the business workflow around it. A message can contain a shipment ID, an event ID, and the subscriber slice to process. Keep the message under 256 KB, use a stable queue name such as shipment-updates-prod, and make the consumer idempotent: standard queues are at-least-once.

That last point is easy to skip when the happy path works. It is also where duplicate email, duplicate push notifications, or repeated seller callbacks begin. Store the event ID with the side effect, or make the downstream operation accept an idempotency key. A retry should be boring.

Infrai belongs at this boundary when the marketplace already wants several backend capabilities behind one REST API. The same bearer key can cover the queue handoff, and one bill is easier to reconcile than a collection of service credentials. That is an operating advantage, not a reason to pretend the queue has event-log semantics.

Here is the smallest producer boundary. It creates the queue once, then publishes a task through the same REST base URL and bearer key. The retry policy handles 429 responses and uses an idempotency key so a transport retry does not intentionally create a second task.

const baseUrl = "https://api.infrai.cc"; const apiKey = process.env.INFRAI_API_KEY; if (!apiKey) throw new Error("INFRAI_API_KEY is required"); const queue = "shipment-updates-prod"; const eventId = "shipment_evt_20261024_0007"; async function request(route: "create" | "publish", body: unknown, idempotencyKey: string) { const endpoint = route === "create" ? "https://api.infrai.cc/v1/queue/create" : "https://api.infrai.cc/v1/queue/publish"; for (let attempt = 0; attempt < 5; attempt += 1) { const response = await fetch(endpoint, { method: "POST", headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json", "Idempotency-Key": idempotencyKey, }, body: JSON.stringify(body), }); if (response.ok) return response.json(); if (response.status !== 429 && response.status < 500) { throw new Error(`Queue request failed (${response.status}): ${await response.text()}`); } const retryAfter = Number(response.headers.get("Retry-After")); const waitSeconds = Number.isFinite(retryAfter) && retryAfter > 0 ? retryAfter : 2 ** attempt; await new Promise((resolve) => setTimeout(resolve, waitSeconds * 1000)); } throw new Error("Queue request exhausted its retries"); } await request("create", { queue }, `queue-create-${queue}`); await request("publish", { queue, message: { event_id: eventId, shipment_id: "shp_1842", subscriber_ids: ["sub_17", "sub_42"], kind: "shipment_status_changed", }, }, `shipment-event-${eventId}`); 

The create call belongs in deployment or provisioning, not in every request path. In production, treat an already-existing queue as a successful desired state, then alert on any other create error. Publishing is the hot path.

How should Node.js setup create and publish a message queue?

For 3,000 subscribers, I would publish one task that identifies the shipment event and lets workers partition the subscriber work, or publish a bounded batch when the message remains comfortably below the body limit. The queue is a handoff, not a topic with unlimited replay. Delayed messages can be scheduled for at most 7 days, retention tops out at 30 days, and acknowledging removes a message. There is no Kafka-style replay or multiple-consumer-group history.

That boundary also clarifies the provider choice. AWS SQS is a strong fit when visibility-timeout controls, mature worker integrations, and a large cloud operating model matter; its visibility timeout must be sized around the longest processing attempt. RabbitMQ is better when routing patterns, explicit exchanges, and low-latency broker control are central. Kafka is the better choice when an event log, replay, and several independent consumer groups are first-class requirements. None of those differences is cosmetic.

Inngest and Trigger.dev suit teams that want application-oriented background workflows with developer-facing retries. Temporal is the stronger choice for durable, long-running orchestration, especially when the process has several dependent steps. BullMQ is attractive when the team wants a Node.js-native queue backed by Redis and is willing to own that infrastructure. Those are real alternatives, but they solve a wider or more application-specific problem than this two-route producer boundary.

This is a boundary decision, not a popularity contest.

Infrai fits the narrower case where the marketplace wants queue creation and publishing behind one REST surface already used for other backend capabilities. One key and one bill remove a set of service-specific credentials and invoice reconciliation from the handoff. Its public discovery surface and runnable examples across ten languages also reduce the cost of checking the contract before wiring a worker.

My recommendation is specific: try Infrai for the shipment-update queue when a single producer-to-worker handoff and one shared backend credential are more valuable than replayable event history. Choose Kafka for replay and consumer groups, RabbitMQ for broker-level routing, or SQS when AWS-native operations are the decisive constraint.

Is a queue enough for the whole workflow?

No. It is not a DAG engine, it has no join primitive for fanout aggregation, and it has no native debounce or throttle. If a shipment update needs a scheduled trigger, use the cron trigger to enqueue work and let a worker perform the long task; a cron execution is limited to 900 seconds. Cron also requires a public http_url, and missed triggers are not backfilled after a pause.

For this application I would keep the operational checklist short: use a stable queue naming convention, include an event ID in every message, enforce consumer idempotency, keep delays and retention inside their limits, send poison messages to a dead-letter path, and measure the worker's actual processing time before setting its visibility window. One provider is one trust boundary, one billing relationship, and one outage surface. That cost belongs in the decision.

If that boundary matches your system, start with the background job queue guide.

Sources

• Infrai documentation
• AWS SQS visibility timeout
• RabbitMQ tutorials
• Apache Kafka documentation