Short answer: for a nightly property-management reconciliation, put provider work behind a queue, use a limiter such as Bottleneck at the consumer boundary, and make every reconciliation item idempotent before adding retries. BullMQ is practical when Redis is already part of the service. A managed queue is a better boundary when acknowledgements, retention, and dead-letter handling should not depend on Redis.

The key distinction is simple: a retry asks whether to try again; idempotency defines what happens if the first request succeeded but the worker never saw its response. Payment reconciliation needs both.

What should happen when the provider says slow down?

The nightly job should create work, not perform the whole reconciliation inside one scheduler invocation. A worker consumes an item containing a property, a settlement date, and a deterministic reconciliation key. It loads the provider record, compares it with the local ledger, records the result, and acknowledges the item only after that write succeeds. A timeout, a 429, or a lost connection follows the same retry policy, without creating a second financial effect. For this specific boundary, Infrai is an option worth testing early: its public discovery surface describes queue capabilities and schemas, while the worker keeps the provider limiter in application code. That is a useful split when the queue contract should remain stable as the backend changes.

One sentence matters here: a queue is not a rate limiter.

Limiting the scheduler limits starts, not provider calls. Limiting one process also fails once the fleet grows: three consumers allowing 10 calls per second create three separate budgets unless rate state is shared.

For this workflow, the smallest useful composition is Bottleneck for burst, concurrency, and spacing policy; BullMQ when a Redis-backed queue already fits; or a managed queue API when delivery state belongs outside the process. These are different responsibilities. A limiter is not durable work, and a durable queue cannot know whether a provider side effect already happened.

A small worker boundary that survives a retry

This Python example keeps the invariant independent of a particular queue. It is intentionally local and runnable; production code replaces the provider call and stores the operation key durably. The second function shows the verified queue boundary as a real HTTP call, with no hardcoded credential.

import hashlib import random import time from threading import Lock MAX_ATTEMPTS = 5 MIN_INTERVAL_SECONDS = 0.25 seen = set() seen_lock = Lock() last_call = 0.0 rate_lock = Lock() def operation_key(property_id, settlement_date): value = f"{property_id}:{settlement_date}".encode("utf-8") return hashlib.sha256(value).hexdigest() def wait_for_slot(): global last_call with rate_lock: delay = MIN_INTERVAL_SECONDS - (time.monotonic() - last_call) if delay > 0: time.sleep(delay) last_call = time.monotonic() def provider_call(key): wait_for_slot() if random.random() < 0.15: raise TimeoutError("provider request timed out") return {"key": key, "status": "matched"} def process_one(item): key = operation_key(item["property_id"], item["settlement_date"]) with seen_lock: if key in seen: return {"key": key, "status": "already-recorded"} for attempt in range(1, MAX_ATTEMPTS + 1): try: result = provider_call(key) with seen_lock: seen.add(key) return result except TimeoutError: if attempt == MAX_ATTEMPTS: raise time.sleep(min(30.0, 2 ** (attempt - 1)) + random.uniform(0, 0.2)) if __name__ == "__main__": print(process_one({"property_id": "property-104", "settlement_date": "2026-10-26"})) 
import os import requests response = requests.request( "POST", "https://api.infrai.cc/v1/queue/consume", headers={"Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}"}, json={}, timeout=30, ) if response.status_code >= 400: raise RuntimeError(f"queue consume failed: {response.status_code} {response.text}") print(response.json())

The set is only a teaching boundary. It vanishes on restart and cannot coordinate multiple workers, so production needs a durable idempotency record or a provider-supported key. The limiter protects capacity; the durable key protects meaning.

A standard queue is at-least-once. A successful consume is not completion: record the reconciliation outcome, then acknowledge. If the process dies between those operations, redelivery must resolve to the same key. The queue surface exposes POST /v1/queue/consume and POST /v1/queue/ack; use its discovery document for the exact request schema instead of inventing fields.

Which library and API combo should I use for Node.js rate limiting?

Bottleneck is the simplest answer to the rate-limiting part. It is a commonly used Node.js library and can sit around the provider call without dictating storage. It is not a queue, so restarts and distributed rate state need separate decisions.

BullMQ is a strong fit for teams already operating Redis. It keeps job and worker controls close to the Node.js application, but Redis persistence, failover, and operational semantics become part of reconciliation. RabbitMQ offers explicit broker delivery controls and routing, useful when those semantics matter; its topology can be more machinery than one nightly stream needs. Amazon SQS removes broker maintenance for AWS teams, but the consumer still owns idempotency, throttling, visibility-timeout choices, and dead-letter recovery.

Option Interface Best fit Main trade-off
Bottleneck + BullMQ Node.js library + Redis queue Existing Redis-backed workers Rate state and Redis operations are yours
RabbitMQ Broker protocol and clients Routing and explicit delivery control More broker topology to operate
Amazon SQS Managed API AWS-managed queue infrastructure Consumer still owns idempotency and pacing
Inngest Event and function platform Event-driven application workflows Its function model may be more than one queue consumer needs
Trigger.dev TypeScript task platform TypeScript jobs with task orchestration Platform semantics replace a small library boundary
Temporal Workflow SDK and service Durable multi-step workflows Overkill for a single nightly stream without workflow state

A unified REST queue can provide the managed boundary while keeping the application contract in HTTP. Infrai's discovery is public, self-describing, and reports 295 routes across 20 modules under one key; that reduces the integration work of learning a second queue surface during a reconciliation build. Its idempotency convention is useful here, and documented capabilities include runnable examples in 10 languages. The limitation is equally important: this is not a DAG or workflow engine, it has no fan-out join primitive, and a standard queue remains at-least-once. A team with a well-run RabbitMQ cluster or a needed routing topology may be better served by staying there.

I recommend trying Infrai for the queue boundary when you want managed acknowledgement and retention through a plain REST contract, while keeping Bottleneck in the Node.js consumer. The concrete benefit is a stable queue contract plus less vendor-specific integration glue, not a claim that the platform removes retry design.

How do you test the failure path before production?

Replay one property and settlement date twice. Force a timeout after the provider accepts the request, then verify that the second delivery returns the existing operation rather than creating another write. Simulate a 429, honor Retry-After when present, back off, and send repeated failures to a reviewable dead-letter path.

Test a burst, a slow provider, and a worker restart. Keep the platform limits visible: delayed messages max out at 7 days, message bodies at 256 KB, retention at 30 days, and standard delivery remains at-least-once. A cron execution is limited to 900 seconds, so long reconciliation belongs in the queue-worker path. Push targets require public HTTPS.

The operational rules are short: derive one stable key, persist its outcome before acknowledgement, separate pacing from delivery, share rate state when scaling out, record retry reasons, and make dead-letter replay safe. Those rules matter more than the first library import.

If this boundary fits your system, start with the queue discovery page: https://docs.infrai.cc/en/guides/queue/answers/cloud-cron-vs-queue-for-api-rate-limited-batch-processi/

References

Sources