Developing and Supporting a CRM System for a Medical Transportation Company
A medical transportation company had previously developed and maintained a customer relationship management (CRM) system with the help of an outsourcing team. When they required developers with deeper expertise, they contacted Apriorit.
Apriorit cybersecurity and cloud platform development teams improved the security of the company’s existing solution, perfected the user interface (UI), rewrote legacy code, and created new modules for the CRM.
Our client is a US-based medical transportation company that provides a complex solution to facilitate communication between people with special needs who require transportation to a hospital or other location and the drivers that provide this service.
The client’s internal CRM system was mostly used by customer service representatives (CSRs) working in call centers to communicate with and keep records of the company’s customers.
Before contacting Apriorit, our client already had an outsourcing development team building and maintaining their healthcare CRM software. But when they needed to expand this team, they started looking for developers with expertise in cybersecurity and cloud solutions, which is why they chose Apriorit.
The client challenged Apriorit specialists with the following tasks:
- Implement access controls to resolve security issues. The CRM system had to meet strict US healthcare compliance requirements such as those imposed by the Health Insurance Portability and Accountability Act (HIPAA).
- Redesign the UI to make it more comfortable for CSRs and improve their performance.
- Rewrite legacy code and optimize existing functionality to meet new business needs.
- Add new features to the system to improve its performance and implement new functionalities.
To resolve security issues and guarantee data protection, we offered to improve the CRM system’s existing custom authentication and authorization mechanisms.
To improve the UI of the CRM, our business analysts worked closely with designers on the client’s side to create mockups. Our developers also recommended integrating Metronic themes in the client’s web portal to improve the user experience (UX) and the general style of the application as well as to ensure a smooth transition to the new UI.
We also made the following improvements to the web portal:
- Implemented a new call handling system
- Created configurable tables in the database system for approving requests
- Set up a user notification system
- Built a cloud-based serverless solution for integrating the web portal with a third-party CRM
- Improved billing software modules
In addition, we refactored the code of the existing CRM system and implemented new features for mobile applications.
Thanks to improvements made by the Apriorit team, our client brought their CRM up to current cybersecurity standards and into compliance with US healthcare industry requirements. The solution became modern, adaptable, and comfortable for CSRs, allowing them to handle customer calls faster and improve the overall quality of their service.
Organizing the process
This project included several areas of development, a constantly changing scope, frequent and interim releases, and close cooperation with the client’s team. We started with a small team of a couple full-stack developers and one business analyst (BA), but over time the team grew significantly.
We introduced the Scrum framework to stay flexible, react to requests in a timely manner, control the project, and keep it transparent. While communicating with the client’s team, we paid special attention to three things:
- Eliciting and documenting client requirements. Our business analysts constantly communicated with stakeholders. Then they organized requirements into user stories in Gherkin syntax and groomed them with the Apriorit team.
- Discussing the development process with client-side experts. Apriorit developers were constantly validating technical solutions with architects on the client’s side.
- Cooperating with the client’s support team. Specially assigned developers and QAs helped the client’s support team solve end users’ requests, providing a third line of support.
Before starting any development activities, we outlined and analyzed the project’s key business requirements. Also, our team constantly demonstrated new features to gather feedback from the client.
How we did it
The project included five phases:
Phase 1. Fixing security issues and redesigning the UI
During this phase, we improved the security of the healthcare CRM and reworked its complicated and rigid interface. First, we created an access control system for managing a user’s access permissions. This measure improved data protection in correspondence with healthcare industry security standards.
Next, we started working on the UI. Initially, all pages of the CRM were custom made, so introducing changes was hard. Each fix required a lot of time, and the final system behavior was unpredictable.
We changed the architecture of the existing web portal and integrated Metronic — an adaptable design template — for the administrator panel. Metronic helped us improve the general appearance and UX of the existing interface and enhance the security of the web portal. As a result, web pages became easier to adapt; adding new controls or changing the layout no longer required rewriting the code.
At this stage of the project, the client wanted to split tasks between two outsourcing teams. As our team and the other outsourcing team had different development styles and approaches, we needed to put additional effort into organizing communication and delivery processes. During the next phases, the client delegated the largest part of work on the CRM to Apriorit developers and their own in-house experts.
Phase 2. Working on the call handling and notification systems
Our next task was to change the existing system for handling calls and introduce new features for approving requests and notifying users. This was designed to make the system more comfortable for CSRs, as they would spend less time on each call.
We started with our BAs discussing the prototypes of new features with designers on the client’s side and preparing user stories in order to better understand the product’s end users.
After we had documented the initial requirements, our team created a prototype to ensure a shared understanding of features to be implemented. We then presented the prototype to the client, collected feedback, and only afterwards started iterative development.
To adjust call handling, request approval, and user notification functionality to the client’s needs, we frequently released improved versions of the product and constantly communicated with the client’s team.
Phase 3. Refactoring legacy code
Our client decided to rework their legacy code because some of it no longer met business requirements. Parts of the code were hard to maintain and update, and even the slightest change caused multiple issues.
Our Apriorit team had to work with large amounts of legacy code written by our client’s other external team. This legacy code contained hard-coded data and code duplications, which made refactoring long and tricky.
To speed things up, we converted the existing reporting system into a webpage constructor configurable through a database. Making this conversion was easy, as the main parts of legacy pages had the same format, and we already had the core functionality of the reporting system. This new webpage constructor helped us move old web pages to a new system and simplify the addition and maintenance of report pages.
Phase 4. Migrating to a new version of the UI
To make it easier for CSRs to get acquainted with the new UI, we supported both the old and new versions of the UI for some time. All new features were implemented for both UIs.
At phase 4, the major part of the business finally migrated to the new UI. A gradual and careful migration allowed us to adapt the new interface to users’ needs, analyze changes, ensure a smooth transition, and preserve data from both UIs.
The more users switched to the new UI, the more adjustment requests we received. Our business analysts worked with the product owners to evaluate each request and determine whether it increased the value of the system or could be handled by additional user training.
Phase 5. Integrating the solution with a third-party CRM
Our client wanted to integrate their custom CRM system with a popular enterprise CRM solution. This integration would allow the client to handle customer interactions in a ready third-party system, eliminating the need for adding one more complex functionality to the client’s system.
We achieved this goal in several steps:
- Designed the architecture for synchronizing between the two CRMs and planned changes required to implement this design.
- Configured the environment using Amazon Web Services.
- Implemented core features of the integration, including data exchange and interactions between the CRMs.
- Released several iterations to improve our solution and make the integration frictionless.
Over the course of several years with Apriorit, our client has achieved great results:
- Moved their business platform from a desktop application to a web portal
- Improved data security and ensured compliance with industry requirements
- Reduced call handling times, allowing them to process customer requests faster
- Expanded their business to several new areas thanks to flexible and modern IT solutions
- Quickly adjusted their CRM to constantly changing needs
During this project, we greatly improved our client’s CRM system. Today, our client’s software is compliant, secure, adaptable, and integrated into their larger infrastructure.
If you’re working on a CRM, feel free to contact us and use our experience to take your project to another level!