Webinar Transcript

The Record Behind Every Requirement

With Morgan Kostal, Customer Success Manager  ·  Martin Fay, Product Manager

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.

Watch the Recording

Section 1 — Welcome & Today's Question

Lead: Morgan [0:05]

Morgan

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.

Morgan

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.

Morgan

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.

Morgan

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.

Morgan

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.

Morgan

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.

Morgan

So Martin, why should the requirements be part of that diagnosis?

Section 2 — Why the Record Matters Now

Lead: Martin and Morgan [3:18]

Martin

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.

Morgan

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?

Martin

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%.

Morgan

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?

Martin

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.

Martin

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.

Martin

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]

Morgan

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.

Morgan

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?

Martin

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]

Morgan

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."

Morgan

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.

Morgan

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.

Morgan

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.

Morgan

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."

Morgan

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.

Morgan

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.

Morgan

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.

Morgan

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.

Morgan

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.

Morgan

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.

Morgan

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.

Martin

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]

Morgan

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.

Morgan

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.

Morgan

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.

Martin

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.

Morgan

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.

Martin

That came straight from program leads. They didn't want to see everything. They wanted to know where to look first.

Morgan

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.

Morgan

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.

Morgan

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.

Martin

Surprising.

Morgan

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.

Morgan

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.

Martin

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]

Morgan

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.

Morgan

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.

Morgan

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.

Martin

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.

Morgan

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.

Morgan

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]

Martin

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.

Martin

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.

Martin

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.

Morgan

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.

Martin

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.

Morgan

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."

Martin

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.

Martin

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.

Morgan

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.

Martin

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]

Morgan

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.

Morgan

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?

Martin

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.

Morgan

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.

Martin

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.

Morgan

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.

Morgan

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]

Question 1How far back can the history go? What if we only connected a project today?
Martin

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.

Morgan

Which is why, like I said, you should connect your projects early, so the history is running before the gate matters, not after it.

Question 2Polarion and DOORS already keep version history. How is this different?
Morgan

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.

Martin

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.

Question 3Our requirements tools now have AI quality checking built in. Why add QRA?
Morgan

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.

Martin

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.

Question 4Can we hand this to an auditor? Is there an export option?
Martin

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.

Morgan

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.

Question 5Can it tell us which requirements were written by AI?
Martin

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.

Morgan

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.