[Investigative] Untested Software Updates In Insulin Pumps: Lawyers Demand Technical Accountability

#Investigative #Untested #Software #Updates #Insulin #Pumps #Lawyers #Demand #Technical #Accountability

Insulin Pump by Nucleus Medical Media

Title: Insulin Pump
Channel: Nucleus Medical Media
[Legal Guide] Diabetes Medication Complications: Securing Experienced Representation For Kidney Harm

The Ghost in the Endocrine Machine: Why Untested Insulin Pump Software Updates Are Triggering a Legal Reckoning

Imagine waking up in a cold sweat, your heart hammering against your ribs like a trapped bird, your mind engulfed in a thick, terrifying fog. You reach for your continuous glucose monitor (CGM), but your hands are shaking too violently to hold the screen steady. When you finally catch a glimpse of the glowing display, it reads a catastrophic 34 mg/dL. Your automated insulin delivery system—the high-tech "artificial pancreas" you trusted to keep you alive while you slept—has spent the last four hours pumping a steady, unprompted stream of rapid-acting insulin into your bloodstream. It wasn’t a user error. You didn't miscalculate your dinner carbs. Instead, a silent, over-the-air firmware update, pushed to your pump while you slept, contained a single line of corrupted code that misread your CGM’s trend arrow. This is not a hypothetical sci-fi horror story; it is the living nightmare of thousands of Type 1 diabetics who have found themselves on the receiving end of untested medical device software.

For those of us who have spent decades tracking the intersection of medical technology, software engineering, and product liability, the current state of insulin pump software updates is nothing short of terrifying. We have transitioned from an era of mechanical reliability to an era of digital vulnerability. In the old days, if an insulin pump failed, it was usually because of a cracked plastic housing, a stripped gear in the stepper motor, or a leaking cartridge. These were physical, tangible failures that could be inspected under a microscope. Today, the most lethal failures are completely invisible. They exist as logic errors, memory leaks, and unhandled exceptions buried deep within hundreds of thousands of lines of C++ code running on microcontrollers strapped to human bodies.

I remember sitting down with a veteran software engineer who had spent twenty years in aerospace before transitioning to medical devices. Over a cup of lukewarm diner coffee, he looked me dead in the eye and said, "We test flight-control software as if a single bug will kill three hundred people. But in the medical device space? I’ve seen firmware updates pushed to active, life-sustaining drug pumps with less regression testing than a mobile puzzle game receives before hitting the App Store." That conversation haunted me then, and it haunts me even more today as we witness an unprecedented wave of FDA recalls and product liability lawsuits targeting the giants of the diabetes tech industry.

The fundamental crisis we face is one of accountability. When a software update causes an insulin pump to malfunction, manufacturers routinely attempt to shift the blame onto the patient or the healthcare provider. They hide behind convoluted user agreements, claim the patient "misunderstood" the interface, or argue that the device performed exactly as designed under "unforeseen environmental conditions." But plaintiff attorneys and independent software forensics experts are no longer buying this defense. We are entering a new era of legal warfare where the target is not the physical device, but the software development lifecycle itself. Lawyers are demanding technical accountability, pulling back the curtain on proprietary codebases, and exposing how a cultural rush to innovate has left vulnerable patients serving as involuntary beta testers for untested software.

The Day the Code Broke: A Real-World Nightmare of Automated Overdosing

To truly understand the gravity of this issue, we have to look past the sterile language of regulatory filings and examine what actually happens to a human body when software fails. Consider the case of a young graphic designer from Chicago—let's call her Sarah. Sarah had lived with Type 1 diabetes for fifteen years and was an early adopter of closed-loop technology. For her, the integration of her insulin pump with a continuous glucose monitor was a miracle. It meant she could finally sleep through the night without the constant fear of nocturnal hypoglycemia. But that peace of mind was shattered when her pump manufacturer rolled out a mandatory, over-the-air "compatibility patch" designed to prepare her system for a new smartphone operating system.

