Automatic Call Management System Prototype -- 2

Project: Functional Prototype of an Automatic Call Management System with IVR

Project Objective:

The goal is to develop a functional prototype of an automated call management system using Twilio. This prototype will allow for the reception and queuing of incoming calls, agent assignment with call recording, and real-time supervision. The system will manage both incoming and outgoing calls, ensuring a smooth customer experience and optimizing the call center workload.

It is important to note that this is a functional prototype that will not have access to a database, nor will it be integrated with other systems. However, it must rely on Twilio TaskRouter for its functionality, particularly for managing call distribution and routing.

IVR Call Flow with Twilio (Prototype)

Customer: Calls the call center number.

System: Automatically responds with a welcome message (e.g., "Welcome to [company name]'s customer service center").

System: Requests the customer's ID number (NDI).

Example: "Please enter your identification number using the phone keypad."

System: Validates the ID number:

If correct: A personalized welcome is given with the customer’s name ("Welcome, [customer name]").

If incorrect: Requests the customer to re-enter the number or transfers them to an agent for assistance.

System: Queues the call based on the customer's priority level.

High-priority customers are placed at the front of the queue.

System: While the customer is in the queue:

Informs them of their place in the queue (e.g., "You are number [X] in line").

Provides an estimated wait time (e.g., "Your estimated wait time is [X] minutes").

Plays a set of audios while the customer waits (music, company messages, etc.).

System: Assigns the call to an available agent using round robin.

Agent: Takes the call. The system automatically starts recording the call.

Supervisor: Has the ability to listen to the call in real-time and can intervene if necessary.

System: If no agents are available and the wait time exceeds 5 minutes:

If the customer’s phone number is registered:

The system ends the call and informs the customer they will be called back within an hour.

If the number is anonymous:

The system ends the call after informing the customer to try again later.

Project Components (Functional Prototype):

IVR Management API:

Description: Programmed using a state machine to control the flow of incoming calls. The API will handle customer interaction, including ID validation, priority-based queuing, agent call assignment, call recording, and callback functionality when no agents are available.

Key Features of the Prototype:

Call queuing with priority.

Call assignment to agents using round robin with Twilio TaskRouter.

Real-time call supervision.

Automatic call recording.

Blazor WebAssembly FrontEnd:

Incoming Calls: Interface to view and manage real-time calls, allowing agents to accept and manage incoming calls.

Outgoing Calls: Interface that allows agents to make follow-up or callback calls when calls could not be answered in time.

General Agent Actions:

Answer a call.

Transfer a call to another agent.

Pull a call from another agent.

Place a call on hold.

Mute a call.

Supervisor Actions:

Listen to a call in real-time.

Join the conversation if necessary.

Technologies to Use (Functional Prototype):

Backend:

Platform: .NET Core 8.

Language: C#.

Architecture: Microservices with Minimal API.

State Machine: To control the call flow in the IVR.

Twilio: Manages incoming calls, queuing, and call distribution.

Twilio TaskRouter: To manage call routing to agents.

Frontend:

Framework: Blazor WebAssembly.

Development Environment: Visual Studio.

Required Freelancer Skills:

Languages and Frameworks:

Advanced proficiency in .NET Core 8 and C#.

Experience with Blazor WebAssembly for frontend development.

Experience in designing and implementing microservices using Minimal API.

Integrations:

Extensive experience integrating with Twilio for call management.

Knowledge of Twilio TaskRouter for call routing and distribution to agents.

Experience with call recording and real-time supervision tools.

IVR Development:

Knowledge of state machines to manage call flow within the IVR.

Tools:

Proficiency in Visual Studio as the main development environment.

Project Deliverables:

Deliverable 1: IVR Management API with Twilio Integration

Objective: Develop the core functionality for managing incoming calls using Twilio, including queuing, prioritization, and call routing via Twilio TaskRouter.

Key Features:

Create an API using .NET Core 8 and C# to handle the IVR system's logic.

Implement state machine logic for call flow control.

Integrate Twilio TaskRouter to manage call routing and distribution among agents.

Basic functionality for assigning agents based on a round robin algorithm.

Handle incoming calls, validate customer ID, and queue calls based on priority.

Completion Criteria:

The API should respond to incoming calls, handle queuing, and assign calls to agents using Twilio.

Integration with Twilio TaskRouter must be functional.

Documentation for the API endpoints.

Deliverable 2: Agent and Supervisor FrontEnd in Blazor WebAssembly

Objective: Develop the Blazor WebAssembly frontend for agents and supervisors to interact with the IVR system and manage calls.

Key Features:

Implement the interface for agents to:

Answer incoming calls.

Transfer calls to another agent.

Pull a call from another agent.

Put calls on hold and mute.

Supervisor interface to:

Listen to real-time calls.

Join calls if necessary.

Interface for agents to view calls in the queue and accept them.

Completion Criteria:

A fully functional frontend interface that connects with the API and supports the specified agent and supervisor actions.

Responsive and tested for basic interaction flows.

Deployment instructions and frontend documentation.

Deliverable 3: Call Recording and Error Handling with Twilio

Objective: Implement advanced functionality for call recording, error handling, and call monitoring.

Key Features:

Enable automatic call recording once an agent accepts a call.

Implement the supervisor’s ability to monitor calls in real-time and join them when necessary.

Develop error handling mechanisms for missed calls, call transfer failures, and system timeouts.

If a call is in the queue for over 5 minutes, implement logic to end the call and either schedule a callback or inform the customer to try again later.

Completion Criteria:

Full call recording functionality for incoming and outgoing calls.

Error handling for call queueing, transfers, and timeouts.

Callback scheduling mechanism in cases of long wait times.

Final testing and documentation.

Working Methodology and Timeline

Daily Meetings: We will hold daily meetings to review progress and clarify the scope as needed. These meetings will be short (15-30 minutes) and aimed at ensuring the project remains on track.

Review Meeting: At the end of each deliverable, we will have a review meeting to discuss feedback and ensure the quality of work.

Git Repository: All work must be stored in a Git repository that will be updated at least twice a day to ensure transparency and continuous monitoring of progress.

Code Reviews: Regular code reviews will be conducted to maintain the quality of the code and ensure alignment with project goals.

Communication: Open communication through Slack or a similar tool will be required to handle any blockers or issues that arise quickly.

Timeline: The total project duration is estimated to be around 10 days. Each deliverable should have clear timelines, allowing enough time for testing and feedback.

Final Delivery: Ensure that all documentation, including API endpoints, system design, and usage instructions, is completed by the final delivery date.

.NET Programação C# Twilio Blazor Microservices

ID do Projeto: #38726199

Sobre o projeto