Functional vs. Non-Functional Requirements: The Full Guide, Definitions, and Technical Examples

What Are Functional Requirements?

Functional requirements specify which functions your system (or system component) must have. In other words, they define what your custom software needs to do. If these requirements are not met, the software fails; it’s non-negotiable. Examples of the most common functional requirements are (1) use cases and (2) document descriptions.

Use Case

Use cases can be numbered lists with text or diagrams that describe user actions. Each use case illustrates behavioral scenarios through one or more functional requirements. First, a set of use cases is selected — and then an analyst can derive the functional requirements that need to be implemented in order for each use case to be fulfilled. For example, a navigational use-case model for a conference management system is proposed in the diagram below. Each main functionality is associated with user roles: Here’s an example of a use case numbered list for a subway ticket machine:

Written Document Descriptions

A typical written functional requirement will contain a unique name and number, a summary, and a rationale. This information is used to help the reader understand why the requirement is necessary and develop a system to track it. Some examples of written functional requirements include:

  • Interface requirements
  • Data manipulation and processing requirements
  • Verification requirements
  • Documentation requirements
  • Security requirements
  • Acceptance criteria

During the development stage, functional requirements are used to describe whether or not the system is working as intended. Unfortunately, that means that there might be many more requirement types for you to write down until you create a complete picture of a correctly working system.

Who Is Responsible for Preparing Functional Requirements?

Functional requirements are typically collaborated on by a business analyst, system analysts, and an implementation team. The project manager is responsible for making sure the functional requirements are delivered on time, and the System Owner and QA sign them off.

What Are NFRs or Non-Functional Requirements?

Non-functional requirements define how the software fulfills its functional goals – not what the system will do but how the system will do it. These requirements define criteria that are used to evaluate the system’s performance, reliability, and maintainability. They define and impose external constraints on the software being developed, as well as on the development process. Non-functional requirements are presented as a specific aspect or general property of the system as a whole — as opposed to an exact function. Aspect = a feature linked to many parts of the system but not related to its primary function Properties = software characteristics, including integrity, reliability, accuracy, etc. Non-functional requirements can be divided into two main categories: performance and evolutionary qualities.

Reliability Testability
Survivability Maintainability
Efficiency Extensibility
Integrity Scalability

Performance qualities are observed at runtime, whereas evolutionary qualities are embodied in the system’s static structure. Let’s take a closer look at some non-functional requirements examples presented in a paper published by the IEEE.


Efficiency: How well does it utilize resources?

Integrity/Security: How vulnerable is it to cyberattacks?

Reliability: What level of confidence can be placed in its functions?

Survivability: How well does the system perform under poor conditions?


Correctness: How well does the system conform to requirements?

Verifiability: How easy is it to verify the system’s performance?

Maintainability: How easy is it to repair the software?


Expandability: How easy is it to upgrade or expand its capability/performance?

Interoperability: How easily does it interact with other systems?

Flexibility: How easy is it to change?

Portability: How easily transportable is the system?

Reusability: How easily can it be converted for use with another system?

Who Is Responsible for Preparing Non-Functional Requirements?

While functional requirements can be presented in a Functional Requirements Document (FRD), a Product Requirements Document (PRD) combines functional and non-functional ones. Non-functional requirements are usually defined by developers, software architects, and other technical experts, and the product manager typically prepares the PRD.

Comparison Table

To see the differences between functional and non-requirement functions at a glance, just check out the table below:

Helps the reader understand what functions the system will have Helps the reader understand how the system will perform
Explains the system’s necessary features Explains the way the system should behave
Identifies what the system must (and mustn’t) do Identifies how the software should do it
The system won’t work if these requirements aren’t fulfilled The system will still work if these requirements aren’t fulfilled
Ensures the software meets user requirements Ensures the software will meet user expectations
Straightforward to define Harder to define
Can be documented through a use case Can be documented as a quality attribute


Your software needs to fulfill both functional and non-functional requirements for optimal performance. The former enables it to run, while the latter enhances the user experience. Therefore, it’s important to work with a custom software development team that meticulously documents both kinds of requirements. Otherwise, you could end up with a disappointing product or a decent one that exceeds budget and time constraints.


Leave a Comment