Month three of a project to build software that reads ECG data from a wearable and flags suspected atrial fibrillation to a cardiologist. The team has a working prototype, an investor who likes the demo and a date for the notified body submission. The regulatory consultant asks for the software architecture with safety classes and the SOUP list. The architecture turns out to be a whiteboard photo, and the arrhythmia detection code shares a process, memory and a database with the chat feature, the sign-up form and the billing screen.
The consultant’s verdict takes one sentence: since nobody can show that a crash in the chat module cannot affect detection, the whole system is class C. Class C means a detailed design down to the unit level, verification of every unit against acceptance criteria and full traceability, including for the sign-up form and the billing screen, which have nothing to do with patient safety.
This article is for CTOs and engineering leads at software as a medical device companies, and for anyone comparing medical device software development services: the teams building software as a medical device (SaMD) or software inside a device. Most writing on the subject describes the rules; this piece describes what they do to a sprint. We already covered the regulatory landscape, interoperability and budgets in our guide to healthcare software development, so this piece goes one level down, into how IEC 62304, ISO 14971, the EU MDR, FDA expectations and IEC 81001-5-1 change a development team’s daily work. The thesis: the cost of IEC 62304 compliance is set by architecture decisions made in the first weeks of a project, not by documentation. Documentation written at the end is the most expensive way to comply, because it locks in a safety class that could have been avoided.
Why is IEC 62304 compliance cost decided in the architecture rather than the documentation?
The popular image of IEC 62304 is a stack of binders: a development plan, a requirements specification, test reports, a traceability matrix. That image leads to a popular strategy. Build the product like any other, then hire a consultant before submission to “write the paperwork”. The strategy fails for a simple reason. The amount of work the standard requires does not depend on how carefully you write documents. It depends on the software safety class of each software item, which depends on which hazardous situations the item can contribute to and whether risk control measures outside the software limit the risk. That, in turn, depends on the architecture.
The standard scales effort by class. Class A means requirements, system testing, configuration management and problem resolution. Class B adds an architecture, unit verification, integration testing and software risk analysis, including risks that come from third-party components. Class C adds a detailed design for every unit, additional unit acceptance criteria and an explicit statement of the segregation needed for risk control. Each obligation applies to every item in that class, in every release, for as long as the product is maintained.
So the most important question in the project is not “who writes the documentation?” but “how much of the code has to be class C?”. If the module whose failure could harm a patient is a fifth of the system and properly segregated, class C obligations apply to that fifth. If it is not segregated, they apply to all of it. Documentation cannot close the gap, because documentation can only describe the architecture that exists.
A competent reader could disagree. Many regulatory advisers start with the quality management system and its procedures and treat architecture as a technical detail. We agree that there is no medical device without a quality system. Our claim is narrower: the quality system describes how the work is done, while the architecture decides how much work there is. Procedures can be fixed in a week. Splitting a monolith into segregated items in year three of maintenance is a project measured in quarters.
What does a development team need from the MDR and FDA rules before writing code?
The team does not need to know all of Regulation (EU) 2017/745 (the MDR) or the US Federal Food, Drug, and Cosmetic Act. A handful of rules affect developers directly. When the device exchanges data with hospital systems, EHR integration over HL7 and FHIR adds its own scope, and remote care brings the requirements covered in telemedicine platform development.
Intended purpose. Software becomes a medical device through the purpose its manufacturer declares: diagnosing, monitoring, predicting or treating a condition in individual patients. The International Medical Device Regulators Forum defines SaMD as software intended for one or more medical purposes that performs them without being part of a hardware medical device. In the EU, guidance MDCG 2019-11, revised in June 2025, walks through qualification and classification. For the team the consequence is practical: any feature added to the backlog can change the intended purpose. “Remind me to take a reading” is not the same as “warn me that my reading is abnormal”. The product owner should be required to involve the regulatory lead in every story that changes what the software tells anyone about a patient’s condition.
MDR Rule 11. Annex VIII of the MDR contains a classification rule written for software. Software that provides information used to take diagnostic or therapeutic decisions is class IIa; class IIb if those decisions could cause a serious deterioration of health or a surgical intervention; class III if they could cause death or an irreversible deterioration. Software that monitors physiological processes is class IIa, or IIb when it monitors vital parameters whose variations could result in immediate danger. All other software is class I. Software that drives or influences a device takes the class of that device. In practice most clinical decision support software needs a notified body. Annex I, section 17.2, also requires software to be developed according to the state of the art, taking into account the development life cycle, risk management including information security, and verification and validation. IEC 62304 is the standard that the industry treats as that state of the art for the life cycle.
FDA pathways and documentation levels. In the US, device software functions reach the market through a 510(k) (substantial equivalence to a predicate), a De Novo request (novel low-to-moderate risk) or a PMA (high risk). In June 2023 the FDA replaced its 2005 software submission guidance with “Content of Premarket Submissions for Device Software Functions”. It drops the old “level of concern” and asks for one of two documentation levels. Enhanced Documentation is expected when a failure or flaw of a device software function could present a hazardous situation with a probable risk of death or serious injury, and the guidance says this risk should be assessed before risk control measures are applied. Enhanced Documentation includes a software design specification and unit and integration test protocols with expected and observed results. For development practices, the FDA accepts a Declaration of Conformity to the FDA-recognized version of IEC 62304.
That last detail matters for teams selling on both sides of the Atlantic. The device class under the MDR (I, IIa, IIb, III), the FDA documentation level (Basic or Enhanced) and the IEC 62304 safety class (A, B, C) are three different things. The MDR class sets the conformity assessment route. The FDA level sets what goes into the submission. The IEC 62304 class sets how much engineering each software item needs. Because the FDA assesses risk before risk controls and IEC 62304 takes external risk controls into account, a module can be class B under IEC 62304 while the US submission still needs Enhanced Documentation. Plan the evidence for the stricter of the two from the start.
How do you assign software safety class A, B or C, and why is “everything in class C” a mistake?
IEC 62304 edition 1.1, the 2006 standard as amended in June 2015, defines three classes. Class A: the software system cannot contribute to a hazardous situation, or it can, but this does not result in unacceptable risk after considering risk control measures external to the software system. Class B: unacceptable risk is possible, but the resulting harm is non-serious injury. Class C: the resulting harm can be death or serious injury.
Amendment 1 rewrote the classification rule so that risk control measures external to the software carry the weight. External does not mean outside the product. It can be a hardware interlock, a mechanical limit, an independent monitoring circuit or a clinical procedure such as mandatory review of a result by a physician. The Johner Institute points out an important consequence: a software component that monitors another component within the same software system can be a perfectly good risk control, but it does not lower that system’s class.
Why do teams put everything in class C? Caution and convenience. Class C needs no justification in front of an auditor, because it is the strictest. It also avoids a conversation with the architect about what can be separated. That is deferring a decision, not being careful. Every release sends the bill: a detailed design of the admin panel, acceptance criteria for the units of the newsletter consent form, change reviews in the finance report module. A team that maintains non-safety code in class C for three years pays for a decision nobody made deliberately.
A workable way to assign classes looks like this. First, the team and the risk management owner go through the hazardous situations in the device risk analysis and, for each one, identify which software items could contribute to it. Next, for each such item, they check whether an external risk control exists and whether it is effective. Finally, they assign classes and record the rationale in the architecture documentation. One assumption is essential: assess on the basis that the software can fail. “This code is simple, so it will not fail” does not pass.
It is also worth knowing where the standard is heading. As of early September 2026, the second edition of IEC 62304 is still a draft. According to the Johner Institute, the IEC working group had to process almost 1,500 comments on the 2025 committee draft and announced a second committee draft rather than a final edition. The IEC forecast pointed to publication in October 2028; the Johner Institute considers 2029 more realistic. The draft replaces classes A/B/C with software process rigour levels, but the principle stays the same: effort follows risk. A team that partitions its system by risk today will be ready for the new edition too.
How does segregating software items lower the cost of every sprint?
The standard allows software items to carry different classes if the manufacturer shows that they are effectively segregated. In class C the team must also identify the segregation needed for risk control and state how its effectiveness is ensured. Segregation is therefore not a statement in a document. It is a property of the architecture that has to be demonstrated.
What counts as effective segregation? The standard gives no catalogue, but the usual arguments are technical and testable:
- Separate processes with memory isolation, rather than modules in one process that an exception anywhere can bring down.
- Separate containers or virtual machines with resource limits, so a memory leak in reporting cannot starve detection.
- A narrow, one-directional interface with input validation on the higher-class side: the critical item does not trust what it receives.
- Separate data stores, or at least separate schemas with permissions, so a billing bug cannot overwrite measurement results.
- Independent deployment, so a new version of a class A item ships without rebuilding the class C item.
Each argument has a cost: more infrastructure, more interfaces to maintain, more latency. It is a genuine trade-off and does not always favour segregation. In a small embedded device with a single microcontroller, separating processes may be impossible, and then putting the whole system in class C is the honest answer. In a cloud application with dozens of non-clinical features, the arithmetic usually favours separation.
How does daily work change? The team on the class A admin panel writes requirements, system tests and change records, but no unit-level detailed design and no formal unit verification. The team on the class C detection module does everything the standard requires, but on a smaller code base and with less risk that a change elsewhere invalidates its verification. Change reviews, impact analysis and re-verification before release cover only what actually touches safety.
Segregation has another benefit that rarely gets mentioned: it makes external teams easier to use. A class A item with a narrow interface can go to a team that is still learning the domain. A class C item needs people who know the manufacturer’s process and have been trained on it. The architectural boundary becomes the boundary of responsibility.
What does the safety class change in a developer’s and tester’s daily work?
The table below simplifies IEC 62304:2006+A1:2015 to a level that helps plan a team’s work. It does not replace reading the standard: individual subclauses have their own class assignments.
| Area of work (clause) | Class A | Class B | Class C |
|---|---|---|---|
| Software development plan (5.1) | Yes, basic scope | Yes, plus integration and integration test planning | Yes, as class B |
| Software requirements (5.2) | Yes | Yes | Yes |
| Architecture and interfaces (5.3) | Not required | Yes, including requirements for SOUP items | Yes, plus explicit segregation for risk control |
| Detailed design of units (5.4) | Not required | Breakdown into units | Design of every unit and its interfaces |
| Unit verification (5.5) | Implementation, no formal verification | Verification process and acceptance criteria | As B, plus additional acceptance criteria |
| Integration and integration testing (5.6) | Not required | Yes | Yes |
| Software system testing (5.7) | Yes | Yes | Yes |
| Software risk analysis and SOUP (7) | Limited | Causes of hazardous situations, including SOUP failures and known anomalies | As class B |
| Configuration management (8) and problem resolution (9) | Yes | Yes | Yes |
Three observations follow for planning. First, the biggest jump is between class A and B, not between B and C. Class B brings in architecture, unit verification, integration testing and software risk analysis; class C adds detailed design and stricter criteria on top. Items that segregation can keep in class A give the largest saving.
Second, configuration management and problem resolution always apply. No class lets a team ship without unambiguous identification of what is in the release, or close a defect without a documented analysis. That is good news: teams with a mature repository, issue tracker and pipeline already have most of this.
Third, unit verification in classes B and C is not the same as unit test coverage. The standard asks for a defined verification process and acceptance criteria, which can include code review, static analysis, unit tests and compliance with a coding standard. Coverage is one possible criterion, not the goal. A team that adopts “80% coverage” for class C with no rationale has chosen a number, not a method. It is better to write down which kinds of defects verification is meant to catch and which techniques catch them.
How should a team manage SOUP: open source and off-the-shelf components?
SOUP, software of unknown provenance, is a software item that already exists and was not developed under an IEC 62304 process: an open source library, a framework, an operating system, a database, a commercial package. A modern medical application has dozens or hundreds of them once transitive dependencies are counted. The standard does not forbid them. It requires the team to know what it uses, why, and with what risk. The FDA takes the same view in its separate guidance on off-the-shelf software in medical devices.
The requirements fit in four points. In all classes, the team identifies each SOUP item by title, manufacturer and unique version designation. In classes B and C, it specifies the functional and performance requirements the item must meet in this particular use, and the hardware and software the item needs to work correctly. In the risk analysis, it treats failure or unexpected behaviour of SOUP as a possible cause of a hazardous situation and evaluates published anomaly lists for safety impact. The maintenance plan describes how the team evaluates and applies upgrades, patches and end-of-support for these items.
The most common mistake is treating the SOUP register as the licence report generated by the package manager. That report satisfies the identification requirement and nothing else. It does not say why the library is used, what would happen if it returned a wrong result, or who reviews its known issues at each release. A useful register records, for every safety-relevant item: its purpose in the system, the architectural item that uses it and that item’s class, the requirements placed on the SOUP, a reference to the risk analysis, the source of its anomaly list and the date of the last evaluation.
Two decisions are worth making at the very start. The first is dependency minimalism in class C items. Every library in a critical module brings requirements to record, an anomaly list to track and a risk to assess at each update. A date-formatting library that a few dozen lines of your own code could replace is not worth that cost in the detection module. The same library in a class A admin panel is a non-issue. The second is automation. A software bill of materials (SBOM) generated by the pipeline on every build provides identification and versions. A vulnerability scanner matches it against known-issue and vulnerability databases. A person only evaluates what changed since the last release and records the conclusion. The same automation pays off again for cybersecurity, as described below.
How do you build ISO 14971 risk management into the team’s backlog?
ISO 14971:2019 describes risk management for the whole device: identifying hazards and hazardous situations, estimating and evaluating risk, risk control, evaluating residual risk and monitoring after the device is on the market. ISO/TR 24971:2020 gives guidance on applying it. IEC 62304 does not create a separate risk process for software; it plugs into the ISO 14971 process and adds software-specific duties. Yet in many companies the risk management file lives in a spreadsheet owned by quality, the backlog lives in the team’s tool, and neither knows about the other.
The consequences are predictable. The team implements a risk control, say a rule that hides a result when the signal quality is too low, but nobody records that this code implements a specific control from the risk analysis. Six months later someone simplifies the logic because “this condition looks redundant”, and the control is gone. Code review misses it, because the reviewer does not know they are looking at a risk control.
The fix is part organisation, part tooling. Each risk control implemented in software becomes a requirement with its own identifier, linked to the risk analysis entry. Stories that implement or change it reference that identifier, and so do the tests that verify it. A change to code linked to a risk control triggers a mandatory review by someone who knows the risk analysis. The definition of done for such stories includes “risk analysis updated or confirmed as current”. It is the principle we described in our piece on the definition of done as a checklist instead of a testing phase: quality built into every story costs less than quality inspected at the end.
The second practice is a risk review in the sprint rhythm rather than before the audit. During backlog refinement the team asks two questions about every new feature: does it create a new hazardous situation, and does it change an existing risk control? “No” takes a minute. “Yes” brings in the risk owner before implementation, not after release. General risk management in IT projects is the starting point, but ISO 14971 changes one thing fundamentally: the risk is to the patient and the user, not to the schedule or the budget.
The third practice covers use errors. IEC 62366-1 requires usability engineering, and use errors are one of the main sources of hazardous situations in medical software. The people designing the interface should know which screens and messages are risk controls, because changing the colour of a warning or the order of buttons may require repeating the usability validation.
How do IEC 62304 sprints and a CI pipeline fit together?
IEC 62304 does not prescribe a life-cycle model. It requires its activities to be performed and documented, but not in any particular order or number of iterations. The AAMI technical report TIR45 explains how to apply the standard in agile development. Our comparison of software development models, including the V-model used in regulated environments, covers the wider context. Here we care about the mechanics.
The condition for combining the standard with sprints is traceability maintained as you go. Each software requirement links to a user need or system requirement, an architectural item, the risk controls it implements, the tests that verify it and the release in which it appeared. If those links are created continuously in the test management tool and the issue tracker, the traceability matrix is a report you generate in one click. If they are rebuilt by hand before release, the team loses weeks and the result is less trustworthy.
In this model the CI pipeline becomes a compliance tool, not just automation. A well-designed CI/CD pipeline for device software records evidence on every build: version identification of every configuration item including SOUP, unit verification results against the acceptance criteria for each class, static analysis results, integration and system test results linked to requirements, and the SBOM. At release the team does not collect evidence; it checks that the pipeline collected it and records the release decision.
Two things need care. The first is tool validation. If a tool’s output (a traceability report generator, a test framework, a scanner) is used as evidence of compliance, the manufacturer’s quality system requires the tool to be validated for its intended use. That does not mean a full computer system validation for every tool. It does mean a documented, risk-proportionate assessment of whether the tool does what you rely on it to do.
The second is release cadence. Continuous deployment in the sense of many production releases a day rarely suits device software, because each release needs a decision, an impact assessment and sometimes a notification or a new submission. Continuous integration and continuous release-readiness fit perfectly, though. A team can run two-week sprints with complete evidence at the end of each and release to users less often, when enough value has accumulated to justify a formal decision. Separating release-readiness from release is the single most useful agile pattern in regulated work. Mature test automation helps, but automation has its own break-even point, which we covered in when test automation stops paying for itself. In device software that point arrives earlier, because every manual regression run also has to be documented.
What does IEC 81001-5-1 add for cybersecurity?
IEC 81001-5-1:2021 describes security activities across the life cycle of health software. It is designed to complement IEC 62304: it follows the same process structure and adds security requirements to it. For a team that knows IEC 62304, it is not a new process but additional activities inside processes that already exist.
What gets added? In planning: how the team runs a secure life cycle, including training and coding standards. In requirements: security requirements derived from a threat model. In architecture: the threat model itself and defence in depth, meaning several independent layers of protection. In implementation: secure coding practices and security-focused code review. In testing: security testing, including penetration testing and testing against malformed input. After release: vulnerability management, a way to receive reports from security researchers and delivery of security updates to users.
In the EU, information security is required directly by sections 17.2 and 17.4 of MDR Annex I, and MDCG 2019-16 (revision 1, July 2020) describes expectations for device cybersecurity. In the US, section 524B of the FD&C Act requires manufacturers of cyber devices to submit a plan to monitor and address vulnerabilities and a software bill of materials covering commercial, open source and off-the-shelf components. Both systems lead to the same place: the SOUP register and the SBOM become one artefact serving both patient safety and information security.
The biggest change for the team is response time. The classic IEC 62304 process assumes that every change goes through impact analysis, verification and a release decision. A critical vulnerability in a network library needs a response in days, not in a quarter. The team therefore needs a fast patch path agreed in advance: a defined re-verification scope for SOUP updates with no functional change, a template for assessing impact on patient safety and criteria for when a patch requires notification or a new submission and when it is ordinary maintenance. Segregation helps again: updating a library in a class A item does not invalidate verification of a class C item.
How do maintenance and post-release change work, especially for AI models?
A medical device does not end at the first release. IEC 62304 defines a maintenance process (clause 6) and a problem resolution process (clause 9) that apply in all classes. Every report from the field, from a user complaint to a post-market surveillance finding, has to be evaluated for safety impact, and every change needs an impact analysis on existing items, classes and risk controls.
The hardest call for the team is telling an ordinary change, handled within the quality system, from one that changes the device enough to need regulatory review. In the EU, the manufacturer of a class IIa or higher device informs its notified body of planned substantial changes to the approved design or intended purpose, and the notified body decides whether further assessment is needed. In the US, the FDA’s guidance on deciding when to submit a 510(k) for a software change plays a similar role. A new intended use, a new diagnostic algorithm or a wider patient population are typical substantial changes; a bug fix that does not change function usually is not. Write these criteria into a procedure instead of debating them every time.
Machine learning adds a separate problem: retraining a model on new data changes the device’s behaviour even when the code has not changed. Two mechanisms address this, one on each side of the Atlantic.
In the US, the FDA finalised its guidance “Marketing Submission Recommendations for a Predetermined Change Control Plan for Artificial Intelligence-Enabled Device Software Functions” on 4 December 2024. A PCCP has three parts: a description of modifications (what will change, for example retraining on new data or extending to a new input device), a modification protocol (how each change will be developed, verified, validated and implemented, including data management and performance criteria) and an impact assessment (benefits and risks of the changes and how they are mitigated). Once the FDA authorises the device with its PCCP, changes made according to the plan do not need a new submission. A PCCP can be included in a 510(k), De Novo or PMA submission, but not in a Special 510(k), and changing the PCCP itself generally needs a new submission.
In the EU, the AI Act (Regulation (EU) 2024/1689) provides in Article 43(4) that changes to a high-risk AI system that the provider pre-determined at the initial conformity assessment and described in the technical documentation do not constitute a substantial modification. AI in medical devices falls under the AI Act’s high-risk rules through Article 6(1); the application date for those obligations was deferred in 2026, as described in the healthcare software development guide mentioned at the start. MDCG 2025-6, published in June 2025, explains how the MDR and the AI Act interact.
For the team, the lesson from both systems is the same: design model change before the first release, not after it. That means versioning training data as carefully as code, defining in advance the metrics and thresholds a new model must meet, keeping a locked test set that is never used for training, building an automated pipeline that produces repeatable evidence from those pieces, and monitoring model performance after release. A team with all of this can describe changes up front and then make them. A team that retrains its model by hand in a notebook turns every model change into a new regulatory project.
How do you work with an external development team under the manufacturer’s quality system?
Many medtech companies do not have enough engineers to build and maintain the product alone and bring in external specialists. That is legitimate, but it shifts responsibilities in ways worth understanding before signing a contract.
The manufacturer is responsible for the device no matter who wrote the code. The MDR places obligations on the manufacturer, and ISO 13485, on which its quality system is usually built, requires supplier controls proportionate to the risk of the purchased product or service. In the US, the Quality Management System Regulation, which took effect on 2 February 2026, incorporates ISO 13485:2016 by reference, so the same logic now applies on both sides of the Atlantic. The external team works as a controlled supplier inside the manufacturer’s quality system. It does not need its own ISO 13485 certificate, although one can make oversight easier. It does need to work to the manufacturer’s procedures: the software development plan, configuration management, problem resolution and reviews.
Several practical rules follow. The repository, issue tracker and test management tool belong to the manufacturer, and external specialists get accounts there. Compliance evidence must not live in the supplier’s tools, which disappear when the contract ends. Training on the manufacturer’s procedures is documented for everyone who touches device code, because an auditor will ask how a developer knows how to perform a change impact analysis. The line of responsibility follows the architectural boundary: an external team can own a whole item of a given class, but risk assessment, classification and the release decision stay with the manufacturer. Turnover has regulatory weight: every change of person means new training and a risk of losing the reasoning behind decisions, so find out how the supplier ensures continuity.
It is the same problem we discussed in who defines quality when you outsource QA: you can contract out the work, but not the responsibility for what “done well” means. In a medical device, that principle is not good practice; it is a legal requirement.
What should you check before engaging a partner? Whether its specialists have worked under a documented process with requirements traceability, whether they understand the difference between safety classes, whether the contract allows participation in the manufacturer’s and the notified body’s audits, and how knowledge transfer works when a person changes. At ARDURA Consulting, the specialist replacement guarantee runs for two weeks and a replacement is provided within five working days; in a regulated project, add the time needed for training on the manufacturer’s procedures.
Which decisions should be made in the first weeks?
The list below orders the decisions that, by our thesis, set the cost of compliance. The order matters: each builds on the one before.
- Intended purpose and device classification. Written down and agreed with the regulatory lead, with the features that implement it, for the EU and, if relevant, the US. Without it, nobody knows which software items matter for safety.
- Initial risk analysis. The hazardous situations the software could contribute to, and the external risk controls that exist or could exist.
- Architecture with segregation boundaries. Which items will be class C, B and A, and the technical mechanism that keeps them apart. This is the decision hardest to change later.
- SOUP policy. Rules for choosing dependencies in each class, SBOM generation in the pipeline and ownership of anomaly-list reviews.
- Traceability tooling. Where requirements, risks, tests and releases live and how they link. Choosing the tool after a year means migrating thousands of links.
- A class-dependent definition of done. What must be complete for a story in a class C item to count as done, and what is enough in a class A item.
- The post-release change path. Criteria for substantial change, a fast security patch path and, for AI products, how planned model changes will be described: a PCCP for the FDA and pre-determined changes in the technical documentation for the EU.
Any of these can be done later. The difference is that, done at the start, they cost a few people a few weeks; done after two years, they can mean re-architecting the system and re-verifying a large part of the code.
What are the key takeaways for a medtech CTO?
IEC 62304, the MDR and FDA expectations do not stop an agile team, but they force decisions that an ordinary project never makes explicitly. The most expensive one is the decision nobody makes: a system that lands entirely in class C because nobody designed the boundaries.
Remember six things. First, the safety class is an architecture decision: effort follows the amount of code in class C, not the quality of your documents. Second, the biggest jump in effort is between class A and B, so items that segregation keeps in class A give the largest saving. Third, the SOUP register is a risk analysis, not a licence list; minimise dependencies in critical items and automate the SBOM. Fourth, risk controls must be visible in the code and the backlog, or someone will eventually delete one as a redundant condition. Fifth, live traceability and a pipeline that collects evidence let you work in sprints without weeks of preparation before each release, and plan for the stricter of the IEC 62304 class and the FDA documentation level. Sixth, post-release change, especially model change, must be designed before the first release.
If you are building a team for medical device software or reorganising your test process around traceability, look at our QA strategy and test management package: fixed scope, two weeks, from €3,700, including TestRail, Xray or Zephyr setup with Jira and CI integration. If you need QA engineers or developers who will work to your procedures, see our staff augmentation services or book a call and tell us where your product is in its life cycle.