Customer support at scale is a systems problem.
It looks like a people problem — hire more agents, train them better, monitor their calls. But the root cause is almost always structural: the wrong tools, no process enforcement, no visibility into what's working.
At eZhire, our support organization was handling thousands of tickets a month across WhatsApp, phone, email, and in-app chat. Every channel had its own tool. There was no single view of a customer's history. SLAs existed in a document; nobody tracked whether they were being met. QA evaluation meant a supervisor occasionally listening to a call.
This is what we built to fix that.
The Problem We Were Solving
Before the platform, a customer support interaction at eZhire looked like this:
- Customer reaches out on WhatsApp → handled in BotSpace, no record in the support system
- Customer calls → handled in Ziwo, call recording stored in Ziwo, not linked to the customer record
- Customer raises a complaint via email → tracked in a shared inbox, no ticket number, no SLA
- Supervisor wants to review an agent's performance → listens to random calls manually, no scoring rubric
The result: customers who contacted us multiple times had to repeat their story every time. Agents had no context. Supervisors had no data. Leadership had no visibility.
The Platform Architecture
We built the Customer Support Platform as a module within the eZhire ERP, integrating with our existing communication tools rather than replacing them.
Ticketing System
Every support interaction — regardless of channel — creates or updates a ticket. A ticket has:
- A customer record linked to their rental history, payment status, and previous interactions
- A channel tag (WhatsApp, phone, email, in-app, walk-in)
- A category (billing, vehicle issue, complaint, inquiry, extension request)
- An SLA clock that starts from ticket creation
- An assignee (individual agent or team queue)
- A full audit trail of every action and status change
This means when a customer calls for the third time about the same issue, the agent sees the full history before picking up the phone.
SLA Management
We defined SLAs by ticket category and priority:
- P1 (vehicle stranded, safety issue): 30-minute first response, 4-hour resolution
- P2 (active rental issue): 2-hour first response, same-day resolution
- P3 (billing, inquiry): 4-hour first response, 48-hour resolution
The platform enforces these automatically:
- Tickets approaching SLA breach turn amber in the agent view
- Breached tickets escalate automatically to the team lead
- SLA compliance is tracked and reported daily
Before the platform, SLA compliance was unmeasured. After, it's tracked to the minute.
Escalation Management
We built a configurable escalation chain:
- Unresolved after SLA → assigned to senior agent
- Still unresolved + customer escalation flag → assigned to team lead
- Legal/financial dispute → assigned to FinOps or management
Each escalation level has its own SLA clock and resolution criteria.
QA Evaluation System
This was the most technically interesting part of the platform.
We integrated with Ziwo (our call center platform) and Aswat (voice analytics) to build a QA evaluation system:
- Call recording — every call is recorded and stored with metadata (agent, customer, duration, timestamp)
- Transcription — Aswat transcribes calls automatically within minutes of completion
- QA scorecard — supervisors evaluate calls against a standardized rubric (greeting, problem identification, solution offered, tone, compliance)
- Agent scoring — scores aggregate into weekly and monthly agent performance reports
- Keyword monitoring — flagged keywords (complaints, competitor mentions, policy violations) trigger automatic review queues
Before the QA system, evaluation was subjective and inconsistent. After, every agent is evaluated on the same rubric, and managers have data to support coaching conversations.
Mobile App Integration
Our support agents in the field use a mobile app. We built a Firebase-based notification system that pushes ticket updates, escalations, and customer alerts to field agents in real-time. A field agent can update a ticket status from their phone, eliminating the need to call back to the office.
The Integration Layer
The platform integrates with:
- Ziwo — call records, recordings, agent availability
- Aswat — call transcription, keyword detection
- Crisp — website and in-app chat conversations sync as tickets
- BotSpace — WhatsApp conversations sync as tickets
- Firebase — mobile push notifications
- eZhire ERP — customer data, rental history, payment status
Every integration is asynchronous. A new Crisp conversation triggers a webhook that creates a ticket in our system. A completed Ziwo call triggers a webhook that links the recording to the customer record and starts the transcription job. Nothing requires manual intervention.
What Changed
After launch:
- First-response time dropped across all channels as agents had full context before responding
- SLA compliance became measurable — and then improvable
- QA consistency improved because evaluation was standardized, not subjective
- Customer repeat contacts reduced as issues were resolved completely the first time
- Management confidence increased because the data existed to manage performance
The support team didn't change. The tools changed. And the tools made the team measurably better.
Lessons Learned
Customer data model first. We spent two weeks refactoring because we hadn't thought carefully enough about how a "customer" relates to a "contact" relates to a "rental." Get this right before building anything else.
Don't build a ticketing system from scratch if you can integrate. We built a custom ticketing system because our business logic was too specific for off-the-shelf tools. If your business logic is standard, integrate — don't build.
QA adoption requires change management, not just software. The QA system was technically ready in week 4. Full adoption by the team took 3 months because supervisors needed coaching on how to use data in performance conversations.
A support platform is only as good as the process it enforces. The software is the easy part. Getting the team to trust and use it consistently is where the real work happens.