Queue service and Webhook notification dispatching

Budget: 150 EUR Deadline: 4 days

😀 Hello!
✅ I will complete it quickly and efficiently 👌
✅ I have already done similar backend services on Node.js/TypeScript (queues, webhooks, API integrations) 🎯
🛠 How I will do it: NestJS/Fastify + BullMQ (Redis) + PostgreSQL/Prisma; POST /webhooks/dispatch → to the queue; delivery with HMAC signature X-Signature (SHA256); retry Exponential Backoff (1/5/15/30 min); GET /webhooks/logs with filters; tests and launch instructions.
🎥 Portfolio: Freelancehunt
✅ Feel free to reach out, we will discuss the details 👌🙂

Budget: 70 EUR Deadline: 2 days

Good day. I will implement a webhook delivery service with queues and retry policies on NestJS using BullMQ and Redis for reliable task processing. I am ready to discuss the details and start working. I look forward to collaborating.

Budget: 150 EUR Deadline: 5 days

Good day.

I have extensive experience. Shall we discuss everything in more detail?

Budget: 100 EUR Deadline: 1 day

Good day!
In general, the task is clear. To provide an accurate response regarding deadlines and pricing, I would like to clarify some questions that arose after analyzing your task.
Please write in private messages – we will discuss the details and your wishes.

Budget: 150 EUR Deadline: 2 days

Hello. I have been working with Nest.js/Node.js/React for over 9 years. I have also worked with BullMQ. I am ready for collaboration.

Budget: 100 EUR Deadline: 2 days

Hello.

I can develop such a service for you in NodeJS. Write to me, and we will discuss.

Budget: 2000 EUR Deadline: 7 days

Hello, I worked on WebhookHub — an event delivery service on Node.js/TypeScript with BullMQ and Redis. We processed over 2 million webhooks per day with 99.8% guaranteed delivery.

Your project is very similar: queues, Exponential Backoff (attempts after 1, 5, 15, 30 minutes), X-Signature (SHA256) signing, and logging in PostgreSQL via Prisma. This is exactly what we have already implemented. ✅

I would like to clarify a logical question: how do you plan to handle delivery duplicates (idempotency)? For example, if the target server received a webhook, but the response was lost due to a 5-second timeout — should a unique idempotency-key be provided so that the client does not process the same event twice?

I suggest we get in touch; I will consult you for free on the technical side and we can create a development plan + I will tell you about my team!

Budget: 1000 EUR Deadline: 14 days

Hello! The technical specifications are clear; I'll go over a couple of places where such services usually stumble.

The intervals of 1/5/15/30 are not built-in exponential in BullMQ; it provides a power grid. Therefore, I register a custom backoff strategy and maintain an exact schedule of attempts so that retries occur exactly at 1, 5, 15, and 30 minutes, as per the criteria.

I create the X-Signature using HMAC-SHA256 on the raw body of the request (crypto.createHmac), rather than a simple hash of the string, so the recipient can correctly verify the sender. I implement a 5-second timeout using AbortController, which actually cancels the request and frees the connection after the time expires.

Attempt logs are stored in PostgreSQL via Prisma, with GET /webhooks/logs having filters by status and targetUrl. The typing is strict, without any, and the entire stack of App + Redis + PostgreSQL runs in Docker Compose, launched with a single command.

We can discuss all the project details in private messages. I look forward to collaborating.

Budget: 300 EUR Deadline: 4 days

Good day! I will do it, no questions. I have already done something similar for myself (for a project) - https://github.com/erimeilis/test-webhook, a bit simpler.

Budget: 50 EUR Deadline: 1 day

Good day, Ivan.

Your retry intervals (1/5/15/30 min) are not the standard BullMQ exponential, so the backoff requires custom configuration via `backoff.custom`, otherwise the timings will "go off" by the third attempt. I will implement the X-Signature as HMAC-SHA256 with a timestamp in the payload — this will protect your clients from replay attacks, not just verify the sender. A 5-second timeout is essential with AbortController to prevent a hanging socket from blocking the worker and accumulating the queue. Logs in PostgreSQL via Prisma will give you filtering by status and targetUrl without full table scans — a composite index on (status, targetUrl, createdAt) is needed.

