ReqLens Academy
A working library for delivery teams. Start with the craft: what each role is accountable for, how to write a requirement someone can actually test, and how to keep scope, coverage and readiness visible from the first conversation to the release note.
Start with your role
Four roles, one set of requirements. Each path covers the craft first and the tooling second.
Product Owner
Owning outcomes: shaping scope, ordering the backlog, and deciding what good enough means.
12 guidesBusiness Analyst
Turning intent into requirements that are specific, testable, and traceable.
12 guidesQA Engineer
Designing coverage that proves the requirement, not just the code, and closing the loop on defects.
12 guidesDelivery Manager
Keeping scope, coverage, and readiness visible so a release date means something.
11 guidesFollow a path
Curated sequences through the library. The order is a suggestion, so you can join one wherever it is useful.
The Business Analyst path
From what the role is accountable for, through writing criteria a team can test, to elaborating and decomposing real requirements in ReqLens.
6 guidesLearning pathThe QA Engineer path
From testing the requirement rather than the build, through designing coverage and running cycles, to closing the loop on defects and traceability.
6 guidesLearning pathThe Product Owner path
From the three decisions only this role can make, through ordering and acceptance, to deciding whether something is genuinely ready to ship.
5 guidesLearning pathThe Delivery Manager path
From why status is not progress, through traceability and readiness, to reporting that a steering group can actually act on.
5 guidesLearning pathThe ReqLens pipeline, end to end
Every stage in order, from a raw requirement through to release reporting. The fastest route to understanding how the whole product fits together.
9 guidesFoundations
What each role actually does, and the shared vocabulary that lets four roles work from one set of requirements.
What a Business Analyst actually does
The Business Analyst turns intent into requirements a team can build and test. The real shape of the role, what it produces, and where it goes wrong.
What a Delivery Manager actually tracks
Status is not progress and a percentage is not evidence. What a Delivery Manager should be tracking, and the signals that are worth escalating early.
What a Product Owner actually owns
The Product Owner decides what is worth building and in what order. Here is what that accountability really covers, and the three ways it gets diluted.
What a QA Engineer actually does
QA is not the last step before release. It is the discipline of deciding what evidence would prove a requirement was met, and gathering it.
Practices
How the work gets done well: writing acceptance criteria, decomposing scope, tracing coverage, and calling a release ready.
A release readiness checklist worth using
Most go or no-go meetings confirm a decision already made. Here is what to check, who decides each item, and the four signals that should stop a release.
A traceability matrix people actually use
Most traceability matrices are compliance artefacts nobody reads. Here is what to link, what to leave out, and how to keep it alive after week three.
How to decompose an epic into user stories
Most decomposition splits by layer or by screen, which produces stories that cannot ship alone. Here is how to slice so every story delivers something.
What a requirements tool must have
A vendor-neutral evaluation guide: the capabilities that separate tooling which improves delivery from tooling that just stores text in a nicer place.
Writing acceptance criteria that hold up
Acceptance criteria fail for predictable reasons. Here is how to write them so a QA Engineer can build coverage without asking you a single clarifying question.
Product
ReqLens itself, one guide per stage of the pipeline, from requirement through to release reporting.
Breaking a requirement into features
How ReqLens finds feature boundaries in a large requirement, why boundary detection and enrichment are separate steps, and what that separation protects.
Connecting Jira and Azure DevOps
What the connectors import, how run results are pushed back as a single maintained comment, and the decisions behind dedupe, credentials, and eligibility.
From requirements to use cases
Use cases expose the paths a requirement implies but does not state. How ReqLens generates them, and why alternate flows are where the value sits.
Generating test cases from requirements
How to turn an elaborated requirement into test coverage you can defend, using TestCraft, and the design principles that make generated coverage trustworthy.
Reporting coverage and traceability
How ReqLens turns pipeline evidence into reports a steering group can act on, and why end-to-end traceability is generated rather than assembled by hand.
Requirement Studio: rough to testable
How elaboration works in ReqLens: what it adds to a raw requirement, why every change needs approval, and how edits propagate to everything downstream.
Running a test cycle: a TestExecute guide
Why blocked is a first-class result rather than a kind of failure, what a run record needs to stay meaningful, and how execution feeds readiness.
Tracking defects across the pipeline
Defects do not only come from testing. How ReqLens tracks where a defect was found, separates severity from priority, and makes rejection reasons useful.
Workspaces, roles and permissions
Three roles, ranked rather than listed, and what each can do. How project access resolves, and why some things belong to the workspace rather than a person.
Browse by topic
Reference
18 guides published so far, with more added regularly.