Contact Center Thick Client Framework With Common Queuing
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional contact centers face inefficiencies due to the need for significant and costly software changes when integrating external communication services and tools, with thin client applications having limited functionality and thick client applications requiring uncoordinated software updates.
Innovation Solution
A thick client framework with a distributed computing infrastructure, utilizing a container application image and queuing and communication services on client devices, interfaces with internal and external service providers to support a common queuing framework across the contact center.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of manufacture
If thin client applications are used, then ease of deployment and maintenance is improved, but functionality and ability to interact with native operating system features is limited
Solution Approach 1:
The contact center application is divided into two segments: a thin client application that handles deployment and maintenance ease, and a containerized application image that provides full functionality. The thin client launches the container image, which contains the complete application environment with access to native operating system features, thereby resolving the contradiction between ease of deployment and functionality.
Solution Approach 2:
The containerized application image is nested within the thin client application environment. The thin client acts as the outer layer that provides ease of deployment, while the container image is nested inside it, providing access to full functionality and native operating system features without requiring the thin client itself to be complex.
2Adaptability or versatility
If thick client applications are used, then functionality and access to native operating system features is improved, but software updates require uncoordinated decentralized updates
Solution Approach 1:
The application code and dependencies are extracted from the traditional thick client model and placed into a containerized application image. This extracted container image can be centrally managed and distributed, allowing coordinated updates without requiring decentralized changes to individual thick client installations, thus maintaining functionality while improving update coordination.
Solution Approach 2:
Instead of updating each thick client installation individually, a standardized containerized application image is created that can be copied and distributed to all clients. This ensures consistent functionality across all deployments and allows centralized update management by simply replacing the container image, eliminating the need for uncoordinated decentralized updates.
3Adaptability or versatility
If external communication services are integrated, then service functionality is improved, but software changes in internal servers and client devices are required
Solution Approach 1:
The containerized application image is designed with universal interfaces that can interact with multiple different external communication services through standardized APIs. This multi-functionality allows the same container image to work with various external services without requiring specific software changes in internal servers or client devices, thereby improving service functionality while minimizing device complexity.
Solution Approach 2:
The containerized application image acts as an intermediary layer between the thin client and external communication services. It provides standardized interfaces and adapters that enable integration with various external services without requiring changes to the underlying client device or server software, thus improving service functionality while avoiding software changes.
4Ease of operation
If decentralized software updates are performed, then independence of client devices is maintained, but update efficiency and coordination deteriorate
Solution Approach 1:
The application update mechanism is extracted from the traditional decentralized model. Instead of requiring independent updates on each client device, the update process is taken out and centralized in the container image management system. The thin client maintains its independence by simply launching the container image, while the actual update coordination happens centrally through the container image distribution mechanism, improving update efficiency without sacrificing client independence.
Data Source
AI summary
Various techniques described herein relate to a client application framework for a contact center environment. A role-specific thick client framework may include a web browser-based application having multiple processes that can be distributed across the computing infrastructure of the client device. A portion of the framework may include a container application image received from an internal server of the contact center and launched by the client device. The framework also may include queuing and communication services executing on the client device, which interface with the internal client application and external service providers to support a common queuing framework and an integrated model implementation across the contact center environment.