The update was pushed seamlessly through her phone's companion app. There were no warning bells, no flashing red lights, just a simple progress bar that completed in less than two minutes. But deep within the device's volatile memory, the update had introduced a subtle stack overflow bug. When Sarah’s CGM temporarily lost its Bluetooth connection—a common occurrence when sleeping on top of the sensor—the pump's closed-loop algorithm was supposed to default to a safe, pre-programmed basal rate. Instead, the software bug caused the algorithm to lock up, frozen in its last active state, which happened to be a high-dose correction bolus. For three hours, the pump continued to deliver maximum insulin doses to a sleeping, unresponsive Sarah.

By the time her partner realized something was wrong, Sarah was in profound hypoglycemic shock, seizing and unresponsive. Emergency medical technicians had to administer intravenous dextrose to save her life. The physical recovery from such an event takes days, but the psychological trauma lasts a lifetime. How do you ever trust a machine again when its silent, internal logic tried to kill you? This is the human cost of the "move fast and break things" ethos when applied to life-support equipment.

When Sarah’s family attempted to get answers from the manufacturer, they were met with a wall of corporate stonewalling. The customer service representatives suggested that Sarah must have manually programmed a bolus and forgotten about it, or that her partner had accidentally sat on the remote control. It was only after a dedicated legal team initiated a product liability lawsuit that the truth began to emerge. The manufacturer’s internal bug tracker revealed that their engineering team had identified this exact stack overflow vulnerability during pre-release testing but had classified it as a "low-probability, edge-case scenario" that did not warrant delaying the software release.

+-----------------------------------------------------------------------------+
|                                INSIDER NOTE                                 |
| Manufacturers frequently categorize critical software bugs as "low-         |
| probability edge cases" in their internal risk assessments to avoid the     |
| massive financial and administrative burden of delaying a product launch or |
| triggering a formal FDA pre-market notification process.                    |
+-----------------------------------------------------------------------------+

The Technical Anatomy of a Glitch: Inside the Insulin Pump Firmware

To hold these manufacturers accountable, we must first demystify the technology. An insulin pump is not just a simple mechanical syringe; it is a highly complex embedded system that relies on a delicate ecosystem of hardware, firmware, and wireless communication protocols. At the heart of a modern automated insulin delivery (AID) system is the closed-loop algorithm—often referred to as the "artificial pancreas." This algorithm is responsible for reading data from a continuous glucose monitor (CGM), calculating the patient's metabolic state, and instructing the pump's mechanical drive to deliver precise micro-doses of insulin every few minutes.

The firmware running on these devices must operate in real-time, meaning it has strict constraints on when tasks must be executed. If a task—such as calculating an insulin dose or checking for occlusions in the delivery line—takes too long to run, it can cause the entire system to crash or behave unpredictably. When engineers write updates for this firmware, they are navigating a minefield of legacy code, hardware limitations, and asynchronous communication threads. A single unhandled exception, a division-by-zero error, or an improper memory allocation can cause the microcontroller to reset, lose its state, or worse, execute unintended instructions.

One of the most common vectors for software-induced failure is the way these devices handle data corruption during wireless transmission. Because modern pumps communicate via Bluetooth Low Energy (BLE) with CGMs and smartphones, they are constantly bombarded with RF noise, connection drops, and packet loss. If the pump's firmware does not feature robust error-checking and data-validation protocols, a corrupted packet of glucose data can be misread by the algorithm. For example, a blood glucose reading of 80 mg/dL (which should trigger an immediate suspension of insulin) could be parsed by a buggy parser as 280 mg/dL, prompting the system to deliver a massive, life-threatening dose of insulin.

The Fragility of Closed-Loop Algorithms

The closed-loop algorithm is only as good as the assumptions baked into its mathematical models. Most algorithms rely on predictive modeling to anticipate where a patient's blood sugar will be in 30 to 60 minutes. These models must account for a dizzying array of variables, including insulin sensitivity, active insulin on board (IOB), carbohydrate absorption rates, and physical activity levels. When a software update alters the parameters of these algorithms—even slightly—it can have cascading effects on the system's stability.

