When you organize functional requirements with use cases, you usually find conditions still missing.
Conditions such as "responses must finish within 2 seconds," "personal data is stored encrypted," and "the same tasks must also work on mobile screens" are hard to fit into a single use case.
The document that holds these conditions is the
supplementary specification
.
Read it together with the use cases from the previous post, and you can see functions and quality attributes side by side.
the system does, while additional requirements define
how well
and
under what constraints
it does it.
For example, "users can pay" is a functional requirement.
"The payment approval response must finish within 2 seconds" is an additional requirement, and without it developers cannot know how slow the feature is allowed to be even after they implement it.
classification is often used to find requirements systematically.
Each letter stands for a quality category, and the + adds design and implementation constraints.
Category
Question to ask
Example
Functionality (F)
Are there function rules that the use cases did not cover?
Tax calculation method, the time window for canceling an order
Usability (U)
Can a first-time user learn it easily?
Main tasks can be finished within 3 clicks
Reliability (R)
How often is failure acceptable?
Monthly availability of 99.9% or higher
Performance (P)
How fast must it be?
Payment approval response within 2 seconds, 10,000 concurrent users
Supportability (S)
How easy is it to operate and change?
Logs kept for 30 days, configuration changes without redeployment
Design constraints (+)
Are there design decisions that must be followed?
Use PostgreSQL as the database
Implementation (+)
Are there constraints on how it is built?
Libraries under a specific license are not allowed
Interfaces (+)
Are there commitments to external systems?
Follow the payment provider's API specification
Physical (+)
Are there conditions on equipment or environment?
At least 16 GB of memory per server
Legal (+)
Are there regulations or contract terms?
Data retention periods that comply with the law
A checklist that splits additional requirements into the five FURPS categories and the design constraint, implementation, interface, physical, and legal categories
As you fill in the table one cell at a time, the categories the team tends to overlook become visible, like a checklist.
You do not need to fill in every cell. Writing "not applicable" for a category that does not apply is also important.
Turning vague wording into verifiable numbers ๐
The most common mistake in additional requirements is using words that cannot be verified, such as "fast," "stable," or "easy."
Developers and testers cannot judge such words against the same standard.
Fast
โ 95% of payment approval requests respond within 2 seconds
Stable
โ monthly availability of 99.9% or higher
Easy
โ a new user completes the first order within 5 minutes
Each number should also come with a
measurement method
.
For example, stating "measured in a load test with 10,000 concurrent users" lets you judge immediately later whether the result meets the requirement.
๐
It is easy to postpone additional requirements, assuming they can be changed later.
However, design constraints and interface conditions shape the initial structure, so settle them early to avoid major rework later.
An example of a design constraint changing the design ๐
Suppose there is a condition that payment approval responses must come within 2 seconds.
If the average response time of the payment provider's API is 1.5 seconds, only 0.5 seconds remain after our server's own processing.
Because of this condition, the timeout and retry policy for calls to the payment provider must be decided together at the design stage.
One requirement leads to a detailed decision in the system structure.
๐จโ๐ป
It helps to link the supplementary specification from the use case body with a note like "see supplementary specification."
Then a reader of the use case can immediately find the quality conditions attached to that function.
that sits alongside the list of functions.
Use FURPS+ categories to find them without gaps, and turn vague words into measurable numbers and measurement methods.
Requirements organized this way become the basis for design decisions, and they are used again later when setting priorities in iterative development.