Short answer
IEC 62304 (current version IEC 62304:2006+AMD1:2015) defines the life cycle processes for medical device software. The EU MDR does not name it, but Annex I, section 17.2 requires software to be developed according to the state of the art, and Notified Bodies expect IEC 62304 evidence in practice. Software is classified A, B or C by the harm it could contribute to after risk controls external to the software: no unacceptable risk (A), non-serious injury (B), or death or serious injury (C). The class sets the rigour of planning, requirements, architecture, testing and SOUP management, and Agile teams can comply without switching to waterfall.
Why IEC 62304 matters — and what happens when you get it wrong
IEC 62304 is the international standard for medical device software life cycle processes. The current version is IEC 62304:2006+AMD1:2015 — the first edition with Amendment 1, published by the IEC as consolidated edition 1.1. The EU MDR itself does not name a standard: Annex I, section 17.2 requires software to be developed and manufactured in accordance with the state of the art, taking into account the principles of development life cycle, risk management (including information security), verification and validation. Only standards whose references are published in the Official Journal give a presumption of conformity (Article 8), so check the Commission's list of harmonised standards for the current status of EN 62304. In practice, Notified Bodies use IEC 62304 as the reference when they review the software life cycle evidence in your technical file, and it is the structural foundation of your entire software documentation.
Getting the software safety classification wrong — or claiming IEC 62304 compliance without the documentation evidence to back it up — is, in our experience, one of the most common and costly mistakes SaMD companies make. It tends to generate major non-conformities that hold up NB review.
Software safety classification: Class A, B, C explained
The first and most important step is classifying your software under IEC 62304's three-tier system. This classification drives the level of rigour required across your entire development lifecycle. Since Amendment 1 (2015), the classification is risk-based: it depends on whether the software system can contribute to a hazardous situation that results in an unacceptable risk after considering risk control measures external to the software system, and on the severity of the possible harm. The class is documented in the risk management file. Note that the IEC 62304 software safety class is not the same as the device's MDR risk class under Rule 11 — a Class IIa device can contain Class C software, and vice versa.
Class A — no unacceptable risk
Class A: the software system cannot contribute to a hazardous situation, or it can contribute to a hazardous situation that does not result in an unacceptable risk after consideration of risk control measures external to the software system. Possible examples: administrative functions, or data display software where the raw data is independently verified by the clinician before clinical decisions are made — provided your risk analysis supports it.
Class A has the lightest requirements under IEC 62304 — but in our experience it is also the most commonly misclassified. Many SaMD teams classify their software as Class A to reduce documentation burden, then discover during NB review that the risk analysis actually supports Class B or C.
Class B — unacceptable risk, non-serious injury
Class B: the software system can contribute to a hazardous situation that results in an unacceptable risk after consideration of external risk control measures, and the resulting possible harm is non-serious injury. Many clinical decision support, monitoring and diagnostic-aid applications that inform clinical decisions without driving them autonomously end up in Class B — but the class always follows from your own risk analysis.
Class B requires more rigorous testing, architecture documentation, and traceability than Class A — but less than Class C.
Class C — unacceptable risk, death or serious injury
Class C: the software system can contribute to a hazardous situation that results in an unacceptable risk after consideration of external risk control measures, and the resulting possible harm is death or serious injury. Autonomous diagnostic AI, treatment planning software, software controlling active devices, and software with direct patient dosing implications can fall into Class C.
Class C requires the full weight of IEC 62304: detailed design of software units and interfaces, additional unit acceptance criteria, complete traceability from requirements through to test evidence, and formal software problem resolution processes.
Key IEC 62304 processes and what they require
Software development planning (Clause 5.1)
Before any development begins, IEC 62304 requires a Software Development Plan. In practice it should define: the software safety class (whose rationale is documented in the risk management file), the standards and processes to be followed, the deliverables at each development stage, the risk management approach specific to software, and the configuration management plan. This plan is not a formality — NBs read it and use it to evaluate whether your subsequent documentation is consistent with your stated processes.
Software requirements analysis (Clause 5.2)
Every intended use and functional requirement must be documented in a Software Requirements Specification. Requirements must be uniquely identified (numbered) and traceable — because IEC 62304 requires you to demonstrate that every requirement has been tested and verified. Requirements that are vague, duplicated, or unidentified cannot be traced, and your traceability matrix will have gaps that NB reviewers will flag.
Software architecture (Clause 5.3)
The software architecture document identifies the major software items (modules, components, subsystems), their interactions and interfaces, and the rationale for the architectural decisions. An architecture is required for Class B and C software, and it must address how hazardous software failures are mitigated at the design level (including any segregation relied on for risk control). This is also where cybersecurity design decisions should be documented.
Unit implementation, verification and integration (Clauses 5.5 and 5.6)
Clause 5.5 covers implementing and verifying software units. For Class B and C software, each unit must be verified against defined acceptance criteria before integration, and Class C adds further acceptance criteria. Clause 5.6 then covers integration and integration testing for Class B and C. Verification must be documented — test plans, test cases, test results, and pass/fail criteria. The standard does not mandate specific coverage metrics, but NBs reviewing Class C software will ask about your approach.
Software system testing (Clause 5.7)
System testing verifies that the integrated software meets its requirements. Test protocols must map test cases to requirements (the traceability matrix), document the test environment, record results, and document the disposition of any anomalies discovered during testing. For a worked example with a free template, see our SaMD traceability matrix guide.
SOUP management (across clauses 5 to 8)
SOUP — Software of Unknown Provenance — refers to third-party libraries, frameworks, and open-source components incorporated into your software. IEC 62304 requires you to identify all SOUP items under configuration management, specify their functional and performance requirements and the hardware and software they need (Class B and C), consider them as potential causes of hazardous situations and evaluate their published anomaly lists in software risk management, and plan in maintenance how you will monitor them. Add known security vulnerabilities to that monitoring. This is an area where many SaMD teams have significant gaps — particularly teams using multiple open-source libraries without a formal SOUP management process.
Implementing IEC 62304 in an Agile environment
The most common question we hear from SaMD development teams is: "We use Scrum — does IEC 62304 require us to switch to waterfall?" The answer is no. IEC 62304 specifies the what — the deliverables and processes — not the how, and it does not prescribe a particular life cycle model. Here is how Agile teams can meet the standard without abandoning their workflow (and, if you are building the QMS around it, how we approach ISO 13485 for software teams):
- Design inputs and outputs at the user story level: Treat acceptance criteria as design inputs; define outputs as the specific implementation that satisfies them. Design reviews can happen in sprint review ceremonies.
- Traceability in your existing tools: Jira, GitHub Issues, and Azure DevOps can all maintain the requirement-to-test traceability IEC 62304 requires. The key is consistent ID schemes and linking practices — not a separate spreadsheet.
- Change control at the release level: Software change control can operate at release or sprint boundary level. Every release is a documented, authorised change with test evidence attached — this is compatible with CI/CD pipelines.
- SOUP inventory as a living document: Maintain your SOUP list in your repository (a machine-readable SBOM is becoming best practice for this) and update it automatically on every dependency change.
- ↗ IEC 62304:2006+AMD1:2015 (consolidated edition 1.1) — Medical device software life cycle processes — IEC Webstore
- ↗ ISO 14971:2019 — Risk management for medical devices — ISO
- ↗ ISO 13485:2016 — Quality management systems — ISO
- ↗ MDCG 2019-11 Rev.1 — Software qualification and classification — MDCG