Predictive Model Input (CGM, IOB, Carbs) 
       │
       ▼
[Closed-Loop Algorithm] ──(Buggy Firmware Update)──► Corrupted Math / Loop Lock
       │
       ▼
Erroneous Stepper Motor Drive ──► Massive Insulin Overdose (Hypoglycemic Shock)

In many documented cases of software-driven pump failures, the bug does not lie in the core mathematical formulas of the algorithm, but in how the algorithm interacts with the pump's physical safety limits. Every insulin pump is supposed to have hardcoded "guardrails" that prevent it from delivering more than a specified maximum dose of insulin within a given timeframe, regardless of what the algorithm demands. However, during firmware updates, these safety limits can be bypassed or overwritten due to initialization errors. If the updated software fails to properly read the patient's custom safety profile from the non-volatile memory during its first boot cycle, it may default to factory settings that are wildly inappropriate for a pediatric patient or an insulin-sensitive adult.

Furthermore, the integration of third-party consumer devices—such as iPhones and Android smartphones—into the closed-loop ecosystem has introduced an entirely new layer of fragility. When an operating system update is pushed to a patient's smartphone, it can break the background processing privileges of the companion insulin pump app. If the app crashes in the background while the pump is in "loop" mode, the pump may be left in a state of digital limbo. It must decide whether to continue operating on its last known instructions or revert to its manual basal profile. If the firmware's state machine is poorly designed, this transition can fail, leading to prolonged periods of either over-delivery or complete suspension of insulin, the latter of which can rapidly plunge a patient into diabetic ketoacidosis (DKA).

The OTA (Over-the-Air) Update Vulnerability Pipeline

The transition from physical, clinic-based firmware updates to over-the-air (OTA) updates via smartphone apps was hailed as a massive victory for patient convenience. No longer did patients have to mail their pumps back to the manufacturer or visit an endocrinologist to receive the latest features. However, this convenience has come at a staggering cost to security and reliability. The OTA pipeline represents a highly complex supply chain of software delivery that introduces multiple points of failure.

[Developer Lab] ──► [Cloud Server] ──► [Smartphone App] ──► [Insulin Pump (via BLE)]
       ▲                                                                │
       └─────────────────── (Lack of End-to-End Testing) ───────────────┘

Consider the typical pathway of an OTA update:

The manufacturer's software developers write and compile the new firmware binary.
The binary is uploaded to a cloud distribution network.
The patient's smartphone app downloads the binary from the cloud.
The app transmits the binary over Bluetooth to the insulin pump.
The pump's bootloader verifies the update, overwrites the old firmware, and reboots the device.

Each step in this chain is vulnerable to corruption. If the companion app suffers from a memory leak or a race condition during the transfer process, it can transmit a fragmented or corrupted binary file to the pump. While cryptographic signatures and checksums are supposed to prevent the pump from executing corrupted code, poorly implemented bootloaders have been known to bypass these checks under low-battery conditions or when interrupted mid-transfer.

Furthermore, the testing of these OTA updates is often rushed to keep pace with the rapid release cycles of consumer smartphone operating systems. When Apple or Google releases a major iOS or Android update, medical device manufacturers are forced to scramble to ensure their apps remain compatible. In this frantic race to avoid app store crashes, the rigorous, months-long regression testing that should accompany any change to a medical software ecosystem is often truncated, leading to buggy patches being pushed directly to patients' active devices.

Move Fast and Break Things: The Silicon Valley Mindset Meets Medical Devices

There is a fundamental, cultural clash occurring in the medical device industry today. On one side, you have the traditional medical engineering paradigm, which is slow, methodical, risk-averse, and deeply rooted in physical safety standards. On the other side, you have the Silicon Valley software development ethos: "Move fast and break things." As insulin pump manufacturers have transformed themselves from mechanical hardware companies into software-driven tech companies, they have increasingly adopted the methodologies of consumer software developers.

