Medical Device Software Change Control: Significant Changes
- A significant change is any modification that could alter device safety, clinical effectiveness, or intended use.
- 21 CFR 807.81(a)(3) requires a new 510(k) when a change could significantly affect safety, effectiveness, or intended use.
- Security patches and bug fixes that restore cleared specifications generally do not require a new regulatory submission.
- Modular architecture that separates transport and ingestion from clinical processing keeps infrastructure updates out of device scope.
- A Predetermined Change Control Plan lets teams deploy pre-cleared algorithm updates without filing a new 510(k) each time.
A software update triggers a new regulatory submission when it introduces a significant change to device safety, effectiveness, or intended use. Most engineering releases do not cross this threshold. Routine bug fixes, security patches, refactoring, and user interface styling stay within your internal change control system.
This article provides engineering orientation, not legal advice, and a notified body or regulatory consultant decides for a specific product. It shows software engineers how regulatory agencies evaluate code changes, which modifications require premarket review, and how modular architecture protects deployment velocity.
What is a medical device software change control significant change?
A significant change is any modification that could alter device safety, clinical effectiveness, or intended purpose. For medical software teams, the core question is whether an update requires regulator review before deployment.
In the United States, 21 CFR 807.81(a)(3) mandates a new 510(k) when a change could significantly affect safety or effectiveness, or when it alters intended use. Our guide to FDA software routes details these pathways. In the European Union, Regulation (EU) 2017/745 (MDR) Annex IX Section 4.10 requires notified body approval for substantial changes to design or intended purpose. Guidance MDCG 2020-3 Rev.1 details how notified bodies assess software modifications.
Every software change leads to 1 of 2 outcomes:
- Internal documentation: You assess risk, verify the code, update your technical file, and deploy. The FDA calls this a “Letter to File”. You do not notify regulators before shipping.
- Regulatory submission: You submit a new 510(k) or notified body supplement. You must wait for official clearance before commercial release.
Knowing the difference protects your release cadence. It prevents unnecessary filings for routine fixes, and stops you from shipping unapproved medical changes.
How does the FDA software change decision tree work?
The FDA outlines its evaluation process in its guidance document, Deciding When to Submit a 510(k) for a Software Change to an Existing Device. The guidance provides a flowchart built around 4 core engineering questions.
First, is the change made solely to strengthen cybersecurity? If an update patches a vulnerability without altering device functionality, performance, or clinical presentation, no 510(k) is required. You document verification and risk assessment internally and deploy.
Second, is the change made solely to return the device to its cleared specifications? When you fix a defect that caused the application to deviate from documented design, you do not need a new 510(k). The fix must not create new hazards or worsen existing risks.
Third, does the change introduce a new hazard, or increase the severity or probability of an existing hazard? If your update modifies an existing risk control or increases residual clinical risk, the FDA expects a new 510(k). To model these hazards accurately, review our guide to ISO 14971 risk management for imaging data pipelines.
Fourth, does the change alter clinical data, analysis algorithms, or intended use? If you modify how clinical values are calculated, displayed, or interpreted, the update is significant. Adding new clinical features, altering diagnostic metrics, or expanding patient populations triggers a new submission.
When does a software change qualify as significant under EU MDR?
European notified bodies evaluate software modifications using the framework in MDCG 2020-3 Rev.1. Flowchart C of this guidance focuses specifically on software changes.
Under the MDR framework, a software change is significant if it meets any of these criteria:
- It introduces a new intended purpose or expands clinical indications.
- It changes how clinical algorithms process or analyze patient data.
- It alters the diagnostic or therapeutic output delivered to the user.
- It removes an existing software risk control.
- It changes the operating architecture in a way that introduces new hazards.
Non-significant changes follow a simpler path. You update technical documentation, record verification results in your quality management system, and notify your notified body during your next audit.
Updating a storage schema to speed up queries without altering clinical data is non-significant. Refactoring internal code or updating logging libraries also stays internal.
If you are unsure whether your code change affects your device boundary, check our guide on MDCG 2019-11 software qualification and module boundaries.
Which releases stay within internal change control?
Most routine software releases fall safely under internal change control. You do not need to pause your delivery pipeline for standard engineering maintenance.
Common non-significant changes include:
- Security updates: Patching base images, runtimes, or libraries to fix CVE disclosures.
- Bug fixes for cleared specifications: Correcting a memory leak, crash bug, or UI alignment error.
- Performance optimizations: Improving index structures or query latency while preserving exact outputs.
- Non-clinical interface updates: Adjusting branding, button colors, or navigation menus that do not alter clinical workflows.
- Internal test tooling: Adding automated tests, linting rules, or continuous integration checks.
To handle these updates smoothly, maintain a strict change control procedure. Every release should map to a ticket, a git commit hash, and passing test suites.
Document your rationale in an internal memo before deployment. State why the change does not affect safety, intended use, or clinical algorithms. This record satisfies FDA inspectors and ISO 13485 auditors during routine audits. For details on documenting software life cycles, see our guide to IEC 62304 software safety classification.
Which changes turn a release into a regulatory event?
Certain modifications always alter the clinical risk profile of a product. These changes turn a software release into a formal regulatory event that requires premarket clearance.
The most common triggers include:
- Modifying diagnostic algorithms: Changing filter coefficients, model weights, or clinical scoring rules.
- Expanding clinical indications: Analyzing pediatric patients with an adult model, or adding support for new imaging modalities.
- Altering clinical urgency or workflow: Converting a passive viewer into an automated triage tool that prioritizes urgent cases.
- Changing risk controls: Modifying an automated safety check, such as an input validation rule that rejects corrupted DICOM pixel data.
- Removing clinician oversight: Shifting a system from clinician-confirmed suggestions to autonomous reporting.
When you plan any of these changes, a regulatory submission is required. In the United States, you typically submit a Special 510(k) or Traditional 510(k), which takes 30 to 90 days. In Europe, you submit a design change notification to your notified body, which often takes 3 to 6 months.
How architecture boundaries protect release velocity
Monolithic architecture creates severe regulatory friction. If your clinical diagnostic code, network listeners, authentication handlers, and web servers compile into a single binary, any change touches the medical device.
Patching a networking bug or updating a TLS library in a monolith forces you through medical device change control. You must run full risk assessments and regression test suites for code that has no clinical impact.
The solution is architectural modularity. Separate your system into distinct software modules:
Hospital PACS / Modality
│ (DICOM C-STORE over internet)
▼
[ Transport & Ingestion Module ] <-- Non-device infrastructure
│ (Validated HTTPS webhook)
▼
[ Clinical Processing Module ] <-- Regulated medical device software
Isolate infrastructure plumbing so updates to network handlers or server runtimes do not affect the medical device boundary.
A managed gateway such as Dicomly handles this transport layer by streaming incoming DICOM associations directly into HTTPS webhooks without storing files or inspecting clinical tags. This architecture keeps transport plumbing outside your medical device boundary. In exchange, you pay a monthly service fee and lose low-level TCP socket control, and your engineering team must still validate payload integrity at your webhook receiver.
By decoupling communication infrastructure from clinical code, you update networking and ingestion systems continuously. Medical device change control applies only when you modify the clinical module itself.
How to plan software changes using a PCCP
Machine learning models create a challenge for medical device change control. Teams improve algorithms continuously as new training datasets arrive. Under traditional rules, retraining an AI model requires a new 510(k) submission every time.
The FDA addresses this challenge through Predetermined Change Control Plans (PCCPs). The agency details this framework in its guidance, Predetermined Change Control Plans for Medical Devices.
A PCCP is an authorized plan included in your original 510(k) or De Novo submission. It defines:
- Description of Modifications: The specific changes you plan to make, such as retraining model weights with additional clinical data.
- Modification Protocol: The exact verification, validation, and risk management methods you will follow.
- Impact Assessment: Proof that planned updates will not alter device safety or intended use.
When the FDA clears your PCCP, you can deploy pre-cleared algorithmic updates without filing a new 510(k). You validate the update against your approved protocol, document results internally, and release the new model weights.
A PCCP requires upfront investment during your initial clearance. In return, it provides unmatched deployment velocity for teams running active AI development pipelines.
Next steps for your engineering change control
You can protect your release cadence by building change evaluation directly into your development workflow. You do not need to fear regulatory oversight when your decision boundaries are clear.
Take these 3 steps today:
- Audit your module boundaries: Review your system architecture diagram and confirm where non-device data transport ends and clinical analysis begins. Decouple your networking layers so infrastructure updates stay out of scope.
- Add a regulatory check to pull request templates: Include a simple 3-question prompt in your code review template: Does this PR alter clinical algorithms? Does it change an existing risk control? Does it introduce new clinical indications?
- Automate your verification evidence: Link your CI test pipeline directly to your requirements traceability matrix, so every release produces verifiable test records automatically.
Once your architecture cleanly isolates data transport from clinical evaluation, explore our guide on receiving deliveries via webhooks to see how clean boundary design works in production.
Dicomly builds infrastructure for healthcare software teams that receive DICOM studies from hospitals. Why we built Dicomly →