Webinar Transcript
The Record Behind Every Requirement
Something has gone wrong, or someone thinks it might have. An auditor asks why a requirement says what it says. Can you answer in a few minutes, or does the team start digging through old emails?
In this session, Morgan Kostal and Martin Fay show how the QRA Platform keeps the record behind every requirement while the work happens. They cover why baselines and traceability alone fall short, a live demo of QVscribe and ReqWriter in Polarion, the new project view, the full history of a single requirement, and what's coming next on the platform. Full transcript below.
Prefer to watch?
The full recording runs about 36 minutes, including the live demo and audience Q&A.
Section 1 — Welcome & Today's Question
Lead: Morgan [0:05]
Hi everyone, thank you so much for taking the time to join us live today, or for watching the recording on demand afterwards. If you've joined one of our webinars before, you're probably familiar with my motto: check yourself before you wreck yourself. And today is exactly about what happens when nobody actually did that.
My name is Morgan Kostal. I'm your friendly neighborhood Customer Success Manager, and I help teams get the most out of QVscribe and the QRA Platform by giving them the building blocks for success: training, webinars like these, and ongoing guidance. Over the past few years, I've seen firsthand how QVscribe helps teams spot clarity issues, standardize language, and build stronger, more testable requirements. And I see a lot of what happens to those requirements after they're written.
With me today is Martin Fay, our awesome Product Manager. He oversees our full product line to make sure our tools actually solve real-world problems. He works closely with our customers to turn their feedback into practical improvements, helping teams work smarter, reduce errors, and see measurable results.
For anyone new to QRA, we're based in beautiful Halifax, Nova Scotia, and we build requirements quality tools for engineering teams in regulated industries like aerospace and defense and medical devices. If you're new to QVscribe, it's a tool designed to help teams reduce communication risks, improve the overall clarity and quality of requirements, and ensure consistency across projects. And today we're taking everything a step further: from checking the requirement to keeping the record behind it.
Here's a quick plan of what we'll go through today. We'll start with why the record behind the requirement matters so much right now. Then I'll show you how the QRA Platform helps keep that record. We'll check a requirement, let ReqWriter suggest a rewrite, look at the new project-level dashboards, and then open up the requirement's history. Martin will wrap things up with a bit of what comes next for the QRA Platform, and then we've got about ten minutes at the end for questions. So whether you're already using QVscribe today or this is your first look at QRA, I hope you leave today's webinar with something you can try on your own requirements this week.
So today is about one specific moment. Something's gone wrong, or someone thinks it might have. Maybe it's an audit finding, or a supplier telling you the spec they signed up for doesn't say what it says now. And in my experience, the requirements are rarely where anyone starts to look first. When someone does finally ask about them, it can be months later. The person who made that change has moved on to another program, and the team starts digging through all of the emails to try to find a record. And let's be honest: if the answer lives in someone's inbox, it's not really a record.
So Martin, why should the requirements be part of that diagnosis?
Section 2 — Why the Record Matters Now
Lead: Martin and Morgan [3:18]
Because that's often where the problem started. NASA funded a study of safety-critical defects in spacecraft software, and one major contributor stood out: errors going way back to the requirements. Studies in other regulated industries have found much the same thing.
And we see the same thing with our own customers. Finding it late is super expensive. One of the aerospace teams we work with actually measured it: catching a problem at the requirement stage took them from 40 hours per fix down to just one. Martin, we've been writing a lot about this in what we're calling the Requirements Operating Model. What's changed?
Mostly, where the hard part is. With generative AI, getting a draft is easy. Getting a draft that holds up in an audit, not so easy. So running faster with AI, without a way to check the output, builds a big backlog that someone will have to defend eventually. You can see that already with software. Researchers at Harvard followed engineering teams at about 700 companies as they adopted AI coding agents. And yes, engineers wrote 30% more code. Review time went up by almost 50%.
And I see that all the time with the accounts I work with. More requirements are starting to come in, and the number of people who can review them hasn't changed. The senior engineers are now picking up all of that slack. When the writing gets cheap, the cost moves to whoever has to sign off on it. Now, a lot of you here today probably have baselines and traceability in place. Martin, why isn't that enough?
Baselines and traceability show you what the text was. They can't really show you whether it met your team's rules at that moment, or why it changed. So a requirement can have perfect provenance and still be wrong.
And even the trace is hard to stand behind. One medical device customer told us they had people spending literally weeks doing manual tracing, to show that they really did test all the requirements, and they missed some. Weeks of effort, and there were still gaps in the record.
Finally, consider who reads that record last. In regulated environments, it's usually an auditor or a certifier, someone who was never in the room. So the true test is: could you hand that requirement to someone with no context, and would it still hold up?
Section 3 — Snapshots and the Full History
Lead: Morgan and Martin [6:09]
That right there is exactly what we want to show you today. A lot of what we covered comes from the Requirements Operating Model, which I've mentioned a few times. We'll send an email next week with this recording and a couple of links, including one to the Requirements Operating Model.
Before we jump into the exciting demo part, I want to be upfront about what you're about to see. This is in preview. It's a pre-release build with some sample data, so it might look a little different by the time it's available to you. We're showing it now because this is when your feedback can still shape it. As you watch, think about what you'd need this to show an auditor or a customer, and drop it in the chat. You can also email us afterwards. Martin, how does all of this build on what teams are already doing?
A lot of teams are already using Snapshots to mark the moments they plan for, like a gate review or a release. The question we kept getting, especially from team leads, went further: what did a requirement say on any given day, or before a given change, whether or not anyone actually took a snapshot? So the history now spans every version, and your snapshots become milestones on that history. Snapshots cover the moments you planned for, and the history covers all the ones you didn't.
Section 4 — Live Demo: Checking and Rewriting a Requirement in Polarion
Lead: Morgan, Martin adds [7:37]
Snapshots and Timelines have been a real hit with the teams I've worked with so far, especially around those review gates. And what they keep asking for, very similar to what you said, is the whole trend, not just the gates. One medical device team I work with said it better than I could: "not just single moments in time, but trends over time."
I'm going to switch over to Polarion for the live demo. I have a smart doorbell system specification with 50 requirements in it. If you use QVscribe today, a lot of this will look familiar, so I apologize if I repeat some things you already know. If you're new to it, QVscribe is built right into your requirements management tool. It checks each requirement on its own, and the document as a whole, against the rules your team sets out.
Let's start with what we call the summary view. As the name suggests, it's a summary of everything QVscribe has found. It gives a score for the whole set, as well as the average across the set. If you're familiar with the INCOSE Guide for Writing Requirements, a lot of these will look familiar, like non-specific temporal words and cross-referencing pronouns. All of this is interactive, so you can click in to dive deeper.
Every requirement gets a score from one to five. One means there are critical issues to fix, and five means you're good to go: take a quick look to make sure the content is still correct, but based on your rules, everything is looking good. If you've been to one of my trainings, you know I like to call this a traffic light. Red means stop, you need to fix some things. Green means go, move on to the next thing that needs your attention. We also have quality warnings in the mix, things like passive voice and universal quantifiers. These don't count toward the score. Think of them as an FYI to make sure they're being used correctly.
So where do I start? I always like to start with the one-out-of-fives, because those are the ones to prioritize. I can click in and see the list of all the one-out-of-fives in this document, and pick which ones I want to improve. I'm going to pick requirement 742. It says: "Where the infrared camera is equipped, the infrared blaster range shall measure 15 feet, and the infrared signal shall reach visitors that are the typical distance from the smart doorbell."
There's a lot on this screen, so I'll walk you through it. Everything in red is what's pulling down the score. We have two shalls here, and we also have a vague word, "typical." The orange isn't pulling down the score; it's a warning. We also check against EARS, the Easy Approach to Requirements Syntax, one of the most commonly followed syntax patterns among engineering teams. Right now this has been detected as an optional-feature requirement, but it isn't compliant in its current state.
If I open a card, you can see the words getting highlighted to draw your attention to what needs to be fixed. You get incorrect and correct examples, and there's a Learn More button that explains the problem type and possible exceptions. That's really great, because it's a bit of a training tool built into QVscribe. It's really helpful for anyone not super familiar with these problem types or the INCOSE guide, or for junior engineers.
Now, we could use all of this to rewrite the requirement ourselves. But you might have noticed something when I opened it up at the beginning. It's called ReqWriter. It took everything QVscribe found and suggested an improvement. Here it says: try splitting this requirement into singular statements to improve understanding. So we've gone from a score of one out of five to one requirement with a five out of five and one with a three out of five. That's because the tricky word "typical" is still there, and we're not going to guess what you think typical is. You have to go back to your team and figure that out.
So I'll copy these and put them into the document. (Love a live demo: it copied twice, so let me try that again.) There we go. We now have the five out of five that we edited, and we still have the three out of five, because when I open the authoring view, that tricky "typical" is still there.
Let's do another quicker one and open requirement 553 in the authoring view. This one is also a one out of five, but ReqWriter has already run on it, and now we have a five out of five. I'll copy and paste it right in, and we've gone to a five out of five. I'll close everything out and save.
The great thing with both of those examples is that it didn't invent a value that wasn't already there. We saw 15 feet in one of those requirements, and it retained that. Where a value was missing, it put in a placeholder so you can go back to the team and decide what timing or measurement you actually want. That's one thing I really love: the final decision is in your hands. As you get suggestions from ReqWriter, you can copy, decline, or rerun. We're just helping to make the path a little quicker.
It's a really good example of how ReqWriter and QVscribe split up the work. ReqWriter writes, and QVscribe does the judging. You won't get a rewrite back that scores lower than where you started. One medical device engineer put it really well: you need the part that generates the requirement and the judge to measure the quality, and those should be two different things.
And that separation is deliberate. The tool that writes a requirement should not also be the one that certifies it, which is why ReqWriter and QVscribe operate independently. ReqWriter suggests a requirement. QVscribe judges that suggestion objectively and deterministically. So whether a requirement came from an engineer, a supplier, or an AI copilot, it goes through the same check. The source can vary, but the standard does not.
Section 5 — The Project View in the QRA Platform
Lead: Morgan, Martin adds [15:10]
And to be clear, the check tells you whether the requirement meets your team's rules as set up in the configuration. It's not going to tell you whether the signal should reach 10 feet or 20 feet. That's still the job of your team and peer review.
Now that we've made some changes in Polarion, let's hop over to the QRA Platform. If you've already been working in the dashboard, this should look pretty similar to what you're used to. The addition is this Projects section. We have it set up for Polarion right now. You might see DOORS as well, but I'm going to stick with Polarion for today.
Each project tile gives you a quick read on what's changed recently: how many documents are in the project and how many people have been contributing. There's a small trend line that tells you whether things are improving or declining, and a histogram of the quality score distribution, very similar to what you'd be familiar with in the summary view. So you have a quick overview of all these different projects and how they're doing.
And looking at the histogram, you should read the spread, not just the average. Two documents might both average 3.5, but one of them might be hiding a cluster of ones.
And that cluster of ones is really where gate reviews tend to go sideways. If I open up a project, I get every document within it, each with that same summary, and different ways to look at them. I've started with the card view, but there's also a structure view and a table view. I like to compare these to the detail view in File Explorer, where you can see all the little details about each document. Personally, I prefer the card view because it's more visual for me. It also puts the documents with the most recent changes first, and you can drag things around to customize the view.
That came straight from program leads. They didn't want to see everything. They wanted to know where to look first.
Exactly. And a lot of our customers are asking for this. One defense team described wanting an analysis layer over everything, showing how things are scoring across different projects and different teams.
Let's open the document I was just working in, the smart doorbell spec, now from the project side. Up top is the overall quality and how the average has changed over time, starting from when the continuous history begins for the document. Over here should look familiar: this is the quality score distribution at this point in time. You'll recognize it if you've seen the summary view we just showed in Polarion, with the average score here as well. So it adds another layer to the information you get when working in QVscribe.
Underneath, we can see what's changed in this version, between the last version and this one. These are actually the edits I made a few minutes ago.
Surprising.
So we see that requirements 549 and 543 were edited and their quality scores changed. We've also added a requirement and removed one, so we've made quite a few changes, and down here we have the record of who made them. So you have that quick overview of the score, the distribution, and what's changed since last time.
Now, the big piece is the ability to compare to different dates. I can look at other versions specifically, but I can also compare to a certain date. Let's say our last review was on October 1. The chart marks that date, and the histogram shows how things have shifted since then: how much the average score has moved, how many more requirements are showing a five. I get a clear comparison, and I can remove the date or choose a different one quite easily. Here we see the score has gone down, but we've also added a bunch more requirements, 18 of them. So it shows the details and nuances behind the scores.
And that all works because the check is deterministic. The same text against the same rules gets the same result every time. If you had a judgment that changed with every run, that would effectively be an opinion, and you can't file an opinion as evidence. So the timeline holds every past version to today's configuration, and you can compare like with like, apples to apples. And the snapshot keeps the result as it stood that day. That's a record you could file for an audit.
Section 6 — One Requirement's Full History
Lead: Morgan, Martin adds [20:28]
Exactly. Let's take a quick look at the individual requirements. There are a bunch of ways to filter this. You can sort by quality score, so you see the low-scoring ones first. The new thing is sorting by edits, so you can see how many times a requirement has been edited. Maybe a requirement has a score of five, but it's had three edits. That probably still needs another look. We can go in and see the history, and how volatile it has been over time.
I'll open requirement 553, with all of these edits. On the left is every version since the history began, and I'll compare today's version with an older one from September 22. The original draft had a one out of five, with three alerts and one warning. The new one has a five out of five, with those edits done pretty recently, by me. And the findings show why. We can see what's been cleared, like the missing imperative and the non-specific temporal word "quickly." The passive voice is still there, but that's a warning, not an alert.
That's the answer to the question we started this webinar with. Why does that requirement say that? It's all right here, the whole history.
The redline shows what changed, and the findings show which rules the old text missed. By itself, a redline is just history. Combine it with findings, and now you have evidence. And as a quick aside, support for keeping flagged wording on purpose, with the reason recorded, is coming next. More on that shortly.
You can also see who drafted it and who has edited it since. These are both me, so not a great example, but you'd be able to see the history of who's touched it. The names are there, so if an auditor asks about a requirement, that's a few minutes of looking instead of an afternoon.
One last thing before I pass it back to Martin: you can't edit requirements here. You open them in Polarion so you can keep working with QVscribe as you do today. You can open the specific requirement in Polarion, which takes you directly to it, or open the whole document. That's exactly what I did a few minutes ago: I opened it, made some changes, and all of those changes were pushed to the project dashboard as evidence going forward. So Martin, where does this all go from here?
Section 7 — What's Next for the QRA Platform
Lead: Martin, Morgan adds [23:17]
Maybe just as a foundational statement: because everything comes from your requirements tool, the record builds itself as the work happens. There's nothing to export, nothing to upload, and no snapshot required. Today, that's with Polarion. Jama follows later this year, and DOORS Next after that. Your requirements tool remains the system of record. The QRA Platform keeps the record behind it.
That record is also what the next round of QRA Platform updates builds on. Much of what we'll show was inspired by challenges customers described to us. The first builds on what Morgan just showed you. Today you can sort by the number of edits to find the requirements that keep changing. Soon the platform will flag those for you: the most volatile requirements in a document and the most volatile documents in a project, so you can see where the wording is still shifting before a gate, without having to hunt for it.
Next, you'll be able to accept a requirement as-is. Some requirements are not going to change. Maybe they came from the customer, or they're legacy text you don't have the authority to change. If those requirements have low scores, they can distract from the requirements you can fix. Accepting them as-is records that decision along with the rationale, and excludes those scores from the summary statistics. The score is grayed out but still visible. Accepted, but not forgotten. And if the text changes later, the acceptance resets, and the requirement gets the fresh review it warrants.
And this one is going to make a lot of people happy, because keeping the text is sometimes the right engineering call. QVscribe might flag two different terms as inconsistent, but one defense engineer told us they were using those two words specifically, for a reason. That decision deserves a place in the record, too.
Alongside that, we're working on quality benchmarks, so your team can measure a document against a bar it agrees on. Review readiness becomes an objective threshold, not just a feeling, and the team can be notified the moment a document meets that threshold.
And that's exactly where one of my automotive teams is heading. They're making the check part of their review. In their words: "We would require a certain score so the review can pass."
That's the idea. The bar belongs to the team, and the record shows whether a document cleared it. And when the next review comes around, the record will hold your review points, so you can see which requirements changed since the last review, and in which direction. Reviewers can focus on the updates that most need their attention, without rereading what has already been reviewed.
Further out, we're exploring what the record can tell you about a whole requirement set: how quality is trending across a program, and where requirements contradict or duplicate each other, whether within a document or across an entire project.
That's the one leadership asks me about the most. One customer told us their quality dashboards give management an early warning, right from the start of a project.
These pieces are still taking shape, and feedback is always welcome. What helps us most is hearing where the work gets stuck: the review that keeps slipping, the audit question that takes a week to answer, the requirement no one wants to touch. Drop that in the chat or reach out directly to Morgan or me. Customer feedback is how most of what you saw today started.
Section 8 — Wrap-Up & Key Takeaways
Lead: Morgan, Martin closes [27:36]
All right, to wrap things up: getting requirements written faster is the easy part now. Being able to defend them is where there's still a lot of work. If you only take three things away from today, I'd make it these.
The first is that the record is more than just text. It's what a requirement said, how it scored, who drafted it, edited it, and approved it, and why it changed in the first place. That's what lets you answer "why does it say that?" in a few minutes, instead of digging through old emails. Martin, do you want to take the second one?
Sure. Keep the writer and the judge separate. Whatever writes the requirement, whether that's ReqWriter, a supplier, or an AI copilot, the check should be its own thing. That's how you know every requirement was held to the same standard.
Perfect. And the last one: build the record as you go. The history starts when a project is connected, so the sooner you connect, the more you'll have to show at your next gate.
Which brings us back to where we started. Baselines and traceability are not enough on their own. Traceability tells you where a requirement goes. The record behind it tells you how it got there.
And here's something to try this week. Pick one requirement from your last review and see if you can pull up what it said on that day, who changed it since, and why. If that takes more than a few minutes to find, you're not alone, and that's exactly the gap this record fills. It helps everyone on the team. If you're writing requirements, your fixes show up in the history, so you get credit for them. If you're on the quality side, you can answer "why does this say that?" before anyone even asks.
If you're already on the QRA Platform, my one piece of advice is to get your projects connected now and start seeing the impact. If you're on QTS, reach out to me about the move to the QRA Platform. And if you're new to QRA, I highly recommend starting with the Requirements Operating Model we've mentioned a few times. Chapter 4 is coming out later this month, so that's exciting. Our sales team would also be more than happy to chat with you and run QVscribe on one of your own documents.
Audience Q&A
Moderated by Yana [30:14]
I'll start. The short answer is that every version from the day your project is connected will be captured. You saw that marked on the chart, where it said "continuous history begins." That said, history from before that point is possible too, depending on what your requirements management tool has kept. Talk to us to find out more about that.
Which is why, like I said, you should connect your projects early, so the history is running before the gate matters, not after it.
I can take this one. They do, and you should keep using it. Polarion or DOORS serves as your system of record; it keeps the text. What this adds is how each version scored, and against what. The evidence behind the history.
Version history tells you that a requirement changed. The record tells you whether that change was an improvement, and by what yardstick, by what standard.
Those checks can be useful, and you should use whatever helps your team. But the question to ask of any check is whether it gives the same result on the same text every time, and whether it's separate from whatever wrote the text. QVscribe's check is deterministic, as we've said, and it runs independently of the generation piece. So a score means exactly the same thing whichever day you run it, and whichever tool the requirement lives in. That's what makes it something you can file as evidence, and it's why you'd add QRA.
And if your team or your suppliers work in more than one tool, you still get one standard across all the tools we connect to, rather than a different check in each.
Not from these views yet. That's one of the things this preview is helping to shape. The underlying scores are also available through the QVscribe API, and some teams feed them into their own quality dashboards.
I've definitely seen teams do that and bring the scores into their own dashboards. But if you have a specific format in mind, that's exactly the input we asked for earlier. Let us know, because it helps us shape this to match your needs.
It records who made each change; you saw that on each version Morgan showed. It doesn't try to detect whether the text was AI-generated. That kind of detection isn't reliable enough to file as evidence. But as we underlined earlier, the source can vary, and the standard does not. That stays consistent and deterministic.
I think that's key. Talking to teams, a lot of them are writing policies right now about who can even accept AI suggestions. This gives that policy something to stand on, because the record shows what the accepted text was checked against.
This is a near-verbatim transcript prepared from the session recording, lightly edited for readability (filler words and false starts removed). Questions were read aloud by the moderator during the live session and are shown in summarized form. Timestamps refer to the on-demand recording and are approximate.