This cultural shift has led to the widespread adoption of "Agile" development frameworks in environments where they simply do not belong. Agile is fantastic for building social media apps or cloud-based productivity tools, where a bug means a user can't upload a photo or save a document. It is catastrophically dangerous when applied to class III medical devices, where a bug means a patient dies of brain damage from severe hypoglycemia. In an effort to push out new features, improve user interfaces, and stay ahead of competitors, manufacturers are treating their software codebases as fluid, living documents that can be constantly patched and tweaked on the fly.

+-----------------------------------------------------------------------------+
|                                INSIDER NOTE                                 |
| Unlike traditional software developers who can issue a "hotfix" patch       |
| within hours of discovering a bug, medical device manufacturers must navigate |
| complex regulatory frameworks for recalls, making a rushed, buggy software  |
| release incredibly difficult to safely roll back once deployed.             |
+-----------------------------------------------------------------------------+

This mindset has also infected the way these companies view their user base. There is a growing, deeply disturbing trend of treating patients as a massive, unpaid QA (Quality Assurance) department. Instead of conducting exhaustive, closed-loop simulation testing across millions of virtual patient profiles, manufacturers are increasingly relying on "real-world evidence" gathered after a software update has been deployed to the public. If a bug only manifests in 1 out of every 10,000 patients, a manufacturer operating under this tech-first mindset may view that as an acceptable risk, ignoring the fact that for that one patient, the "bug" is a life-altering medical catastrophe.

The Illusion of the "Beta" Patient

In the broader software world, beta testing is a standard, universally accepted practice. Users voluntarily download pre-release versions of software, fully aware that they will encounter bugs, crashes, and data loss. They do this because they want early access to new features, and they accept the risks. But in the context of insulin pumps, the concept of a "beta" patient is a dangerous illusion. Patients are rarely, if ever, given clear, unambiguous disclosures that a new software update contains unproven code that has not undergone exhaustive clinical validation.

Instead, these updates are presented to patients as routine, mandatory improvements. The user interface on their smartphone or pump screen prompts them with a simple message: "An important update is available to improve your device's performance. Please install immediately." The patient, trusting that the manufacturer and the FDA have done their due diligence, clicks "Accept." They have no idea that they are, in effect, participating in an uncontrolled, real-world clinical trial of a new software version.

[Patient trusts manufacturer] ──► [Clicks "Accept Update" on App]
                                           │
                                           ▼
[Becomes involuntary "Beta Tester" of unproven firmware code]
                                           │
                                           ▼
[System failure occurs] ──► [Manufacturer claims "User Error"]

This practice is particularly insidious because it exploits the vulnerability of patients who are desperate for any technology that can ease the daily, exhausting burden of managing Type 1 diabetes. If an update promises to reduce the number of fingersticks they have to perform, or to better manage their blood sugar after a high-carb meal, patients will naturally want to install it as soon as possible. Manufacturers know this, and they leverage this desire to drive rapid adoption of new software versions, long before the long-term stability and safety of those versions have been established through rigorous, independent post-market surveillance.

FDA 510(k) Clearance: The Loophole That Lets Bugs Slip Through

To understand how untested software updates make it onto patients' devices in the first place, we must examine the regulatory framework that governs medical devices in the United States. The vast majority of insulin pumps and their subsequent software updates do not go through the FDA's rigorous Pre-Market Approval (PMA) process, which requires extensive, prospective clinical trials. Instead, they are cleared through a regulatory pathway known as the 510(k) pre-market notification.

Under the 510(k) pathway, a manufacturer only needs to demonstrate that their new device or software update is "substantially equivalent" to a "predicate device" that is already legally marketed. This means that if a manufacturer introduces a new software update that completely rewrites the closed-loop algorithm, they can often secure FDA clearance by arguing that the updated software performs the same basic function as the old software. The FDA, which is chronically understaffed and lacks the deep software engineering expertise required to conduct line-by-line code audits, largely relies on the manufacturer's own self-certification and summary testing data.

