I built a production-grade automation web application that lets teams run opt-in WhatsApp campaigns at scale. The platform supports multiple WhatsApp accounts, role-based admin, message templates & media, bulk sending with scheduling, and real-time queue tracking. The system is written end-to-end in TypeScript (Node.js + React) with MongoDB for persistence and a worker/queue layer for high-volume delivery (tested up to ~8,000 recipients per campaign). The design focuses on reliability (idempotency, retries, dead-letter), observability, and policy-compliant usage.

Bulk messaging & scheduling: create campaigns, choose segments, set send windows, throttle & pause/resume.

Multi-account with admin controls: add multiple WhatsApp Business accounts; round-robin or rules-based distribution; per-account quotas.

Templates & media: reusable text variables, attachments (docs, images, video), preview before send.

Queue & concurrency: worker pool handles high volume with backpressure, retries, and DLQ.

Real-time progress: live status (queued/sent/failed/delivered) via WebSocket + Redis pub/sub; detailed history.

Lists & hygiene: contact lists, import/export, blacklists and opt-out handling.

Type-safe codebase: shared TypeScript types across API/UI for maintainability.

Front end (React + TypeScript): admin console for campaigns, templates, accounts, and live dashboards.

API (Node.js, Express/Fastify + TypeScript): REST endpoints, schema-validated payloads (Zod/JOI), OpenAPI spec.

Queue/Workers: Redis/BullMQ (or RabbitMQ) workers for message scheduling and dispatch; worker threads / process cluster for parallelism.

Messaging service: per-account adapters (e.g., WhatsApp Business Cloud API); rate limiting + idempotency keys to prevent duplicates.

Persistence (MongoDB): collections for accounts, sessions, templates, campaigns, messages, queues, contacts, blacklists, audits.

Observability: structured logs (JSON), metrics (sent/sec, error rate, queue depth), traces/correlation IDs; dashboards + alerts.

Message flow (simplified): UI → create campaign → API validates & writes jobs → queue schedules batches → workers dispatch via account adapters (respecting limits) → statuses stream back to UI via WebSocket → history stored with searchable audit trail.

Throughput: batch scheduling + concurrency controls allow large sends (tested to ~8k recipients).

Backpressure & retries: exponential backoff, jitter, and dead-letter queues for persistent failures.

Idempotency: campaign/message IDs ensure at-least-once processing without duplicates.

Account rotation: round-robin or priority routing to avoid hitting account limits; automatic failover on provider errors.

Account secrets: encrypted at rest (KMS/Keytar/Vault) and masked in logs; scoped RBAC for admin/ops.

Policy alignment: built for WhatsApp Business (Cloud API) and opt-in messaging only; honors user opt-out/blacklist, rate limits, and regional privacy rules (data retention controls).

Data protection: input validation, request signing where applicable, HTTPS everywhere, audit logs.

Note: The platform does not simulate clients or bypass provider policies; it’s designed for compliant, permission-based messaging.

Campaign builder (templates, variables, audience, schedule).

Live queue dashboard (progress, ETA, pause/resume/cancel).

Accounts page (tokens, quotas, routing rules).

Libraries for templates, media, contacts; blacklist management.

History & reporting (per campaign/account, exportable).

TypeScript monorepo with shared types for API/UI.

Worker Threads / Cluster for parallel I/O; graceful shutdown hooks.

Schema-first API (OpenAPI), client SDK generation, Postman collection.

File handling with content-type validation and size limits; resumable uploads for media.

Testing: unit + integration (mock transport), end-to-end for critical flows.

Enabled scheduled campaigns to thousands of recipients with real-time visibility and safe throttling.

Reduced operational errors via idempotency, retries, and clear error taxonomy.

Cut engineering handoffs with a single admin UI and shared type-safe contracts.

Front end: React + TypeScript • Back end: Node.js (Express/Fastify) + TypeScript • Data: MongoDB (+ Redis) • Workers/Queue: BullMQ/RabbitMQ • Realtime: WebSocket/Socket.IO • Infra: Docker • Docs: OpenAPI, Postman

Smart segmentation & A/B testing for templates/scheduling.

Adaptive rate control per account/carrier.

Webhooks for external CRMs and analytics.

Fine-grained roles & audit exports for compliance teams.

Node.js + React WhatsApp Automation: multi-account, scheduled bulk messaging with templates, media, real-time queue tracking, and policy-compliant delivery.

If you want, I can turn this into a two-page PDF case study (with a simple system diagram) or trim it for a Contra project character limit.