Back to all posts
Methodology7 min read·October 25, 2026

Nonfunctional Requirements: What to Specify Before a Build

TB
ThynkBlox Team
Engineering

Nonfunctional requirements define the measurable operating constraints a software product must meet, such as availability, responsiveness, accessibility and recoverability. Examples include how quickly a search returns under a stated workload, which journeys must work with a keyboard, and how much saved work may be lost after a failure. A useful requirement names the expected result, the circumstances in which it applies and the evidence that will prove it.

How do functional and nonfunctional requirements differ?

A functional requirement describes something the product must do: create an account, submit an order or export a report.

A nonfunctional requirement describes the conditions under which that capability must work. Can someone submit the order using only a keyboard? How long may submission take during a busy period? What happens to a confirmed order after a failure?

Keep related requirements together. “Customers can download invoices” describes the capability. “The download remains usable while other customers are placing orders” introduces an operating constraint, but still needs a workload and a measurable result.

The distinction matters less than completeness. Naming a requirement “performance” does not make it testable.

What are useful nonfunctional requirements examples for software?

The examples below are illustrative acceptance targets, not recommended defaults. Replace their numbers and circumstances with ones that match your users and the consequences of failure.

AreaVague requestIllustrative, testable condition
ResponsivenessSearch should be fastWith 100 active users and 50,000 catalogue entries, at least 950 of 1,000 searches show usable results within 2 seconds, measured from submission
AvailabilityOrders should always workDuring the agreed daily ordering window, a signed-in test customer can complete the order journey, with no more than 10 minutes of unavailability in each 30-day observation period
AccessibilityEveryone should find checkout easyA customer can complete checkout using only a keyboard, with visible focus, labelled controls and errors that identify the field and explain the correction
RecoverabilityKeep backupsAfter the agreed data-loss scenario, restore ordering within 60 minutes and lose no more than 15 minutes of saved changes
CapacitySupport growthWith 200,000 stored orders, the order-history screen still meets its agreed response target during the stated peak workload

These are starting points. Each needs a verification method and explicit boundaries. The accessibility example, for instance, covers specific checks; it does not establish that the whole product is accessible.

What should every requirement record?

Use a short record that answers these questions:

  • Which journey? Name the action and who performs it.
  • What counts as success? Define the observable result.
  • What is the target? State the limit or condition.
  • Under what workload? Describe active users, actions, data volume and request frequency.
  • Under what circumstances? Specify relevant devices, network conditions and dependencies.
  • How will it be checked? Name the test and the evidence to retain.
  • What is excluded? State exceptions and their treatment.
  • Who accepts the result? Name the person responsible for the business decision.

Avoid treating “concurrent users” as a complete workload. People reading a page and people generating reports create different test scenarios. Describe what those users are doing and how often.

Keep the agreed record beside the feature description. The principles in software project documentation provide a useful place to start.

How do you specify responsiveness without hiding slow experiences?

Choose the start and end of the measurement before setting a target.

For search, does timing begin when the user submits the query or when the application receives it? Does it end when the response arrives or when results become usable on screen? Choose the boundary that answers the business question.

Record slow results and failures separately. An average alone does not tell you how many users waited beyond the limit.

An illustrative search requirement might read:

> During a 20-minute test with 100 active users, each submitting a search every 10 seconds against 50,000 catalogue entries, at least 950 of every 1,000 searches must display usable results within 2 seconds. Use the agreed mobile device and network profile. Report failed searches separately; they cannot count as passing results.

Also state whether the test includes first visits, repeat visits or both. Otherwise, people may agree on the target while testing different experiences.

How should you define availability and recoverability?

Availability asks whether the required service is usable during the agreed period. Recoverability asks what must happen after a specified failure.

For availability, define a useful journey. A page that opens does not prove that customers can place orders. Record how often the journey is checked, how unavailable time is counted and whether planned maintenance counts.

For recoverability, separate two decisions:

  • Recovery time: how long the business can wait for the journey to work again.
  • Acceptable data loss: how much recent saved work the business can afford to lose.

Then describe the failure being tested and what recovery must preserve. A restore is not accepted merely because the application opens. Check that the agreed records are present, relationships remain intact and users can resume the journey.

Treat a backup requirement and a recovery requirement as separate acceptance items. Require evidence from a restore exercise for the latter.

How do you make accessibility requirements concrete?

Name the journeys and the interaction methods to check. “Accessible interface” leaves too much open to interpretation.

For a registration journey, specify that a person can reach every control using a keyboard, see where focus is, understand each field label and correct errors without losing valid entries. Include what happens after submission and where focus moves when an error appears.

If screen-reader use is in scope, identify the agreed browser and screen-reader combinations and verify the journey with them.

Use these checks as acceptance evidence for the stated scope. Do not turn a small checklist into a claim of complete accessibility. If formal conformance is required, agree on its reference, scope and review method separately.

How do you turn a vague request into an acceptance decision?

Consider a reporting feature described as “quick and reliable”.

The following worked example is entirely illustrative.

First, identify the job: an account manager opens a monthly order summary. Next, define its size: 10,000 orders in the selected period. Then describe competing activity: 50 users continue browsing and submitting orders while 5 account managers request summaries.

The resulting requirement could say:

> Under that workload, each summary must become readable within 5 seconds. Every summary must include the expected orders and totals for the selected period. A failed request must show a clear retry action and must not display an incomplete summary as complete.

Response time, correctness and failure behaviour now have separate pass conditions. The test must check all of them.

Agree on this evidence before estimating the build. For the wider acceptance approach, see software testing and quality assurance.

What common mistakes should you avoid?

Copying targets from another product. Start with the cost of delay, lost work or exclusion for your users.

Writing universal promises. Replace “always”, “instant” and “unlimited” with bounded conditions.

Testing only with a small, empty dataset. Include the data volume and distribution relevant to the agreed requirement.

Leaving dependencies ambiguous. If an outside service is unavailable, specify what the user sees and which actions remain possible.

Defining exceptions after a failure. Agree on exclusions before testing.

Requiring the strongest target everywhere. An occasional administrative export may justify a different response target from checkout. Set requirements by journey.

What should founders agree before requesting an estimate?

Start with the journeys where delay, exclusion or lost work would matter most. For each, agree on the workload, measurable result, failure behaviour and acceptance evidence.

Ask the proposed build partner to identify which requirements materially change the design, delivery effort or ongoing cost. Record unresolved decisions as open questions rather than hiding them inside “production ready”.

The aim is a shared basis for accepting the product.

Frequently asked questions

Are security requirements nonfunctional requirements?

They can be. Write observable conditions, such as which roles may access a record and what an unauthorised user receives. Some security requirements also describe specific product behaviour, so avoid forcing every requirement into one category.

Does an early product need these requirements?

Yes, but keep them proportionate. Define the limits that matter for its intended users and launch workload. Leave speculative future capacity out unless it affects a decision you must make now.

Can the targets change after launch?

Yes. Revisit them when actual use, business needs or supported journeys change. Record the revised conditions and acceptance evidence so everyone knows what the new agreement means.

Performance requirements need evidence before launch; see how to plan load testing.


*Need help defining what your software must deliver? Discuss your build requirements →*

Ready to build?

Let's turn these ideas into your next product.

Start your project