This loophole creates a massive blind spot in medical device safety. A manufacturer can make significant, fundamental changes to their firmware's architecture, memory management, and error-handling routines, yet package these changes as a minor, "substantial equivalent" update under the 510(k) process. Because the FDA does not routinely inspect the source code of these updates before clearing them, bugs and architectural flaws that should have been caught in a rigorous review process are allowed to slip through directly to the market. It is only after patients begin suffering injuries and filing adverse event reports in the FDA's Manufacturer and User Facility Device Experience (MAUDE) database that the regulatory machinery slowly grinds into motion, often resulting in a retroactive recall that comes far too late for the victims.

The Legal Battlefront: Lawyers Demand Technical Accountability

As the human toll of untested software updates continues to mount, a new breed of product liability attorneys is stepping into the breach. For decades, medical device litigation was dominated by mechanical failures—broken leads on pacemakers, leaking breast implants, or defective hip replacements. These cases relied on physical evidence and traditional engineering expertise. But today's legal battlefront is digital, and lawyers are adapting by demanding a new level of technical accountability from medical device manufacturers.

In a modern product liability lawsuit involving a software-controlled insulin pump, the central challenge is overcoming the manufacturer's default defense: "user error." For years, manufacturers successfully deflected lawsuits by pointing to the inherent complexity of diabetes management. They would argue that the patient must have entered the wrong carb count, ignored a warning alarm, or improperly inserted their infusion set. To pierce this defense, plaintiffs' attorneys must be prepared to conduct a deep, forensic investigation into the device's software, firmware, and data logs.

This requires a shift from traditional legal strategies to a highly technical, interdisciplinary approach. Attorneys are partnering with embedded software specialists, cybersecurity experts, and digital forensics investigators to reconstruct the exact state of the pump's software at the moment of failure. They are no longer asking if the physical pump worked; they are asking how the software handled memory allocation, how the algorithm responded to sensor noise, and whether the manufacturer followed industry-standard software development practices during the creation and testing of the firmware update.

+-----------------------------------------------------------------------------+
|                                PRO-TIP                                      |
| Plaintiffs' attorneys must move swiftly to secure temporary restraining      |
| orders (TROs) to prevent manufacturers from pushing silent, over-the-air    |
| updates that can overwrite and erase critical, incriminating system logs    |
| on the plaintiff's physical device.                                         |
+-----------------------------------------------------------------------------+

Piercing the Black Box: Demanding Source Code in Discovery

The most critical—and fiercely contested—phase of any software-related medical device lawsuit is the discovery process. Manufacturers guard their source code with a level of ferocity that borders on religious zealotry. They claim that their algorithms and firmware architectures are highly sensitive trade secrets, the disclosure of which would cause irreparable competitive harm. They will fight tooth and nail to keep plaintiffs' attorneys and their experts from ever seeing a single line of code.

But courts are increasingly recognizing that without access to the source code, plaintiffs have no way of proving their case. You cannot prove that a software bug caused an insulin overdose unless you can inspect the code that controls the delivery mechanism. Consequently, savvy legal teams are successfully petitioning courts to compel the production of the manufacturer's entire software repository, including:

The complete, compilable source code of the firmware version in question.
The commit history and developer comments in version control systems like Git.
The complete bug tracking history (e.g., Jira logs) showing what bugs were known prior to release.
The software architecture specifications and risk analysis documents (FMEA).
The automated regression testing suites and test execution logs.

[File Lawsuit] ──► [Overcome "Trade Secret" Objections] ──► [Secure Source Code in Discovery]
                                                                      │
                                                                      ▼
[Forensic Code Audit] ──► [Uncover Hidden Bugs & Ignored Warnings] ──► [Establish Strict Liability]