Options:

≈4 days: 150–200 EUR
Minimum viable service for guaranteed message delivery.
- Functional API for sending webhooks
- Basic BullMQ queue with retries
- Verification of the X-Signature for data security
- Docker configuration for quick startup

or

≈8 days: 300–400 EUR
Full technical stack according to the specifications, including enhanced monitoring and attack protection.
- Exact implementation of retry intervals (1/5/15/30 min) via custom backoff
- Protection against replay attacks using timestamps in the signature
- Optimized database with indexes for quick log searches
- Strict timeout control via AbortController for queue stability
- Full TypeScript typing without using any

+additional

+≈6 days: 200-250 EUR
High-performance solution with increased fault tolerance and management tools.
- Automatic cleanup system for outdated logs (Data Retention)
- Enhanced error handling with detailed status classification
- Optimization for high loads (tuning Redis and workers)
- API documentation in Swagger/OpenAPI format Expand

Budget: 5000 EUR Deadline: 3 days

Good day!

I am a full-stack developer. Stack: Next.js, TypeScript, React, Node.js, Python, PostgreSQL/Prisma.

What I can do for you:
— websites and landing pages from Figma designs, responsive and SEO;
— online stores with integrations: CRM, Nova Poshta, online payments, product feeds;
— Telegram bots and Mini Apps (grammY, aiogram);
— AI integrations: chatbots, RAG agents based on your materials, Claude/OpenAI API;
— automation and parsing in Python (Playwright), working with APIs;
— WebGL / Three.js — interactive 3D scenes and shader animation;
— deployment and server setup: Docker, Nginx, SSL, backups, monitoring.

The code and access will be entirely yours after completion. I work through Safe, in phases with clear deadlines and transparent communication. Languages: Ukrainian, Russian, English.

Please write the details of the task — I will provide an estimate and timeline and send examples of my work. Expand

Budget: 600 EUR Deadline: 1 day

Good morning,
I am interested in carrying out your project regarding the creation of a reliable Webhook Delivery Engine in Node.js/TypeScript.

I have experience in building backend services based on NestJS and Fastify, as well as in implementing BullMQ queues, integrating with Redis, logging events, and designing stable retry mechanisms using exponential backoff. I have also worked with PostgreSQL and Prisma ORM, creating systems based on guaranteed data delivery and full event logging.

As part of the implementation, I can provide:

the implementation of a complete API according to the requirements (POST /webhooks/dispatch, GET /webhooks/logs),

support for webhook signing (HMAC SHA256),

full handling of timeouts and network errors,

a BullMQ queue with a retry policy (1, 5, 15, 30 minutes),

logging all delivery attempts to PostgreSQL,

preparation of a complete Docker environment (App + Redis + PostgreSQL),

clear, fully typed code in TypeScript,

documentation for setup and configuration.

I would be happy to take on the assignment and can start working immediately.
Please contact me to discuss technical details and to establish the scope and schedule.

Best regards,
Joanna Expand

Budget: 160 EUR Deadline: 4 days

I created queues on BullMQ with exponential backoff and dead-letter after N attempts — your task is clear down to the details. I will sign the payload with HMAC-SHA256 in X-Signature with a timestamp against replay attacks, attempt statuses will be in Postgres via Prisma, and idempotency will be based on event_id. Question: is a separate endpoint needed for manual retry from DLQ? Deadline is 5 working days, 13000 UAH, daily updates on progress.

Budget: 330 EUR Deadline: 5 days

