Killing Tool Sprawl: How We Replaced 5 Fragmented Helpdesks With a Unified WebSockets Operations Hub

SaaS tool sprawl is a silent productivity tax on high-growth operations.

When SAS Customer Care approached Kumasoft, their 85 customer support agents were trapped in an operational nightmare. Handling a single customer inquiry required juggling five separate browser tabs:

1. An off-the-shelf ticketing tool (Zendesk)
2. A standalone live chat widget (Intercom)
3. An internal Postgres billing lookup database
4. A telephony CRM for call logs
5. Multiple shared Google Sheets tracking escalation queues

Because customer data was fragmented across five disconnected silos, support agents spent 4 minutes out of every 6-minute interaction just gathering context: searching email addresses, copy-pasting tracking IDs, and asking customers to repeat their problem. Average first-response time had climbed past 18 minutes, and agent attrition was nearing 35%.

Kumasoft engineered a custom, unified Single-Pane Operations Hub built on Next.js, Node.js, WebSockets, and Elasticsearch that collapsed all five tools into a cohesive, real-time command center.

Here is the system architecture, message routing mechanics, and operational playbook.

The Cost of the “SaaS Frankenstein”

Buying off-the-shelf SaaS tools is easy on day one; by year three, it becomes an unmaintainable Frankenstein:

• Per-Seat Licensing Tax: Paying $150/agent/month across five different tools cost SAS over $60,000 every single month in pure software licensing.
• Context Switching Overhead: Cognitive science shows context switching degrades worker throughput by up to 40%. Agents were making manual data entry errors between tabs.
• Lack of Unified State: If a customer initiated a live chat while having an unresolved billing ticket open, the chat agent had zero awareness of the pending dispute.

Unified Hub Architecture

[ Inbound Customer Channels: Chat / Email / WhatsApp / Voice ]
                            │
                            ▼
               [ Cloud Ingestion Gateway ]
                            │
                            ▼
            [ BullMQ Distributed Job Queue ]
                            │
             (Intelligent Priority Routing)
                            │
                            ▼
         [ State Machine & Dispatch Coordinator ]
             ├── PostgreSQL 16 (Durable Timeline)
             ├── Elasticsearch 8 (Sub-5ms Full-Text Search)
             └── WebSockets Broker (Redis Pub/Sub)
                            │
                            ▼
    [ Single-Pane React Operator Desktop Terminal ]

1. The Unified Customer Timeline Schema

The core of the platform is a unified timeline data model. Regardless of whether an event is a phone recording, live chat transcript, Stripe refund, or email thread, it is stored as an immutable timeline node:

// Unified Timeline Event Interface
export type TimelineEventType = 
  | "chat_message" 
  | "phone_call" 
  | "email" 
  | "billing_charge" 
  | "refund_issued" 
  | "system_note";

export interface UnifiedCustomerEvent {
  id: string;
  customerId: string;
  agentId?: string;
  eventType: TimelineEventType;
  channel: "web" | "ios" | "android" | "telephony";
  payload: {
    title: string;
    summary: string;
    body?: string;
    metadata?: Record<string, unknown>;
  };
  sentimentScore?: number; // Real-time NLP sentiment analysis
  createdAt: string;
}

2. Intelligent Real-Time Dispatch via Redis Pub/Sub

Rather than forcing agents to manually cherry-pick tickets from an unorganized queue, the dispatch engine calculates agent load in real time and routes inquiries automatically:

// Dispatch Routing Worker with WebSockets Push
import { redisClient } from "@/lib/redis";
import { ioServer } from "@/lib/socket";

interface IncomingTicket {
  ticketId: string;
  customerId: string;
  priority: "low" | "medium" | "urgent";
  tierRequired: number;
}

export async function dispatchToOptimalAgent(ticket: IncomingTicket) {
  // Find online agents with lowest active chat count matching skill tier
  const candidates = await redisClient.zrangebyscore(
    `agents:available:tier:${ticket.tierRequired}`,
    0, // minimum active chats
    3  // maximum concurrent chat cap
  );

  if (candidates.length === 0) {
    // Enqueue to overflow pool
    await redisClient.lpush("queue:unassigned_overflow", JSON.stringify(ticket));
    return;
  }

  const assignedAgentId = candidates[0];

  // Increment agent's active load
  await redisClient.zincrby(`agents:available:tier:${ticket.tierRequired}`, 1, assignedAgentId);

  // Push instant desktop alert via WebSocket directly to selected agent's browser
  ioServer.to(`agent:${assignedAgentId}`).emit("ticket:assigned", {
    ticketId: ticket.ticketId,
    customerId: ticket.customerId,
    priority: ticket.priority,
    assignedAt: Date.now(),
  });
}

The Sub-5 Millisecond Customer Search

Support agents often need to locate a customer record from a partial phone number, an old order ID, or a delivery address snippet. Relational SQL queries with multiple ILIKE '%...%' filters took over 4 seconds on tables with 3 million rows.

We configured an Elasticsearch cluster synchronized via Postgres CDC:

• Typed input updates customer profiles in real time with autocomplete in under 5 milliseconds.
• Agents view the customer’s full 3-year history, lifetime purchase value, and open disputes the instant they click the notification.

The Onboarding Breakthrough: From 2 Weeks to 3 Days

With the previous five-tool setup, training a newly hired customer care representative took two full weeks of shadowing and complex software manual navigation.

With the unified Kumasoft command center, new agents mastered the entire workflow in three days. All tools, shortcut keys (Ctrl+K command palette), and internal knowledge base articles were integrated directly into the workspace.

Measured Operational Results

• 60% Reduction in Average Response Time: First-response times dropped from 18.4 minutes to under 7.2 minutes across all incoming tiers.
• +45% Agent Productivity Lift: Agents resolved an average of 42 cases per 8-hour shift, up from 29 cases previously.
• $48,000/Month in SaaS Licensing Saved: SAS eliminated four separate commercial subscription plans, paying for the custom platform build within six months.
• 4.7 / 5.0 CSAT Score: Customer satisfaction rose from 3.6/5.0 to 4.7/5.0 within 90 days of rollout.