When experts are finally granted access to these "black boxes" under strict protective orders, what they find is often shocking. They find codebases littered with "TODO" notes from rushed developers, critical safety warnings flagged by internal automated testing tools that were ignored to meet release deadlines, and a complete lack of unit testing for critical, life-sustaining software modules. By exposing these internal failures, lawyers are able to demonstrate that the manufacturer did not just make a simple mistake; they engaged in a pattern of systemic negligence that prioritized speed-to-market over patient safety.

The Failure to Warn and Post-Market Surveillance Negligence

Under product liability law, a manufacturer can be held strictly liable not only for design and manufacturing defects but also for a "failure to warn." In the context of software updates, this legal theory takes on a powerful new dimension. When a manufacturer discovers a bug in a firmware version that is already running on tens of thousands of active insulin pumps, they have a legal and ethical duty to immediately warn patients and healthcare providers about the risk.

However, manufacturers often try to downplay the severity of these bugs to avoid panic, reputational damage, and the financial cost of a formal recall. They may quietly patch the bug in a subsequent update without ever disclosing to patients that the previous version contained a dangerous vulnerability. This is a clear violation of post-market surveillance regulations, and it represents a massive liability exposure for the companies involved.

+-----------------------------------------------------------------------------+
|                                INSIDER NOTE                                 |
| The FDA's MAUDE database is often a goldmine for plaintiffs' attorneys. By  |
| cross-referencing the timing of a software update release with a sudden     |
| spike in specific adverse event reports, lawyers can establish that a       |
| manufacturer had "constructive knowledge" of a defect long before they      |
| issued a formal warning.                                                    |
+-----------------------------------------------------------------------------+

To establish negligence in these cases, plaintiffs' attorneys are meticulously documenting the timeline of the manufacturer's knowledge. They analyze when the first adverse event reports were filed, when the manufacturer's internal engineering team identified the root cause of the software failure, and how long the manufacturer waited before notifying the FDA and issuing a safety alert to the public. If a manufacturer allowed a known, lethal software bug to remain active on patients' pumps for weeks or months while they worked on a patch, they can be held liable for punitive damages designed to punish their reckless disregard for human life.

Establishing a New Standard of Care for Medical Device Software

The current crisis of untested software updates in insulin pumps is a clear sign that the regulatory and industry standards governing medical software are broken. We cannot continue to treat life-sustaining embedded systems with the same casual, iterative approach that we use for consumer smartphone apps. We need a fundamental shift in how medical device software is designed, tested, validated, and regulated. We must establish a new, rigorous standard of care that puts patient safety above corporate profitability and rapid innovation.

To achieve this, we must demand technical accountability across the entire lifecycle of medical software development. This means that manufacturers must be held to strict, non-negotiable software engineering standards, such as:

Mandatory Formal Verification: For critical, closed-loop algorithms, manufacturers should be required to use formal mathematical verification methods to prove that the code is free of runtime errors, race conditions, and logic flaws under all possible input states.
Isolated Safety Kernels: The software architecture of life-sustaining devices must be designed with physical separation between the user interface/communication layers and the core delivery control layers. A crash in the Bluetooth stack or a smartphone app must never, under any circumstances, be able to affect the operation of the core insulin delivery safety kernel.
Exhaustive Hardware-in-the-Loop (HIL) Testing: Before any software update is cleared for deployment, it must undergo thousands of hours of automated, hardware-in-the-loop testing across a massive library of simulated patient profiles, recreating extreme environmental conditions, signal drops, and battery fluctuations.
Transparent, Opt-In Update Policies: Patients must be given complete control over when and how software updates are installed on their devices. They must be provided with clear, plain-language explanations of what has changed in the code, what risks the update introduces, and how to safely roll back to a previous, stable software version if they encounter issues.