Hi,
I can build this Webhook Delivery Engine as a production-ready internal service.
Scope I’ll deliver:
• POST /webhooks/dispatch — enqueue jobs with targetUrl, secretKey, payload
• Worker with POST delivery + X-Signature (HMAC-SHA256)
• Retry policy with exponential backoff: 1, 5, 15, 30 minutes
• Timeout handling (abort after 5s)
• GET /webhooks/logs — filter by status + targetUrl
• Prisma + PostgreSQL for attempt logging
• Docker Compose: App + Redis + PostgreSQL
• Full TypeScript typing (no any)
Stack proposal:
• NestJS + BullMQ (Redis)
• Prisma + PostgreSQL
• Axios/fetch with AbortController for timeouts
I can share a short architecture diagram and API contract before coding if needed.
I have also some questions as follow.
1. NestJS or Fastify preferred?
2. Max retry attempts after 30 min — stop, or keep retrying?
3. Should failed jobs after all retries go to a dead-letter queue?
4. Auth required for /dispatch and /logs (API key)?
5. Do you need idempotency keys to avoid duplicate deliveries? Expand

Budget: 162 EUR Deadline: 5 days

Queues + webhooks on NestJS/BullMQ — the stack matches perfectly.

⚙️ I will create a service for receiving events into the queue and reliably sending webhook notifications. The scheme is classic, but there are nuances: the delivery of the webhook must be idempotent, with a retry strategy (exponential backoff) and a dead-letter queue for failed attempts — otherwise, in case of a failure on the recipient's side, events are simply lost.

What I will specifically implement:
— Receiving incoming events through Fastify routes (faster than Express, lower overhead)
— Queue on BullMQ + Redis with retry/backoff/cleanup settings
— Delivery of webhook with a timeout, handling 4xx/5xx responses from the recipient
— Log of attempts in PostgreSQL — which ones were sent, which are retried, which failed
— Docker-compose for local setup with one command
— TypeScript throughout, typed DTOs without any

My daily stack — NestJS + BullMQ + PostgreSQL I work with regularly, without needing to learn on the project. I am currently available and can start today. As for timelines — it depends on the volume of endpoints and delivery details (payload signing, retry rules). Send me the conditions — and I will draft the module structure in 15 minutes.

️ After delivery, I won't disappear: edits for new requirements from receivers and updates will be free of charge. Expand

Budget: 348 EUR Deadline: 5 days

Hello! I have extensive experience in developing high-load systems using Node.js/TypeScript. Implementing a Webhook Delivery Engine using BullMQ for queues and Exponential Backoff is a standard task that I am ready to complete efficiently and on time. I will ensure full typing, proper timeout handling, and logging through Prisma. I will provide a ready Docker-compose file for quick deployment of the entire infrastructure. I am ready to start working; let's discuss the details.

Budget: 90 EUR Deadline: 3 days

Hello, Ivan.
I have reviewed the technical specifications. The main task here is not just to send a webhook, but to ensure a predictable delivery pipeline: not to lose tasks, correctly log each attempt, and safely retry delivery in case of a timeout or non-2xx response.
I will implement the service using NestJS + TypeScript with strict typing:
— POST /webhooks/dispatch with data validation and task placement in BullMQ;
— a separate worker for sending webhooks without blocking the API;
— X-Signature via HMAC-SHA256 based on the original payload;
— a hard timeout of 5 seconds using AbortController;
— retries after 1, 5, 15, and 30 minutes;
— logging each attempt in PostgreSQL via Prisma;
— GET /webhooks/logs with filtering and pagination;
— Docker Compose for App, Redis, and PostgreSQL;
— tests for main scenarios and a launch instruction.
I will also provide an idempotency key to ensure that repeated delivery does not lead to double processing of the event on the client side.

Before starting, I just need to clarify one point: should the idempotency key be generated by the service or passed by the client in the request? Expand

Budget: 100 EUR Deadline: 1 day

Доброго дня, Іване!

Зроблю Webhook Delivery Engine під ваше ТЗ: NestJS (або Fastify) + TypeScript, BullMQ/Redis, PostgreSQL + Prisma, Docker (App + Redis + Postgres).

У результаті:

POST /webhooks/dispatch — прийом targetUrl, secretKey, payload, постановка в чергу;
доставка з X-Signature (HMAC-SHA256);
retry з exponential backoff (1 / 5 / 15 / 30 хв) при non-2xx і таймаутах;
таймаут запиту 5 с з коректним скасуванням;
GET /webhooks/logs — історія спроб з фільтром по статусу та targetUrl;
повна типізація TS без any. Expand

Budget: 100 EUR Deadline: 2 days

Hello, Ivan!
I am implementing a Webhook Delivery Engine on NestJS: a queue through BullMQ with a custom backoff for your exact timings (1/5/15/30 minutes, this is not a standard exponential), X-Signature signing through real HMAC-SHA256 (not naive concatenation of payload and key), logging through Prisma and PostgreSQL.

I constantly work on backend development for parsing projects and Telegram bots, but I am building on NestJS and BullMQ for the first time, so I am detailing the approach rather than just saying "I have experience."

What I will do:
- POST /webhooks/dispatch: input validation, logging with a pending status, queuing the task, instant response to the client
- Sending via native fetch with AbortSignal.timeout(5000) - the request is aborted if the server is silent for more than 5 seconds
- X-Signature signing - honest HMAC-SHA256 with secretKey, the key itself will never appear in error logs, even in case of a request failure
- Retries through custom backoff BullMQ: 1, 5, 15, 30 minutes, after the fourth failure the status will be finally failed
- Unique idempotency-key in each payload - if the response from your server is lost due to a timeout, but the request actually reached it, a retry will not lead to processing the event twice on your side
- GET /webhooks/logs: filter by status and targetUrl, plus pagination, so the list is not returned entirely as the table grows
- Docker Compose: application, Redis, PostgreSQL, applying Prisma migrations at startup
- Full typing: DTO with validation, Prisma types, generic Job for queue tasks, no any

I will also address a risk that is not in the technical specification: since the service itself calls any sent targetUrl, without restrictions this is a hole for SSRF attacks (the request can be directed to the internal network or cloud metadata instead of the actual client address). I will add a block for private IP ranges by default.

Please clarify: will POST /webhooks/dispatch be secured by authorization (for example, API key), or is this purely an internal service in a closed network - this affects whether an authentication layer is needed at the endpoint itself. Expand

Budget: 180 EUR Deadline: 3 days

Hello!

I am ready to develop a reliable microservice for delivering Webhook notifications according to your specifications. I have extensive experience in building task queues using Node.js / TypeScript.

How I will implement the project:
1. Architecture: NestJS (or Fastify at your choice) with full strict TypeScript typing (without any).
2. Task queues: I will set up BullMQ based on Redis for reliable event processing with retry logic (Retry Policy) using the Exponential Backoff algorithm.
3. Database: I will connect PostgreSQL through Prisma ORM for storing detailed logs of delivery attempts (Request/Response, HTTP statuses, timeouts).
4. Security: I will implement the generation and verification of the X-Signature (SHA256 HMAC using secretKey) for each request.
5. Fault tolerance: I will set up strict request timeouts (5 seconds) with connection termination in case of the receiving side hanging.
6. Deployment: I will prepare a Docker Compose file (App + Redis + PostgreSQL) for launching the project with a single command.

I will deliver clean, fully tested code within 3 days. I would be happy to discuss the details of the API endpoints in the chat! Expand

Budget: 100 EUR Deadline: 1 day

Hello, I have 5+ years of experience with Nest JS.
Message me privately - we will discuss the details.
I will be happy to help you!

Budget: 130 EUR Deadline: 4 days

Вітаю, Іване! Зроблю Webhook Delivery Engine на NestJS + TypeScript (strict, без any): POST /webhooks/dispatch кладе задачу в BullMQ/Redis, воркер шле POST з підписом X-Signature (SHA256 від payload з secretKey), таймаут 5с, retry з exponential backoff 1/5/15/30 хв на не-2xx або таймаут. Всі спроби логуються в PostgreSQL через Prisma, GET /webhooks/logs з фільтрами за статусом і targetUrl. Docker Compose для сервісу, Redis і Postgres + README. Покрию ключову логіку тестами (Jest).

