What Are Non-Functional Requirements And Why You Need Them?

There’re essentials you have to think through before you’re to develop a product if you want it to work as you expect it to or even better. These are, as we explained in our previous article, 2 types of requirements: functional and non-functional. From this article, you will learn what non-functional requirements are, and why they are as important as technical ones.

What is a Non-Functional Requirement?

A non-functional requirement, or NFR, is a requirement for the  system as a whole. It doesn’t describe user actions, system behavior, or interface. Instead, it determines WHERE the product  should be used and HOW we better design it from a technical perspective. Often NFRs are referred to as technical user stories or software quality requirements.

This is what the NFR list for a product may look like:

Now let’s dive deeper into the types of non-functional requirements to better understand why you even need to describe them in the first place.

Requirements to for WHERE the system should work

There are systems we expect to work everywhere: on any device, any platform, from any place. This is their technical requirement. For example, Facebook or YouTube. But they weren’t like that in the beginning. Making the system work flawlessly around the world on any device is pretty difficult and expensive. An MVP doesn’t need this to test their hypothesis and get the first users. That’s why we always ask our clients how many active users they plan to have in a few months and where they are located. This brings a lot of benefits:

• fits the initial system scale to the expected load — avoiding unnecessary scaling saves money;
• saves funds for not having to maintain the load that is not expected in the near future.

Basically, when you ask yourself “Where should my system work?” and then answer your own question — this is how you articulate the non-functional requirements for localization (early adopter countries) and scalability (concurrent users, storage capacity).

Example: A Texas factory owner wants to develop a video surveillance system that can meet specific needs of the factory. NFRs to it will be:

• Localization: USA, language — American English
• Scalability: 1 factory, 10 security officers, up to 100 simultaneous cameras.

Most likely, this system will never have to experience the Black Friday test in Europe. However, if this is suddenly required (for example, the business grows in an unforeseen way), the factory owner will have to scale it up.

However, it’s a big game changer if we consider the potential of scaling from the very beginning, it saves a lot of money.

Some non-functional requirements don’t even require additional timespend. It takes the whole development some time to build a functional user story and features within. A technical user story, for instance, simply comments on the date and time formats for the specified use location.

Technical user stories also determine the browser and device support. You might’ve seen a note like “For the best experience, use the latest version of Chrome”? It indicates that the developers tested the platform, obviously, on the latest version of Chrome. It may work in other versions and browsers, but the software provider themselves don’t know how exactly — they haven’t tested it. Usually this is how companies save money on testing things and features not or least used by potential users. It’s a rather simple rule: you can grow a product and add new cool features to it only when the main functionality is working perfectly.

Requirements for HOW the system should work

1. Effective performance

How to build it so that it works well? What does “well” even mean?

Example: Let’s take the same video surveillance system. If we want it to work well, then the video quality should be high (say, Full HD). But at the same time, we want to optimize server costs so that the client doesn’t overpay. Most likely, Full HD is useless at night or when nothing happens in the picture. Then we lower the quality and boost it automatically when cameras detect motion. Or maybe leave the decision up to the user? They could set, for example, the main camera to 720p and the others to 480p.

Depending on the specifics of the business, non-functional requirements for video quality can vary and must necessarily be specified in writing.

2. Security

Another side of “how well” is “how safe”. The system may collect or transmit sensitive (in terms of security, safety, or privacy) data. Not meeting relevant requirements can cause its owner major legal problems. In 2022 covering damage from data leaking may cost a company up to $4,35 million, according to the IBM data breach report.

Examples of security requirements:

• The users of the platform should be over 18 y.o.
• The payment processing gateway must be PCI DSS compliant.
• 1-1 calls should be HIPPA compliant.
• User profiles and data storage should be GDPR compliant.

3. Speed

Non-functional requirements also answer the “how fast” question, in case the speed is critical.

Example:

• The results must load within 3 seconds.

4. Integrations

Last but not least, technical user stories define the necessary integrations into functional user stories, in case we don’t develop custom solutions.

Examples:

• If the user needs to pay, the NFR specifies the payment method (e.g. Stripe, PayPal, in-app purchases, etc.).
• If the user should receive a system email, the NFR says what system will perform it (e.g. MailChimp, Sendinblue, Mailgun).
• If the user wants to watch a video, NFR determines the player.
• If the user needs to call, NFT names the video conferencing system to integrate.
• If the client needs to analyze performance, NFT specifies the requirement for Google Analytics integration.

And so on, so on, so on.

5. Reliability and availability

For some systems it is important to provide a high level of availability and resilience to failures. These requirements describe how the system should react to failures and disruptions, and how fast it should recover, as well as implemented solutions to achieve these goals.

Example: The system must provide availability of 99.99% uptime and recovery should take no more than 5 minutes.

6. Scalability and performance under load

Other than the current load of the system, it should also be prepared for future growth and potential increase in load. Non-functional requirements describe how the system should react to increased loads and how it should scale with increase in usage.

Example: The system should support up to 10,000 users simultaneously without any performance degradation

7. Maintainability and flexibility for updates

These requirements define how easy the system is to maintain and update after launch. Examples include code standards, documentation and modular architecture which allow changes to one part of the system without impacting the whole system.

Example: Software should be developed according to specific code standards and have at least 80% code coverage with tests, which will simplify future development and support.

8. Monitoring and configurability

The system must be easily configurable to provide a higher level of quality and reliability. Monitoring of the system state should be implemented at all levels. Non-functional requirements in this area describe which metrics and logs should be collected and how the administrators of the system should be notified about potential issues.

Example: The system must have a monitoring system that tracks CPU and RAM usage in real time and sends alert notifications when these values reach critical values.

Let’s summarize

To write complete non-functional requirements that can ensure the quality of the system, the analyst better discuss with the client and list the following possible attributes:

• Localization and Language / Multi-language support,
• Date and Time formats, Timezone, Currency,
• Current scale and potential Scalability,
• Browser support,
• Operating System / Device compatibility,
• Quality / Size / Format constraints,
• Security / Safety / Privacy concerns,
• Speed (Performance), Responsiveness, Reliability,
• Third-party integrations.

Conclusion

Functional and non-functional requirements go hand in hand when planning a system. While the first bring more value to the end user, the second explains where and how the product delivers that value. While describing non-functional requirements is crucial for building an MVP, it goes fil-rouge throughout the entire product life cycle.