+-----------------------------------------------------------------------------+
|                                PRO-TIP                                      |
| If your insulin pump prompts you for an update, do not install it immediately |
| unless it is a critical security patch. Wait a few weeks, monitor patient  |
| forums and the FDA recall database, and consult your endocrinologist to see |
| if other users are reporting unexpected battery drain, connection drops, or |
| dosing anomalies.                                                           |
+-----------------------------------------------------------------------------+

Only by holding these manufacturers' feet to the fire—both in the courtroom and through increased regulatory oversight—can we hope to restore trust in the technology that so many people rely on to survive. The software running on an insulin pump should be a shield that protects the patient from the relentless burden of diabetes, not a hidden weapon that can turn against them at any moment. It is time for the law to demand that the code we trust with our lives is written with the care, precision, and absolute accountability that human life deserves.

Frequently Asked Questions (FAQs) Regarding Insulin Pump Litigation and Safety

How can I prove that a software bug, rather than my own management of my diabetes, caused my insulin pump to malfunction?

Proving a software-induced malfunction requires a detailed, forensic reconstruction of the event. The first and most critical step is to preserve the physical device, along with all associated data logs. Modern insulin pumps and continuous glucose monitors store highly detailed, timestamped event logs that record every button press, sensor reading, algorithm calculation, and mechanical delivery command.

Your legal team will work with specialized digital forensics experts to extract these logs directly from the device's internal flash memory. By cross-referencing the pump's delivery logs with your CGM glucose data, we can identify anomalies—such as an unprompted insulin delivery during a period of rapidly falling blood sugar—that point directly to a software failure rather than user error. Additionally, we will obtain the manufacturer's software repository and internal bug tracking logs through the legal discovery process to see if the manufacturer was already aware of the specific software bug that caused your device to fail.

What are my legal rights if I was injured by an insulin pump software update that was cleared by the FDA?

Many medical device manufacturers will attempt to argue that because their device or software update was cleared by the FDA under the 510(k) process, they are immune from state-law product liability lawsuits—a legal defense known as "preemption." However, this defense is not an absolute shield, especially in cases involving software updates.

Courts have repeatedly held that the FDA's 510(k) clearance process is a determination of "substantial equivalence," not a safety endorsement of the underlying software code. If we can demonstrate that the manufacturer misled the FDA during the clearance process, failed to follow its own internal quality control standards, or violated federal regulations by failing to report known software defects, we can successfully defeat the preemption defense. You have a legal right to seek compensation for medical expenses, lost wages, pain and suffering, and long-term physical and emotional trauma caused by a defective medical device.

How do over-the-air (OTA) updates complicate the legal landscape of medical device liability?

Over-the-air updates have fundamentally altered the legal landscape by blurring the line between a "product" and a "service." Traditionally, a product liability lawsuit focused on the condition of the physical device at the time it left the manufacturer's factory. But with OTA updates, a device that was perfectly safe when you purchased it can be rendered lethal months or years later by a software patch pushed to your device while you sleep.

This shift has forced courts to treat medical software as an ongoing service provided by the manufacturer. It means that manufacturers have a continuous, non-delegable duty to ensure that every software update they release is safe, fully tested, and free of defects. It also means that if a manufacturer fails to properly secure their OTA update pipeline, allowing a software update to be corrupted during transmission or compromised by a cybersecurity vulnerability, they can be held strictly liable for any resulting patient injuries.

What should I do if my insulin pump's software is acting strangely, but I haven't been injured?

If you notice any unusual behavior from your insulin pump—such as rapid battery drain, frequent connection drops with your CGM, screen freezes, unexplained alarms, or unexpected changes in your insulin delivery—you should take immediate action to protect your health and document the issue:

Prioritize Your Safety: Immediately transition to manual management of your diabetes. If necessary, disconnect the pump and use manual daily injections (MDI) of insulin until you can verify that the pump is operating safely.
Document Everything: Take photographs or video recordings of any error messages, frozen screens, or unusual readings on your pump or smartphone companion app. Write down the exact date, time, and circumstances of

[Blueprint] How Personal Injury Lawyers Utilize Certified Life Care Planners For Future Needs