QueueFlow

Raam Bhandarkar — Sun, 04 Oct 2026 13:23:07 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

I built an IoT-enabled Smart Queue Management System for my friend Shiva, who often has to deal with long and unpredictable queues at service centers.

The system connects a physical IoT setup with a digital queue platform. When a person is detected by an IR sensor, the ESP32 communicates with the user application and the phone announces:

“Please press the button for token.”

When the physical button is pressed, a digital token is generated instantly. The user receives a virtual ticket showing their token number, current serving number, people ahead, and estimated waiting time.

The system also provides an admin dashboard for monitoring queue length, footfall, service counters, waiting times, and resource utilization in real time.

The core flow

Person Detected → IR Sensor → ESP32 → Voice Prompt → Physical Button → Digital Token → Virtual Queue → Live ETA → Notification

The goal is simple: reduce unnecessary physical waiting and make queues predictable.

Demo

The demo showcases a small-scale working service-center model with:

ESP32
IR sensor for visitor detection
Physical push button for token generation
Phone-based user interface
Virtual digital ticket
Real-time queue position
Estimated waiting time
Admin dashboard

Demo Video:

Live Demo:
[live.shivasoni.me](url)

Code

The project is built as a connected IoT + web application.

GitHub Repository:

RA4m15 / Queue-Flow

queue flow is the solution for crowd management using both the software and hardware

QueueFlow — Real-Time Smart Queue Management System

QueueFlow is an enterprise-grade, real-time Smart Queue Management System designed to eliminate physical waiting lines, balance service counter workloads, track physical footfall via IoT sensors, and provide live operational analytics.

Architecture Overview

QueueFlow is built as a unified distributed system sharing one central backend and database:

                  ┌─────────────────────────────────────┐
                  │    Flutter Customer Mobile App      │
                  │   (Token Booking, Status, Alerts)   │
                  └──────────────────┬──────────────────┘
                                     │ REST / WebSocket
┌──────────────────────────────┐     │     ┌──────────────────────────────┐
│       React Admin Panel      │◄────┼────►│   ESP32 / RFID / IoT Sensors  │
│   (Dashboard, Counters,      │     │     │   (Footfall Entry/Exit Count)│
│    Display Board, Analytics) │     │     └──────────────┬───────────────┘
└──────────────┬───────────────┘     │                    │ IoT Events
               │ REST / WebSocket    │                    │ (x-iot-secret)
               ▼                     ▼                    ▼
     ┌──────────────────────────────────────────────────────────┐
     │       Node.js + Express + Socket.IO Unified Backend       │
     │      (Authentication, Queue Engine, Event Broker)        │
     └────────────────────────────┬─────────────────────────────┘
                                  │
                                  ▼
                     ┌─────────────────────────┐
                     │   MongoDB Atlas Cloud   │
                     │  (Multi-Tenant Data)    │
                     └─────────────────────────┘

Backend Engine…

View on GitHub

The repository contains the ESP32 firmware, queue-management backend, user interface, admin dashboard, and simulation/demo components.

How I Built It

The system combines IoT hardware, a real-time queue engine, and a web/mobile interface.

Hardware

ESP32 as the main IoT controller
IR sensor for detecting arriving visitors
Physical push button for token requests
Wi-Fi communication between the ESP32 and application

Software

React.js / Next.js for the user and admin interfaces
Backend API for queue and token management
Real-time communication for live queue updates
Text-to-speech for the voice instruction
PostgreSQL for queue and service data
REST/WebSocket-based communication between system components

The MVP uses an explainable queue-estimation approach based on people ahead, average service time, and active counters.

The architecture is designed so that historical queue data can later be used for machine-learning-based waiting-time prediction and resource optimization.

Open-source AI

For the intelligent part of the system, the architecture is designed around open-source AI/ML components rather than depending on a proprietary AI API. The prediction and recommendation layer can be extended with open-weight models and local inference while keeping the core queue system lightweight and explainable.

Why Does Open Innovation Matter?

Open innovation makes it possible to build this project as a low-cost, adaptable system rather than depending on expensive proprietary infrastructure.

The ESP32, open-source software libraries, open communication protocols, and community-built tools allow the system to be modified for different environments such as:

Hospitals
Banks
Government offices
Railway counters
Universities
Customer service centers

More importantly, the system can be deployed locally and customized according to the requirements of each service center.

A queue-management system should not be locked into one vendor or one ecosystem. Open innovation makes the solution easier to experiment with, extend, and adapt to real-world public-service environments.

Prize Categories

Hacktoberfest Weekend Challenge: Build for a Friend
IoT / Hardware
Open Source
AI / Intelligent Systems
Smart City / Civic Technology

Team

Team SHARPRAD-X

Devraja
Shiva
Arpana
Raam

This project was built as a practical experiment in connecting physical IoT interactions with a real-time digital service experience.

Instead of making people wait in a queue and repeatedly check their position, we wanted to answer a simple question:

What if the queue could come to you instead of you waiting in the queue?

DEV Community: Raam Bhandarkar