MDCG 2019-11: Software Qualification & Boundaries
- Software qualifies as a medical device under MDCG 2019-11 only when it serves an intended medical purpose.
- The decision tree's runtime location does not matter; qualification depends only on the software's intended purpose.
- Pure communication and storage pipelines exit the device framework at Decision Step 3 if they do not alter clinical meaning.
- Lossless compression that allows exact data reconstruction does not make software a medical device under the guidance.
- Section 7 allows modular segregation, but non-medical modules must not impair the safety of medical modules.
Under European Union guidance MDCG 2019-11, software qualifies as medical device software only when it serves an intended medical purpose. It must also perform an action on data beyond communication, storage, or lossless compression. Systems that only route or store DICOM files without interpreting clinical data are not medical devices. For platforms combining data pipelines with clinical algorithms, MDCG 2019-11 allows modular separation so you certify only the clinical module.
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 to work through the official decision steps and defend module boundaries in technical documentation.
When is software qualified under MDCG 2019-11 software qualification guidance?
The Medical Device Coordination Group issued MDCG 2019-11 Rev.1 to help manufacturers interpret the European Medical Device Regulation (MDR 2017/745). The guidance defines Medical Device Software as software intended for a purpose listed in MDR Article 2(1).
MDCG 2019-11 makes one point immediately clear: runtime location does not matter. Whether code runs on a local workstation, a mobile phone, or in a cloud container, the regulatory test is identical. The guidance formally retired the older term “standalone software”. European regulators evaluate software strictly by its intended medical purpose, not its deployment environment.
The guidance also brings practical relief for engineering teams. It recognizes that modern health platforms include many subsystems performing non-medical jobs. You do not need to certify an entire cloud infrastructure simply because it delivers images to a diagnostic model.
Before evaluating risk classes or notified body review paths, you must confirm that your code qualifies as a device. If a component does not qualify under MDCG 2019-11, it falls outside the MDR entirely.
Walking through the MDCG 2019-11 decision tree
Section 3.2 of MDCG 2019-11 provides a 5-step decision flowchart. This flowchart establishes whether software falls under the MDR or exits the medical device scope.
Decision Step 1: Is the product software? The guidance defines software as a set of instructions that processes input data and creates output data. Hardware microcode, firmware, and cloud microservices all fulfill this definition. If yes, proceed to Step 2.
Decision Step 2: Does the software drive or influence a device? Software directly controlling hardware takes the regulatory class of that hardware. If software acts as an accessory, it qualifies under Article 2(2). Independent software proceeds to Step 3.
Decision Step 3: Does the software act on data beyond basic operations? This is the central fork for data pipelines. If code only transfers, archives, or indexes data without altering clinical meaning, it stops here and exits the device framework. If it performs an action beyond storage, communication, or lossless compression, proceed to Step 4.
Decision Step 4: Is the action for the benefit of individual patients? Software calculating population statistics, epidemiological registries, or hospital billing records stops at Step 4. It does not target individual patient care. If the output benefits an individual patient, proceed to Step 5.
Decision Step 5: Does the software fulfill the medical device definition in MDR Article 2(1)? The software must diagnose, prevent, monitor, predict, or treat a disease, injury, or disability. If it fulfills an Article 2(1) purpose, it qualifies as Medical Device Software. It then enters the classification rules in MDR Annex VIII Rule 11.
Why communication pipelines stop at Decision Step 3
Decision Step 3 is where pure data pipelines cleanly exit the medical device framework. To prevent ambiguity, MDCG 2019-11 explicitly defines basic data functions.
Footnote 25 of the guidance adopts the IEEE 610.10 definition of communication: the flow of information from a source to a receiver. MDCG 2019-11 states that general communication systems do not fall within the medical device definition.
Consider what a DICOM transport pipeline does during imaging ingest. An imaging modality connects over port 104 to send CT slices using a C-STORE transfer. Alternatively, a clinic uploads images using DICOMweb STOW-RS over HTTPS. The pipeline parses the outer envelope, verifies TLS certificates, checks the transfer syntax, and writes the byte stream to object storage.
At no point does the pipeline alter pixel values. It does not measure anatomical structures. It does not reorder slices based on suspected pathology. Because the pipeline only performs communication and storage, the answer to Decision Step 3 is “No”.
MDCG 2019-11 also addresses lossless compression. Using a compression procedure that allows exact reconstruction of original data does not make software a medical device. If your pipeline transcodes uncompressed DICOM instances into lossless JPEG-LS or JPEG 2000 transfer syntaxes, it remains a communication utility under Step 3.
In contrast, software altering data to support diagnosis answers “Yes” at Step 3. Section 3.1 gives specific examples: edge enhancement, gray scale manipulation, contrast stretching, or automated lesion search. Once code changes pixel representations to guide clinical decisions, it leaves the communication exception behind.
How do you define module boundaries under Section 7?
Real-world healthcare software rarely consists of a single binary. Most commercial products combine user management, DICOM ingestion, image viewers, and automated algorithms within one cloud platform.
Section 7 of MDCG 2019-11 Rev.1 addresses this modular reality directly. The guidance confirms that software can be segregated into distinct modules where some modules serve a medical purpose and others do not. Modules claiming an intended medical purpose fall under the MDR. Modules without a medical purpose remain outside MDR requirements.
Section 7 sets 4 requirements for manufacturers who rely on modular segregation:
- Explicit boundary identification. You must explicitly identify which modules are subject to the MDR and which sit outside. This boundary must be visible in technical documentation and clear to users.
- Interface safety and performance. The overall system configuration, including connection interfaces and data exchanges, must be demonstrably safe. Non-medical modules must not impair the performance or safety of medical modules.
- Architecture evaluation. You must document how medical modules acquire input data and present output data. If a non-medical module provides operational support, you must evaluate its impact on safety.
- User clarity. Users must receive clear documentation explaining which parts of the platform constitute the certified medical device and which parts are general IT services.
Notified bodies reject arbitrary boundary lines. If a non-medical pipeline drops slices silently or corrupts metadata tags, the diagnostic module downstream produces erroneous results. You must demonstrate that your architectural interfaces prevent pipeline failures from creating clinical hazards.
Architectural controls for non-device data pipelines
To defend a non-device pipeline in an audit, your technical documentation must reflect real engineering boundaries. You cannot declare a boundary in a PDF while running tight coupling in code.
First, establish clear API contracts. Decouple your communication pipeline from your clinical inference engine using standard network interfaces. For example, have your ingestion worker deliver raw DICOM files to cloud object storage, then publish a notification event. The clinical module fetches the stored file as a read-only consumer through its own interface.
Second, enforce independent input validation inside the medical device module. Under ISO 14971 risk management, your clinical algorithm cannot assume that upstream pipes deliver perfect data. The medical software module must independently verify DICOM SOP Class UIDs, pixel bit depths, slice spacing, and patient identifiers before running inference. If an input is incomplete, the clinical module must reject the study safely.
Third, maintain independent deployment lifecycles. If you package your ingestion listener and your AI model in the same container, any pipeline bug fix requires re-evaluating the entire release under IEC 62304. Splitting the ingest pipeline into a separate service allows your ops team to patch network libraries without triggering medical device change control.
Connecting hospital DICOM modalities brings operational friction. Senders require mutual TLS handshakes, custom port mappings, and persistent TCP connections. Building a custom C-STORE listener to manage these hospital connections requires ongoing protocol maintenance and dedicated server infrastructure.
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.
Next steps for mapping your pipeline boundaries
Drawing clean module boundaries under MDCG 2019-11 protects your engineering velocity. It keeps cloud data pipelines, network proxies, and administrative storage services out of lengthy notified body audit cycles.
Start by auditing your software architecture today:
- Trace your data flow on a single diagram from the hospital scanner to the clinical user.
- Mark the exact line where raw communication stops and clinical evaluation begins.
- Write a 1-paragraph intended purpose statement for each component on that diagram.
- Verify that your marketing website and user manuals make zero diagnostic claims for your ingestion pipeline.
- Add automated input validation tests to the boundary of your clinical module.
If you are determining whether your product as a whole qualifies as a medical device, compare your architecture against our guide on cloud software as a medical device. Once you establish that a module qualifies as a device, use our MDR Rule 11 classification guide. It helps you determine whether clinical software lands in Class I, IIa, or IIb.
Dicomly builds infrastructure for healthcare software teams that receive DICOM studies from hospitals. Why we built Dicomly →