Support Online
MirrorLooking Glass
GenixNodeGenixNode
Client Panel
Skip to main content

Node.js Asynchronous Task Management: Background Processes with BullMQ

What will you learn in this guide?​

In this guide, you will learn how to put long running processes in the background in Node.js applications.
You will speed up the request-response cycle by using BullMQ and Redis.
Finally, you will monitor the tasks on a panel.

🧠 Technical Summary​

The topic is asynchronous task management in Node.js.
The problem is that CPU-intensive operations increase response time.
The solution is to move tasks to the Redis queue with BullMQ.

Preliminary Preparations​

Before continuing, the following is required:

  • A system with Node.js installed
  • A service running Redis
  • Basic knowledge of Express.js
  • async/await and Promise logic

1. Why Use Asynchronous Task Queue?​

Some operations may take seconds or minutes.
Examples:

  • Visual processing
  • Report generation
  • Email sending

These operations lock the main flow.
The user waits, the experience decreases.

2. What is BullMQ?​

BullMQ is a Redis-based task queue.
Runs long processes in the background.
The main app is responsive.

Basic ingredients:

  • Queue
  • Worker
  • Job

3. Project Setup​

mkdir image-processor && cd image-processor
npm init -y
npm install express express-fileupload sharp ejs bullmq @bull-board/express
  • These commands set up the project structure and dependencies.

4. Understanding Synchronous (Blocking) Structure​

  1. Image processing is CPU intensive.
  2. Node.js becomes unresponsive during the process.
  • This causes performance problems.

Purpose:

  • Separating this process from the main flow.

5. Creating a Task Queue with BullMQ​


const { Queue } = require("bullmq");

const imageQueue = new Queue("imageQueue", {
  connection: { host: "localhost", port: 6379 }
});
  • This code creates a queue on Redis.

6. Add Task to Queue​


await imageQueue.add("processImage", {
  image: imageBuffer,
  name: imageName
});
  • This action sends the task to the background.

The user does not wait.

7. Worker Identification​


const { Worker } = require("bullmq");

new Worker("imageQueue", async job => {
  await processImage(job.data);
});
  • This code processes tasks sequentially. The process is independent of the main application.

8. Tracking Tasks with Bull Board​


app.use("/admin", serverAdapter.getRouter());
  • This structure opens a visual panel. Task statuses are monitored from the browser.

Access path:


http://localhost:3000/admin

❓ Frequently Asked Questions​

  1. What problems does BullMQ solve? It separates long-running processes from the main flow.

  2. Why is Redis needed? Task information is kept quickly in memory.

  3. What happens if the worker does not work? Tasks wait in the queue and are not lost.

  4. Should large files be added to Redis? No. The file path must be added.

  5. Is it suitable for production? Yes. Ideal in high traffic.

Result​

In this guide, you made Node.js application faster. With BullMQ, you moved long transactions to the background. You have established a scalable architecture with Redis and worker structure.

You can safely run your asynchronous task infrastructure on GenixNode servers.