Table of contents
- What is compliance management?
- Why compliance management looks different for engineering teams
- The parts of a compliance management system
- How compliance management works, step by step
- What compliance evidence looks like in Azure DevOps
- A worked example: one pull request, three standards
- Compliance management vs. GRC, QMS and audit management
- Signs your compliance process has outgrown the spreadsheet
- Running compliance management inside Azure DevOps
- Frequently asked questions
Compliance management is the ongoing work of knowing which requirements apply to you, showing how you meet each one, and keeping the proof current so an auditor can follow it. For engineering and quality teams, the requirements come from standards like ISO 13485, IEC 62304, ISO 27001 or CMMC, and most of the proof is created in the tools where software gets built.
The evidence lives in Azure DevOps: work items, pull requests, pipeline runs, test results but the compliance record doesn’t. For most teams it sits in a spreadsheet with a tab per standard, backed by a shared drive of exported PDFs, and before every audit someone rebuilds the connection between the two by hand.
This guide is written for whoever ends up owning that spreadsheet. That’s usually a quality manager or regulatory lead, plus the engineering managers who get pulled in when an auditor asks for proof.
What is compliance management?
Stripped back, compliance management comes down to three questions. An auditor will ask all of them in some form, and you have to keep answering them as things change:
- What are we required to do? Every standard, regulation, customer requirement and internal policy you’re held to, broken down to the clause.
- How do we meet each requirement? These are your controls: the procedures, reviews, approval steps and tool settings that satisfy a clause.
- Can we prove it right now? That’s your evidence: records showing the controls actually ran, tied back to the requirement they support.
The “keep answering” part is what separates compliance management from an audit. An audit checks a sample of your answers on a particular day. Compliance management is everything you do in between, so the answers are already there when someone asks.
A compliance management system (CMS) is the set of roles, processes, records and tools an organization uses to do this work. The international reference point is ISO 37301:2021, Compliance management systems: Requirements with guidance for use. ISO published it in April 2021 to replace ISO 19600, which was guidance only. ISO 37301 sets requirements, so an organization can be audited and certified against it. It’s deliberately generic and applies to any organization of any size, which also means it won’t tell you how to evidence a design review in Azure DevOps. The rest of this guide is about that part.
Why compliance management looks different for engineering teams
Search for “compliance management” and most of what comes back is written for legal, risk or IT security teams. That kind of compliance covers policies, training sign-offs, ethics hotlines, security controls and regulatory filings. It’s real work, but it isn’t what keeps a medical device software team or a defense supplier busy the week before an audit.
Engineering compliance has a different shape. The requirements are technical clauses, such as IEC 62304 5.7 on software system testing or ISO 13485 7.3.9 on controlling design and development changes. The evidence is work your team already produces: requirements, reviews, code changes, builds, test runs and release approvals. It piles up every sprint, and each release can change which version of it counts.
The standards also overlap. A team building software for a medical device may answer to ISO 13485, IEC 62304 and ISO 14971 at the same time, with ISO 27001 on top, often because customers ask for it. Many of those clauses want the same underlying proof.
Producing evidence is rarely the problem. The trouble starts in the second hour of an audit, when someone asks which build record shows IEC 62304 5.8 was met for release 4.2, and whether that was the build you actually shipped. The answer is often spread across three tools and somebody’s memory.
The parts of a compliance management system
Whatever tool you use, a working compliance management system for an engineering organization has the same seven parts. Here’s what each one means in practice, and where it tends to live in a team that builds in Azure DevOps.
| Part | What it means in practice | Where it often lives today |
|---|---|---|
| Standards and clauses | The exact standards and revisions you’re held to, broken into clauses you can track | PDFs of the standards and a clause list in Excel |
| Applicability | Which clauses apply, with a written reason for each one you exclude | A spreadsheet column, or an ISO 27001 Statement of Applicability |
| Controls | What you do to meet each clause: procedures, review steps, branch policies, approval gates | Wiki pages, SOPs, repo and pipeline settings |
| Evidence | Records showing the controls ran | Work items, pull requests, pipeline runs, test runs, signed documents |
| Assessments | A verdict for each clause, from compliant to non-compliant | The spreadsheet, again |
| Findings and corrective actions | Gaps you’ve found, who owns the fix and when it’s due | Email, a separate tracker, sometimes bugs in Azure Boards |
| Audit calendar | Gap assessments, internal audits, supplier audits, management reviews and certification audits | Someone’s Outlook calendar |
Look at the last column. The evidence and some of the controls already sit in Azure DevOps. The standards, applicability decisions, verdicts and audit calendar mostly don’t, and that split is why the record and the proof drift apart between audits.
How compliance management works, step by step
Most regulated teams run some version of the process below, whether they use spreadsheets or dedicated software. The steps are the same with or without a tool. A tool mostly changes how much of the work you redo before each audit.
1. Pick the standards and the exact revisions you’re held to
Revisions matter more than people expect. ISO 27001:2013 certificates stopped being valid after October 31, 2025, so anyone still mapped to the old Annex A structure has rework to do. In the US, the FDA’s Quality Management System Regulation took effect on February 2, 2026, bringing ISO 13485:2016 into 21 CFR Part 820 by reference. And since November 10, 2025, CMMC requirements can be written into new Department of Defense solicitations and contracts. Your compliance record should show which revision each assessment was made against.
2. Break each standard into clauses you can track
A PDF of a standard can’t hold a verdict, an owner or a link to evidence. Each clause needs to become its own record that you can assess, discuss and report on. Go below the top level, too. Clause 7.3 of ISO 13485 on design and development has ten sub-clauses, and an auditor will ask about them one at a time.
3. Decide what applies, and write down why
Not every requirement applies to every organization or product, although most standards limit what you’re allowed to exclude. Auditors don’t mind justified exclusions. They mind exclusions nobody can explain, and “N/A” with no reasoning is one of the easiest findings to pick up. ISO 27001 formalizes this for its Annex A controls in the Statement of Applicability, but the habit is worth keeping for any standard: every exclusion gets a short, specific justification that carries through to the audit package.
4. Map each control to every clause it satisfies
A branch policy that requires two reviewers and a linked work item on every pull request can support clauses in several standards at once. Map it once, at the control level, and the same evidence serves every clause it touches. Map it separately for each standard and you’ll be maintaining one copy per standard, and they won’t match by the next audit.
5. Link evidence instead of copying it
Screenshots and exported PDFs go stale the moment someone edits the work item. Linking to the artifact keeps the evidence current and lets an auditor see its history. A live link isn’t a controlled record by itself, though, because work items can still be edited after the fact. That’s why step 7 matters. The other catch, covered further down, is making sure the thing you link to still exists when the auditor clicks.
6. Assess each clause, log findings and assign corrective actions
For every applicable clause, record a verdict against the evidence: compliant, partially compliant, non-compliant or not assessed. Gaps become findings with a severity, and each finding gets a corrective action with an owner and a due date that you track to closure. Finding a gap in your own internal audit doesn’t make it any less of a nonconformity. It does mean you close it on your schedule instead of the certification body’s.
7. Freeze the record for the audit, then keep going
When an internal audit or certification visit comes up, you need a snapshot: the clause table, verdicts, evidence index and open findings as they stood on a given date, tied to the revision of the standard you assessed against. Then the work carries on, because next sprint creates new evidence and the next audit is already on the calendar.
What compliance evidence looks like in Azure DevOps
If your team builds in Azure DevOps, most of your evidence is already there. The table shows common artifacts and the kinds of clauses they often support. Use it as a starting point rather than a mapping to copy. Which artifact satisfies which clause depends on your own procedures, and auditors don’t all read clauses the same way.
| Azure DevOps artifact | What it shows | Clauses it often supports |
|---|---|---|
| Work items (requirements, user stories, bugs) and their links | What was planned, what changed and why, and what it traces to | ISO 13485 7.3.3 (design and development inputs); IEC 62304 5.2 (software requirements analysis) and clause 9 (software problem resolution) |
| Pull requests with required reviewers and linked work items | That a change was reviewed and approved before it merged, and what it was for | ISO 27001 A.8.32 (change management); IEC 62304 clause 8 (software configuration management); NIST SP 800-171 3.4.3 (CMMC CM.L2-3.4.3) for infrastructure and configuration repos inside your CMMC scope |
| Pipeline runs and build validation | What was built, from which commit, and whether it passed | IEC 62304 5.6 (software integration and integration testing) and 5.8 (software release) |
| Test plans and test runs | That verification happened, against what, and with what result | ISO 13485 7.3.6 (design and development verification); IEC 62304 5.7 (software system testing); ISO 27001 A.8.29 where security tests are included |
| Wiki pages and linked documents | The procedure you say you follow | Documented-procedure requirements in most standards |
Azure Repos gives you the controls behind the pull request row out of the box. The branch policies “Require a minimum number of reviewers”, “Check for linked work items” and “Build validation” turn a team habit into a rule the tooling checks, so you can show the auditor a policy setting instead of describing a habit. Two settings are worth checking before any audit: who holds the “Bypass policies” permissions, and whether “Allow requestors to approve their own changes” is switched off.
Two Azure DevOps details that trip teams up
Pipeline runs don’t last forever. Azure Pipelines deletes old runs once they pass your project’s retention settings, unless they’re among the recent runs those settings keep or someone has retained them, and a deleted run takes its logs, artifacts, test results and run metadata with it. If your evidence for a release is a link to a pipeline run, retain that run, either with a retention lease or by marking it to be kept indefinitely. Otherwise the link may point at nothing on audit day. Automated test results follow a separate test retention policy, so check that setting too.
The audit log isn’t your compliance record. Azure DevOps auditing is off by default, and events are kept for 90 days once it’s on. It records changes such as permission updates, deleted resources and branch policy edits, which is useful when an auditor asks who changed what. It won’t tell anyone whether a clause is met. If you need those events for longer than 90 days, stream them to your SIEM.
A worked example: one pull request, three standards
Here’s how control mapping plays out on a single change. Say your team builds medical device software that also runs as a cloud service, so you’re certified to ISO 13485 and ISO 27001 and follow IEC 62304 for the software lifecycle.
A tester logs a bug in Azure Boards against a released version. A developer fixes it on a branch and opens a pull request. Your branch policy requires two reviewers and a linked work item, so the pull request can’t complete until both reviewers approve and the bug is attached. Build validation runs the pipeline against the change. Before the fix is released, a tester reruns the affected regression tests in Azure Test Plans against the new build and records the result.
That one chain of records supports at least five clauses and controls across three standards:
- IEC 62304 clauses 6 and 9, software maintenance and software problem resolution: the problem report against the released version, its investigation and its fix are on record.
- IEC 62304 clause 8, software configuration management: the change is identified, controlled and traceable to a specific commit and build.
- ISO 13485 7.3.9, control of design and development changes: the change was reviewed, verified and approved before release. The clause also expects an assessment of the change’s effect on the product and its risks, so record that too, on the bug or a linked change request.
- ISO 27001 A.8.32, change management: the change went through a defined, authorized process, and the records were kept.
In a spreadsheet, you’d paste the same handful of links into three tabs and keep all three current by hand. Map the control once, link the evidence to it, and those records show up everywhere they’re needed. Teams with one standard rarely bother with it. The pain starts with the second.
Compliance management vs. GRC, QMS and audit management
These terms get used interchangeably, but they cover different ground.
| Term | What it focuses on | Where engineering evidence fits |
|---|---|---|
| Compliance management | Meeting obligations and proving it, continuously, across every standard you’re held to | At the center: evidence is linked to the clauses it supports |
| GRC and security compliance platforms | Security and privacy frameworks such as SOC 2 and ISO 27001, with evidence from cloud, identity and HR systems | Typically code repository and access settings, collected for security controls |
| Quality management system (QMS) | The quality system as a whole: document control, training, supplier management, CAPA | Often managed in a separate system from engineering tools |
| Audit management | Planning and running audits, and recording what they find | Gathered when an audit is coming up |
Plenty of companies need more than one of these. For an engineering team, the more useful question is whether the compliance record sits anywhere near the place where the evidence is created. In a lot of Azure DevOps shops, it’s still an Excel file on SharePoint.
Signs your compliance process has outgrown the spreadsheet
Spreadsheets are a reasonable way to start, and plenty of audits have been passed with one. They stop working at a fairly predictable point. You’ve probably hit it if:
- Every audit starts with someone rebuilding the tracker from last year’s copy.
- Links in the tracker lead to pipeline runs that no longer exist, or to work items that have changed since they were linked.
- The same evidence sits in more than one tab because two standards ask for it.
- Nobody can say how many clauses have been assessed without opening the file and counting.
- A new revision of a standard means starting a new spreadsheet.
- Findings from the last internal audit are in someone’s inbox.
Running compliance management inside Azure DevOps
Compliance4DevOps is a compliance management extension for Azure DevOps from Modern Requirements. It keeps the compliance record in the same Azure DevOps organization as the evidence it points to.
You load a standard from the Modern Requirements library or from your own licensed copy, and each clause becomes a record you can track. You record applicability clause by clause, and anything marked not applicable needs a written justification. Controls are mapped once to every clause they satisfy across standards. Evidence is linked from work items, test runs, pipeline runs and pull requests where they already are, so nothing is copied out of Azure DevOps.
Assessments use four verdicts: Compliant, Partially compliant, Non-compliant and Not assessed. Findings carry a severity, and corrective actions get an owner and a due date. A single timeline shows gap assessments, internal audits, supplier audits, management reviews and certification events, so you can see what has to be ready before each one. When an audit comes up, one action on the compliance event generates the audit package: a PDF with a cover page, document control, clause table, evidence index and findings, locked to a point in time and bound to the revision of the standard.
AI assistance can parse a standard into clauses, propose scope and control matches, draft verdicts and flag gaps. Each suggestion shows its confidence, and nothing goes on the record until a person approves it.
Supported frameworks include ISO 13485, IEC 62304, ISO 14971, 21 CFR Part 11, EU MDR, CMMC, NIST SP 800-171, ISO 26262, ASPICE, ISO 27001 and SOC 2, as well as your own internal policies. If your team also uses Modern Requirements4DevOps, traceability, reviews with e-signatures and Smart Docs can serve as evidence too.
See how the platform works, start a 30-day free trial in your own Azure DevOps organization with no credit card, or book a demo to see it against the standards you’re audited to.
Frequently asked questions
What is compliance management in simple terms?
It’s the day-to-day work of tracking what you’re required to comply with, how you comply, and the records that prove it. For engineering teams, that means standards like ISO 13485 or ISO 27001 mapped to the work items, tests and builds that show each requirement is met.
What is the difference between compliance management and a compliance management system?
Compliance management is the practice. A compliance management system is the set of roles, processes, records and tools an organization uses to carry it out. ISO 37301:2021 is the international standard that sets requirements for a compliance management system.
What are the main parts of a compliance management system?
For an engineering organization, a compliance management system covers seven parts: the standards and clauses you’re held to, applicability decisions, controls, evidence, clause-level assessments, findings with corrective actions, and an audit calendar. Most teams struggle less with any single part than with keeping them connected.
How is compliance management different from an audit?
An audit checks a sample of your compliance on a particular day, usually by someone independent of the work. Compliance management is the continuous work of meeting requirements and keeping evidence current, so audits confirm what you already know instead of turning up surprises.
Can you manage compliance in Azure DevOps?
Yes. Azure DevOps already holds much of the evidence regulated teams need, including work items, pull requests, pipeline runs and test results. What it doesn’t have natively is a compliance record: standards broken into clauses, applicability, verdicts, findings and audit packages. Extensions such as Compliance4DevOps add that layer inside Azure DevOps.
What counts as compliance evidence in Azure DevOps?
Common evidence includes linked work items that show requirements and changes, pull requests with required reviewers, pipeline runs and build validation results, and test runs from Azure Test Plans. Which artifact supports which clause depends on your documented process. Retain any pipeline runs you rely on, because expired runs are deleted along with their logs and artifacts.
Is a spreadsheet enough for compliance management?
For one standard and a small team, a spreadsheet can work. It tends to break down when you manage several overlapping standards, need evidence links that stay current, or spend days before each audit rebuilding the tracker. At that point, a tool that connects the record to the evidence saves real time.
Your next audit package is already in Azure DevOps.
Bring a real Azure DevOps project and we'll build an audit package from it, live: every verdict linked to its proof, every gap flagged.
