IEC 62304 Software Safety Classes: Class A, B, and C
- IEC 62304 defines three software safety classes: Class A (no injury possible), Class B (non-serious injury), and Class C (death or serious injury).
- Classification is based on severity of harm, not probability, because IEC 62304 assumes software failure probability is 100%.
- Amendment 1 added a two-step process allowing external risk controls to reduce a software item's assigned class.
- Class C requires detailed design and unit verification for every unit, while Class A exempts both activities.
- Software segregation into separate items can let different components carry different safety classes.
IEC 62304 divides medical device software into 3 safety classes: Class A, Class B, and Class C. This classification sets the documentation, design rigor, and verification depth required before release. Class A requires the least documentation, while Class C demands formal detailed design and unit verification for every unit.
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 classify software items and meet requirements using lean developer workflows.
What is IEC 62304 software safety classification?
The international standard IEC 62304:2006 defines life cycle requirements for medical device software. Both the United States Food and Drug Administration (FDA) and European notified bodies recognize it as the benchmark for medical software development.
Engineers often confuse regulatory device classification with software safety classification. Device classification depends on intended clinical purpose and legal jurisdiction.
Under European Union Medical Device Regulation (EU MDR 2017/745), software receives a device tier such as Class I, Class IIa, Class IIb, or Class III. Our guide to MDR software classification rules details those rules. The FDA classifies devices into Class I, Class II, or Class III based on product codes.
In contrast, IEC 62304 software safety classification is an internal engineering framework. It dictates the development processes, test artifacts, and technical records you must maintain.
A Class IIa medical device does not automatically require Class B software. If software failure cannot cause physical injury, a Class IIa device can contain Class A software components.
Conversely, a Class IIb device might isolate its core diagnostic function in Class C, leaving utility tools in Class A. Before classifying code, check our guide on is your cloud software a medical device.
How do Class A, Class B, and Class C differ?
Clause 4.3 of IEC 62304 defines 3 software safety classes based on the severity of harm that software failure can cause:
- Class A: No injury or damage to health is possible.
- Class B: Non-serious injury is possible.
- Class C: Death or serious injury is possible.
IEC 62304 links these definitions directly to the risk management framework in ISO 14971. To see how pipeline defects translate into clinical risk, review our guide to ISO 14971 risk management for imaging data pipelines.
To classify your software, you assess what happens if your code crashes, corrupts data, calculates an incorrect measurement, or drops an alert.
Hardware risk analysis multiplies probability of failure by severity of harm. IEC 62304 rejects that model for software. Bugs are systematic design flaws, not wear-and-tear events.
Because developers cannot assign a numerical probability to a latent bug, IEC 62304 assumes that software failure probability is 100%. If a defect can lead to a hazardous situation, regulators assume that failure will occur. Classification depends entirely on the resulting severity of harm.
Non-serious injury (Class B) means temporary discomfort or reversible conditions that resolve without medical intervention. Serious injury (Class C) means permanent impairment of bodily function or irreversible tissue damage. It also includes injuries requiring urgent intervention to avoid permanent harm.
How does Amendment 1 change software classification?
The original 2006 version of IEC 62304 used a rigid classification model. If software could contribute to a hazard causing serious injury, the entire software system became Class C.
In 2015, Amendment 1 (IEC 62304:2006/AMD 1:2015) revised Clause 4.3 to establish a 2-step classification process.
First, you assess the severity of potential harm assuming no risk controls exist. If the potential harm is serious injury or death, the system starts as Class C.
Second, you evaluate risk control measures implemented external to the software system. These external controls include hardware interlocks, physical barriers, or independent monitoring hardware.
If an external risk control prevents the harm or reduces its severity before patient injury occurs, you classify the software based on the reduced severity.
Consider a service that calculates radiation therapy doses. If a calculation error could cause a lethal radiation overdose, the initial hazard suggests Class C.
Now suppose an independent physical dosimeter on the treatment machine cuts power if radiation output exceeds safe limits. If that external hardware control guarantees that no patient can suffer serious injury, the software drops from Class C to Class B.
External risk controls cannot simply be another subroutine in the same software program. Code within the same unsegregated process cannot serve as its own safety barrier.
What does each safety class require in practice?
IEC 62304 defines software engineering requirements across Clause 5. Your assigned safety class dictates which sub-clauses apply to your project:
| Lifecycle Activity | IEC 62304 Clause | Class A | Class B | Class C |
|---|---|---|---|---|
| Development planning | 5.1 | Required | Required | Required |
| Requirements analysis | 5.2 | Required | Required | Required |
| Architectural design | 5.3 | Exempt | Required | Required |
| Detailed design | 5.4 | Exempt | Exempt | Required |
| Unit verification | 5.5 | Exempt | Exempt* | Required |
| Integration testing | 5.6 | Exempt | Required | Required |
| System testing | 5.7 | Required | Required | Required |
| Software release | 5.8 | Required | Required | Required |
*Note: Class B requires unit implementation and coding standards, but exempts you from formal unit verification protocols before integration.
Understanding these exemptions helps small teams avoid unneeded documentation:
- Class A: Requires only 4 activities: development planning, requirements analysis, system testing, and release procedures. You do not need formal software architecture diagrams, written unit test protocols, or formal integration test reports.
- Class B: Adds architectural design (Clause 5.3) and integration testing (Clause 5.6). You must document component interfaces and prove they communicate reliably. You remain exempt from detailed design specifications (Clause 5.4) and unit verification records (Clause 5.5).
- Class C: Demands the full life cycle without exemptions. Under Clause 5.4, you must write detailed design specifications for every software unit. Under Clause 5.5, you must record unit test verification for boundary conditions, edge cases, and memory limits.
For a small team, Class C documentation creates heavy overhead. Aim to keep your application in Class B whenever clinical risk analysis permits.
Can software segregation keep your system in a lower class?
Under Clause 4.3, all software items inherit the safety class of the highest-classified component by default. If your repository is a single monolith with one Class C algorithm, your entire codebase becomes Class C.
Every storage migration, utility helper, and logging wrapper would require Class C detailed design and unit verification records. That burden can stall a small engineering team.
Clause 5.3.5 provides the solution: software segregation.
You can partition your software system into distinct software items. If you demonstrate effective segregation between items, you can assign different safety classes to different items.
To defend segregation during an audit, you must establish 2 technical controls:
- Functional independence: The lower-class item cannot alter or interrupt the execution of the higher-class item.
- Defensive data boundaries: A crash or corrupted state in the lower-class item cannot cause the higher-class item to fail silently.
In cloud environments, microservices and serverless workers make segregation straightforward. You separate services by process boundaries, network APIs, and isolated containers.
Consider an AI diagnostic platform. The image ingestion service accepts DICOM studies from hospital networks and stores them in cloud storage. The ingestion service performs no clinical interpretation.
If the ingestion service fails, the hospital scanner retries, but no patient receives an erroneous diagnosis. The ingestion service qualifies for Class A.
The downstream inference worker reads the pixel data and detects intracranial hemorrhages. A defect here could delay urgent surgery, making it Class B.
By running the ingestion service and the inference worker in separate containers connected by an HTTP API, you segregate the components. You only maintain Class B documentation for the inference service. For an example of how automated pipelines verify payloads, see how to receive deliveries in your backend.
Software segregation requires architectural discipline. If your Class A ingest service shares memory or local disk storage with your Class B engine, auditors will reject segregation. They will classify the entire codebase as Class B.
How can a small team implement IEC 62304 without enterprise bloat?
Legacy medical device companies use enterprise Application Lifecycle Management (ALM) software that costs thousands of dollars per seat. They hire dedicated compliance staff to route 100-page Word documents for manual signatures.
A small team does not need that bureaucracy. You can satisfy IEC 62304 using standard developer tools.
Requirements and design in Git
Store requirements and architecture documentation directly in your Git repository alongside your application code. Use lightweight Markdown or structured YAML files.
Assign each requirement a stable identifier, such as REQ-014. When an engineer updates software requirements, they submit a pull request. The team reviews the change in Git, and the commit history creates an unchangeable audit trail.
Document your software architecture using Architecture Decision Records (ADRs). ADRs capture design decisions, component boundaries, and interface contracts without maintaining unwieldy specification binders.
Traceability through commit tags and automated tests
Auditors expect traceability: a requirement must link to an architectural item, code implementation, and verification test.
Instead of maintaining brittle spreadsheets, automate traceability in your continuous integration (CI) pipeline. Tag your automated test functions with the requirement IDs they verify.
A small build script can scan your test files, extract requirement tags, and generate a traceability matrix artifact during your build. You can see how this operates in automated environments in our guide to DICOM conformance testing in CI.
Pull requests as verification gates
IEC 62304 requires code evaluation and verification before release. Configure repository branch protection to enforce these quality gates:
- Every code change requires a pull request with at least 1 peer review.
- Automated linters and typecheckers enforce coding standards.
- Automated unit and integration test suites must pass before merging.
When the pull request merges, the review approvals and CI test logs serve as contemporaneous objective evidence of software verification.
Where should your team start today?
Regulatory compliance feels intimidating when treated as an afterthought. Handled early, IEC 62304 fits naturally into modern development workflows.
Take 3 practical steps today:
- Write your intended medical purpose. Define exactly what your software does and what clinical decisions it influences. Your clinical claims establish the hazards you must evaluate.
- Sketch your software system architecture. Identify boundaries between data ingestion, user interfaces, and clinical algorithms. Segregate diagnostic modules into separate services to keep your Class B or Class C footprint as small as possible.
- Add requirement tags to your test suite. Create a simple Markdown file with your first 10 software requirements. Tag your existing automated tests with those identifiers.
Clear boundaries and automated tests let a small team build compliant medical software without sacrificing engineering velocity.
Dicomly builds infrastructure for healthcare software teams that receive DICOM studies from hospitals. Why we built Dicomly →