Budget: 25000 EUR Deadline: 14 days

We have experience in creating high-load event delivery systems. We implement a service on Node.js/TypeScript using Redis for queue management and a flexible retry policy. We will ensure fault tolerance and logging of each request for delivery control. We are ready to start architectural design and solution development.

Budget: 355 EUR Deadline: 7 days

Good day.

The task is clear: it is important not just to send webhook requests, but to create a predictable delivery mechanism that does not lose tasks, correctly retries failed attempts, and allows for quick understanding of what happened with each submission.

I would divide the solution into an API layer, a delivery queue, and a separate worker. This will simplify scaling and will not block the main request during webhook sending. I will also implement protection against hanging requests, a clear status model, and the logging of each attempt so that errors can be diagnosed properly instead of searching through logs manually.

Before delivery, I will check scenarios for successful delivery, timeouts, unavailable recipients, retries, and final failures. I will also prepare the project so that it can be launched with a single command via Docker.

The deadline is up to 7 calendar days, including testing and final verification. If there are no unexpected issues in the environment, I can deliver the result earlier.

Budget: 350 EUR Deadline: 5 days

Hello, Yvan Myronets.

I can start right now on this project

I can build the webhook Delivery Engine in Node.js and typescript using nestJS or Fasify, BullMQ with Redis, PostgreSQL and Prisma.

My approach will be to create a clean dispatch API that accepts targetUrl, secretKey, and JSON payload, signs the payload using SHA256, stores the job in BullMQ, and processes delivery with reliable retry handling.

The worker will send POST requests with the X-Signature header, enforce a 5 second timeout, and trigger exponential backoff retries after 1, 5, 15, and 30 minutes when the target server fails or returns a non 2xx response.

I will also implement delivery attempt logging in PostgreSQL and a logs API with filters by status and targetUrl.

The code will use strict TypeScript types without any, clean structure, validation, error handling, and Docker setup for app, Redis, and PostgreSQL.

I am looking forward your response.

Thank you. Expand

Budget: 150 EUR Deadline: 2 days

Good day.

I have already implemented the webhook delivery service with queues and retry policies on NestJS using Redis as queues for reliable task processing here https://prague.localno.io. I am ready to discuss the details and get started.

Message me!

Budget: 15000 EUR Deadline: 14 days

Hello! The task is clear and well-known in the stack: NestJS, BullMQ, Prisma, PostgreSQL — I have been actively using all of these in commercial projects for the past few years.

Regarding the essence of the task: the key challenges here are not in the routes, but in the reliability of the delivery pipeline. Exponential backoff through BullMQ is set up natively, but it is important to properly handle edge cases: request timeout via AbortController with a 5-second limit, correct attempt status in PostgreSQL even in the event of an unexpected worker crash, and the X-Signature that is generated without leaking the secretKey into the logs. I plan to do all this with full typing without any, with explicit interfaces for payload and delivery attempt.

I will set up Docker Compose with the App + Redis + PostgreSQL stack right away, so it can be launched and tested locally without unnecessary configurations. Logs with filtering by status and targetUrl will be implemented through Prisma with pagination.

I am ready to discuss the details and start quickly.

Budget: 100 EUR Deadline: 2 days

Hello, I can create the service you need.
I have experience working with microservices on node.js, bullMq, and Redis, and I even have an almost ready solution for your case.
You can check the portfolio with similar projects (in the clipDeep profile).
Feel free to message me to discuss timelines and the exact price.

Budget: 150 EUR Deadline: 5 days

Hello,

I can build a reliable Webhook Delivery Engine using Node.js/TypeScript with NestJS (or Fastify), BullMQ + Redis, Prisma + PostgreSQL, and Docker.

The service will include:

* POST /webhooks/dispatch to queue webhook jobs.
* SHA256 X-Signature generation using the provided secret key.
* Reliable delivery with a 5-second timeout and exponential backoff retries (1, 5, 15, 30 minutes).
* GET /webhooks/logs with filtering by status and target URL.
* Complete TypeScript typing without using `any`.
* Docker Compose for quick deployment of the app, Redis, and PostgreSQL.

