This client’s new R&D manager promised to increase speed and efficiency. Here’s how he delivered.
This medical device manufacturer needed to rebuild a legacy desktop app. The app was the control center for service and maintenance of the software driving its life saving infusion pumps. A new R&D manager got the job done by extending his internal team through outsourcing in an agile environment. The result: a better, 10x faster app.
Legacy means a time-consuming and imprecise result
This client makes FDA-regulated pumps that deliver life-saving liquids to patients in hospitals and other clinical settings. A critical part of pump functionality is service and maintenance, including updating software and firmware, and downloading and reporting on use data. At the time of this project, performing these service and maintenance functions required using a different tool for each function on each pump version. This meant a lot of time and room for error.
The client was using multiple legacy apps and tools to manage their medical equipment and devices. Some tools would read logs and transfer instructions, called data sets. Data sets included concentration and amount of a drug/liquid to be infused, start time, stop time, duration, etc. The tools would tell the pumps what to do and track what was done. There was another set of tools that was used to update the firmware/OS of the pump itself.
All tools tended to be pump- and version-specific and could only accommodate one update of one pump’s firmware at a time. This meant that each pump required 2-3 tools to manage all necessary functions. Add to this the fact that different pump versions required different tools, and the total number of required tools to maintain the pump inventory had become hugely inefficient.
This legacy system was slow, imprecise, and not scalable. These disadvantages would only be exacerbated as new pumps were introduced.
It’s go time
When a new R&D department manager came on board he wanted to hit the ground running with this long-overdue project. He had something to prove to his stakeholders, and we had something to prove to him. We were eager to prove ourselves partnership-worthy to this results-driven “new kid on the block.“
Extending the client’s team in an agile environment
The client worked within an agile environment and this lent itself well to an integrated, one-team approach to the project. Together we defined the ideal team to allow for iterative collaboration:
- The client contributed a marketing manager; a UX engineer responsible for usability, colors, and developing wireframe and prototypes; a systems engineer; a software development lead; a software quality engineer to perform V&V; plus a few people from the field representing the end users.
- Integrant extended the team with a technical account manager to secure schedule and resources, a technical project lead, developers, and software quality engineers.
- Our two teams would work side by side from the start on brainstorming, spec writing, prototyping and wireframing, demonstrating, soliciting feedback, and adjusting.
Although the client knew they wanted to increase speed and efficiency, they had not yet defined requirements for the control center’s features and functionality. Once we started the initial stages of the project the client recognized some functionality they wanted beyond the basics:
- The app needed to support multiple pumps at once and to cycle in new tasks automatically, in real-time.
- The app needed to work in 22 different languages. We would create a list with all UI strings, and a subcontractor engaged by the client would translated the UI strings into 22 languages. In this way the user could choose their preferred language at or immediately following log-in.
- The app needed a feature where simply plugging a particular pump into the utility would result in the pump specs displaying on the utility screen including pump name, specs, serial number, and other info. The firmware upgrade options and data set download options displayed would be specific to that particular model. In this way the user could more rapidly interface with the utility and would avoid mistakes associated with attempts to download or upload incompatible or outdated components.
The final result would be a control center with legs:
- Any pump model could be managed using the same desktop app
- Multiple pumps could receive new firmware uploads, event log downloads, and activity reporting concurrently
- If a new pump type/style were added to the company’s inventory, the software could scale to accommodate it
- Functionality would include:
- Firmware upgrades
- Event log downloads
- Pump logs reporting including:
- Drugs, doses, and concentrations
- Data on what keys were pressed, in what order, and over what period of time
- Activity reporting including:
- Actions taken between control center and pump such as uploading firmware, downloading logs and uploading datasets, storing information about the affected pump like serial number, pump model, and action date, username who ran the action
- Actions taken by the defined users on control center
- Actions taken on the control center’s stored libraries and documentations
The changes and new features, modifications, and refactoring would extend the project timeline, but a shared and agile culture allowed for the client stakeholders to buy in or modify at each step along the way. As a result, non-critical functionalities were prioritized and completed within one month of the balance of the project.
- Sprint every 2-4 weeks including code review, new features, fixing issues, fixing review comments
- Weekly core team meeting including all stakeholders
- Brainstorm meetings regarding functionality, features, etc., as needed
- Daily interaction/conversations with client SW dev lead
- When Integrant team members were on-site with the client, we conducted 2-3 meetings per day to maximize efficiency of communication and productivity
Our technology stack was focused on Microsoft and included:
- SQL server
- Open XML for Excel exporting
- Active Reports for exporting PDFs
- C# (language)
- Design patterns
- Dependency injection (DI), Inversion of Control (IoC) container
ROI in a competitive and cautious industry
Software in the world of FDA-regulated devices brings its own challenges. The competitive edge that innovative software brings to the game must be balanced with accuracy, tracking, and auditing. This means software development teams must be innovative while at the same time dedicated to domain knowledge and strict adherence to protocol.
For some manufacturers, this means handling software in-house. For others, it means outsourcing only repetitive, easily validated tasks that are not mission critical. But our client needed to outsource for speed without compromising on quality. He required:
- A strong team to extend his own team
- A commitment to innovation
- A meticulous adherence to protocol
Together as one agile team we went from inefficient legacy tools to a single control center for all pumps and functions. The resulting “all in one” desktop app allowed a 10-fold time savings plus improved accuracy of tracking and reporting. This accuracy was due in part to a more unified platform, and in part to the discovery of reporting bugs in the legacy tools which were corrected in the new app.
The R&D department manager wanted to hit the ground running with this project, and he did. He now uses us as a tool to achieve innovation he seeks in other areas. We are discussing several new projects–one related to the control center, and two related to other apps.