Introduction
Download the Manual as PDF — the printable book version, regenerated at every release (FR-17.7).
REQQA — Requirements Quality Assurance with AI — is a multi-tenant web application for managing software requirements and applying AI-driven analysis to them. It helps teams capture what a system should do, then uses a structured analysis technique (DeFOSPAM) to find the faults, ambiguities, and omissions in those requirements before they become expensive to fix downstream.
This Manual is the conceptual reference: what REQQA is, how it thinks about requirements, and why it is built the way it is. It explains the model and the reasoning behind it. When you need to do something — add a requirement, run an analysis, generate stories — turn to the How-To section instead. If you are brand new, start with Welcome.
This Manual is also the document that PDF export (FR-17.7) renders into a single downloadable file. Chapters here are ordered by their sidebar_position, and that order is the chapter order in the printed book. The PDF is regenerated at every release so the printable version stays in step with the site.
What REQQA is
At its core REQQA does two things, and the second is what makes it more than a requirements register:
- It manages requirements. Each organisation keeps a structured, versioned set of requirements — organised under applications, anchored to a mission, and elaborated into user stories and features. Every change is audited.
- It analyses them with AI. REQQA applies the DeFOSPAM technique — its method for analysing requirements and Gherkin stories and finding faults — to surface issues such as ambiguity, missing detail, untestable wording, and inconsistency. The findings feed a synthesis loop that rewrites the requirement to address them.
REQQA is multi-tenant: everything you see and do is scoped to your organisation. Your requirements, applications, glossary, and analysis results are isolated from every other tenant. It is built on the py4web framework, with AI calls made through configurable models (GPT-family by default) on a per-organisation basis.
The conceptual model at a glance
REQQA arranges everything in a hierarchy, and context flows downward through it:
Organisation → Application → Mission → Requirements → Features → Stories
- Organisation — your tenant. It holds your members, your AI configuration, and everything below. See Access and onboarding.
- Application — a product or system you are specifying. An organisation can hold several. See Your first application.
- Mission — the application's mission statement: its purpose, scope, stakeholders, operational concept, scenarios, assumptions, and constraints. This is the top of the requirements hierarchy — every requirement and story below inherits its context, and the AI reads it to understand what the application is for. See The mission.
- Requirements — the structured, versioned statements of what the application must do. Each has a change history. This is where DeFOSPAM analysis is applied. See Requirements.
- Features and stories — requirements are elaborated into features and user stories (typically Gherkin), which can themselves be analysed and which feed the build. See Stories and features.
Two further objects cut across this hierarchy:
- The glossary — shared definitions and a term index that keep vocabulary consistent across requirements and stories. See The glossary.
- Releases (scopes) — a Release groups the requirements and stories targeted for delivery together, and carries a delivery plan through its lifecycle. Release is the word you see in the UI; scope is the underlying object a release is built on. See Releases and scopes.
How to read this Manual
The chapters build up from the model, through the engine, to the bigger picture. In sidebar order:
| Chapter | What it covers |
|---|---|
| Key concepts | The vocabulary and the shape of the data model — the foundation for everything else. |
| Requirements | What a requirement is in REQQA: templates, versioning, history, and lifecycle. |
| The mission | Why the mission sits at the top, and how its context propagates to everything below. |
| Stories and features | How requirements become features and Gherkin stories, and how those relate back up. |
| The analysis engine | DeFOSPAM, analyser codes, and what each analyser looks for. |
| Synthesis and cleanup | How analysis issues feed back into requirement content to improve it. |
| The glossary | Definitions and the term index that keep vocabulary consistent. |
| Releases and scopes | Grouping work for delivery, and the scope/plan lifecycle behind a Release. |
| Static analysis policy | Policy-driven checks applied across requirements. |
| Access and onboarding | Multi-tenancy, invitations, and how people join an organisation. |
| Background jobs | How long-running work (analysis, generation) runs asynchronously. |
| The Dark Factory | The vision of REQQA driving its own build from requirements. |
What this Manual deliberately doesn't cover
- How to perform specific tasks → see How to manage your requirements and the other entries in the How-To section.
- First steps for new users → see Welcome and A tour of REQQA.
- Quick answers → see the FAQ.
Related
- Key concepts — the model and vocabulary in detail.
- Welcome — start here if you are new.
- The mission — why the mission is the foundation of everything below.
- What is REQQA? — the short answer.