I write clean, maintainable, and production-ready code with proper error handling and logging. I can start immediately and deliver a solution that meets all the requirements.

Looking forward to working with you! Expand

Budget: 500 EUR Deadline: 12 days

I read the description of your project. It interests me, and I have experience with similar tasks. I am ready to start working and complete it with high quality.
Questions about the project:
1. Is there already a ready API contract, or do we need to agree on it together?
2. Are there any other statuses needed besides success, failed, and retrying?

Budget: 600 EUR Deadline: 7 days

Good day!

I have experience in developing backend services using Node.js, TypeScript, NestJS, as well as creating integration solutions with queues, external APIs, and fault-tolerant task processing.

For implementation, I propose the following stack:
* NestJS + TypeScript
* BullMQ + Redis for queues and retries
* PostgreSQL + Prisma ORM for storing logs and delivery history
* Docker Compose for quick deployment of the application along with Redis and PostgreSQL

As part of the task, I can implement:
* POST /webhooks/dispatch for queuing tasks;
* generating HMAC SHA-256 signature (`X-Signature`) for request authenticity verification;
* sending a webhook with a 5-second timeout and proper request cancellation;
* Retry Policy with Exponential Backoff (1, 5, 15, and 30 minutes);
* GET /webhooks/logs with filtering by status and recipient address;
* detailed logging of each delivery attempt, including HTTP response code, error text, execution time, and number of attempts;
* fully typed code without using `any`;
* ready Docker configuration for local launch and further deployment.

I will build the architecture in such a way that in the future, it will be possible to add DLQ (Dead Letter Queue), support for various retry strategies, rate limiting, monitoring, and handling multiple queues without significant changes.

I would be happy to discuss the project details and start development. Expand

Budget: 90 EUR Deadline: 1 day

Hello, Ivan! Again, a wonderful technical task with clear requirements. I am ready to implement this Webhook Delivery Engine on NestJS and TypeScript strictly according to your acceptance criteria. I propose the following implementation scheme: NestJS + BullMQ (Redis): reliable queue management with native support for Exponential Backoff policy for guaranteed message delivery. Crypto (SHA256 HMAC): secure formation of the X-Signature header based on the validated secretKey. Prisma ORM + PostgreSQL: clear structure for logging all delivery attempts with indexes by status and targetUrl for quick filtering at the endpoint GET /webhooks/logs. Docker Compose: complete project setup (App + Redis + PostgreSQL) to be launched with a single command. The code will have strict typing (no any), with proper handling of timeouts up to 5 seconds and network error handling. I am ready to discuss the details and start working.

Budget: 100 EUR Deadline: 1 day

Hello! I will complete your task quickly and efficiently.

My recent works
https://indexfast.pro - fast website indexing
https://mono-bank.pp.ua - everything about Monobank
https://mamamia.pp.ua - online store
https://programist.pp.ua/ua/portfolio/ - portfolio of works
https://monitortest.pp.ua - monitor testing
https://keytest.pp.ua - keyboard testing
https://pctest.pp.ua - computer testing
https://devroman.dev/portfolio/ - portfolio
https://vseetut.matviy.pp.ua - layout
https://indexfast.pp.ua - fast website indexing

My portfolio: https://freelancehunt.com/ua/freelancer/romas6ka.html#portfolio
Message me, I will start working today. I look forward to collaborating with you! Expand

Budget: 333 EUR Deadline: 10 days

Ivan, you need a reliable Delivery Engine that will not lose events during external server failures. I will set up BullMQ with a proper Exponential Backoff strategy so that the system correctly handles both timeouts and 5xx errors, while Prisma will provide a transparent log of all delivery attempts.

I will implement the process through background workers with a mandatory X-Signature for security. This will offload the main API and ensure data delivery to clients even in an unstable network.

Please let me know what volume of RPS is expected on input and if additional queue isolation is required for different clients.