It can be devastating when families learn that their loved ones may have been victims of medical errors. Yet, it happens all too often.

Therac-25 has become one of the most well-known cases in history, given that its software contained bugs which proved to be fatal for 6 patients.

But while its software was the linchpin, it wasn’t the root cause. The entire system design was problematic: fault trees for both hardware and software were not created, timing analysis wasn’t implemented, and unit testing never happened.

The Therac-25 case is proof of how much damage medical software can cause when it’s poorly designed and inadequately tested.

It’s tough to grasp that software errors cost the U.S economy $59.5 Billion every year. Just imagine how many unpleasant situations could be avoided not necessarily by building new software, but simply by improved testing.

To ensure your medical devices are safe and effective for users, let’s look at 4 software testing steps every engineer should perform.

Validation – More than just testing

Proper software validation techniques should be a key component of any medical device development QA strategy.

The FDA considers software validation to be the “confirmation by examination and provision of objective evidence that software specifications conform to user needs and intended uses, and that the particular requirements implemented through software can be consistently fulfilled.”

A crucial factor in successful validation lies in accurately and completely documenting software requirements.

Tests are often written without detailed requirements, which constrains test developers to refer to the software itself for details regarding its functionality.

The end result? If requirements are unclear, they may be misinterpreted. If particular details are missing, it may result in a buggy design. If it lacks specificity, it’ll result in something being built that is different from what was intended.

Thus, tests may end up documenting the way software works, rather than resembling the original scope and specs. Inadequate requirements will eventually lead to ineffective software testing.

Software validation activities should take place at every stage of the software development cycle, and validate that all requirements have been implemented correctly and are traceable to system requirements.

Given that requirements usually get defined, refined, added to, and deleted throughout the course of your project, consider the following practices for creating top-notch software requirements:

• Write user stories, which will help team members plan, estimate and understand the project at its basic level;

• Define conditions of satisfaction: the criteria that must pass for the user story to be “user accepted” (for example, validation error messages that should appear if a field entry is missing or invalid);

• Create workflow diagrams;

• Use wireframes and visual designs, which include: the layout and design of the page and form fields, the style and placement of errors and notifications, as well as annotations of conditional or dynamic elements of the UI;

• Define non functional requirements, such as: security protocols, compatibility with other platforms, backup and redundancy systems, and so on;

• Create test tables and test scenarios.

These practices will ensure you what gets built is what you envisioned.

Verification – Ensure utmost accuracy

In addition to validating the software, you must verify that it has been built properly, and inputs and outputs comply with previously determined regulations.

When it comes to examining all specifications, medical software development should focus on job-centricity not just user-centricity. In short, focus on how the user needs to get their job done.

As agile practitioners, we believe that moving to an agile software development process can significantly improve your systems.

Tests are as important as the actual code. In agile practices, testing is used to confirm the precision of the system and as a method to provide immediate feedback during development.

Furthermore, it allows you to have a better control over costs and schedules, launch new features quickly, and adjust with your project needs.

To make sure testing and verification activities are performed as planned, use test-driven development and write automated tests in different abstraction levels of the system. These tools provide swift feedback at regular intervals, hence reduce the possibility of major problems.

Testing for Worst-Case Scenarios

A common mistake that often engineers make is to submit their test findings, only to have FDA require additional testing because the most serious conditions were not accounted for.

Make sure you test for the worst-case scenarios, otherwise the price of such mistakes can be a missed product launch, or even a redesign.

To learn more about Agile development and how it’s used to develop FDA compliant medical software, here’s an easy to read article.

You can also download this free “5 Ways Medical Companies are Using Software & Apps” guide for a better understanding on how to meet user and patient needs.

Release planning

Even though it’s impossible to identify every possible scenario, before releasing the product you must determine the most critical and probable situations that might arise. One common method is to run brainstorming sessions.

The release planning phase should involve a big-picture design that acts as a framework for more detailed design done in later phases of development, thus you’ll be able to plan and estimate the release in a trustworthy manner.

Medical devices are a key factor when making decisions for patients and, as history tells us, having the right testing equipment is just as important as saving lives.

Additionally, the application of these procedures help save time, money, and resources in the long run.

At AndPlus, we help transform innovative software design into reliable products with our verification and validation practices for medical devices.