Defining product requirements is the first stage of any software development project. The owner describes expectations about the software, and the development team specifies skills and tech stack, applied to reach these objectives. Detailed requirements help to improve mutual understanding and set clear benchmarks for the product.
What are the software development product requirements?
Product requirements are a documented version of projects’ needs, deadlines, and risks. The document with product requirements defines the purpose of the software and its individual features. The file answers many important questions about product and development process:
- Who is the audience of the product?
- What are the needs of an average user?
- What are the business goals of a product owner?
- What technologies will a software development team use to fulfill these objectives?
- What are the end benefits for the user?
Product requirements describe multiple aspects, which is why, over time, different kinds of requirements stood out.
Types of product requirements
Deciding what product to build is the most challenging part of software development. If done wrong, product requirements distort the final result. Most importantly, if done wrong, this stage is difficult to redo later on- which is why it’s usually included in the first stage of a product development process. To build a successful product, all requirements should be written in detail and order – especially the five main types:
- Business requirements: describe financial and marketing reasons that a company has for building the product. For instance, it can be increasing conversion by 20% or increasing request processing speed by 2 times.
- User requirements: a development team analyzes the product from a user’s point of view. The goal is to determine which functionality will improve user experience the most. An example of such requirements is “to create a customer profile that is easy to manage, and that can load fast even in low-bandwidth conditions.”
- Functional requirements: this type describes the features that should be implemented to achieve business and user objectives. For instance, it could be “to enable multi-factor authentication for increased profile security” or “to allow sorting product items by their price.”
- Non-functional requirements: these requirements describe rules that features have to comply with, but not the features themselves. For instance, a non-functional requirement for multi-factor authentication could be “to require a password with 8 numbers and 2 letters.”
Each type of these requirements has to be described in detail for development to succeed. However, two of them are often harder to grasp – we are talking about functional and non-functional requirements. Their respective scopes, differences, and purpose might seem less intuitive, which is why we will focus only on these two types now.
Why are functional and non functional requirements important?
More than 48% of developers believe that poorly defined requirements led their projects to failure. The inability to define features and functionality rules early on leads to improper financial estimates and missed risks.
Functional and nonfunctional requirements tackle such important aspects of product development functions as accessibility, security, user accounts, data integrity, and other aspects. If you don’t take these factors into account early on, the project is subjected to security risks, malfunctions, poor user experience, and internal team issues (unmet deadlines, increased development costs, etc.).
Case in point: Amazon published its AVS product requirements openly. All developers that create products for Amazon Alexa should be familiar with user expectations and necessary features. Amazon explains that they published the full guide with functional and nonfunctional requirements in order to deliver the best user experience. Also, it sets the same standards for all developers who are working with the voice assistant.
Let’s take a look at functional and non-functional requirements one by one, discuss their scope, and assess practical examples.
What are functional requirements?
A functional requirement is a function of a system with inputs, required for a system to function and outputs that it produces. Functional requirements usually describe the following aspects of the system’s functionality:
- calculations, performed by the system (inputs, formulas, expected output)
- data processing and consumption (how much data and of which type are required to start the system and keep it running)
- use cases for the system: all possible scenarios where a system might be involved
- used technology: which languages, APIs, database solutions, and other tools are used to implement and maintain a system.
The formula for functional requirements is “the system must do” because they describe all actions that a feature should undertake.
Main types of functional requirements
Let’s take a look at a functional requirements document that you should create in order to describe all the requirements discussed above.
1. Functional requirements specification document
The FRS document collects and describes all the main features of the application. It can feature functional requirements only or include other types as well. There’s no need to write the entire software requirement specification document before you start developing a product. You should start with the essential functionality. New functions can be added right before their development, not necessarily during the very first sprints.
The structure of the SRS includes:
- Purpose: you describe the background and value of the system.
- Description: the description of the general functionality (for instance, for an AI platform, you can describe tools that you use for data processing and outline product improvement strategies).
- Specific requirements: features, necessary data inputs, database characteristics, connections between several functions, etc.
You can take a look at examples of functional requirements that were created by the University of Washington and the University of Wisconsin – scroll to 3.1.1 to see Functional requirements. You can order your requirements in a similar list, grouping features by their purpose.
2. Use cases
Functional requirements in SRS touch on standalone functionality without taking users into account. That purpose is covered by use cases – a document that describes the interactions between a system and a user (UX). In functional requirements, you describe which date users have to enter to start working within a system, how the system responds to particular user actions, and underline scenarios in which every feature will be used.
The structure of a use case document
- Actors: types of users that interact with a system (for instance, on a blogging platform, these actors can be publishers, readers, and moderators).
- System: a list of features available for user interactions;
- Functionality, necessary to achieve goals: objectives, related to the user experience are usually defined in user requirements. Functional requirements describe which features are necessary for each user group to get the ultimate experience.
- Associations: relationships between several features of the system and involved actors.
The goal of use cases is to determine scenarios of how users typically interact with the intended functionality of the software.
3. User stories
If use cases describe user-software interactions in a generalized impartial way, user stories go through the same situations but from the user’s point of view. A document with user stories connects possible interactions with user motivations and expectations. The structure of the document is as follows:
- User needs: as a customer, I want to find accommodation that fits my price range – a possible need for an e-booking system or a tourist app.
- The solution, described from a user’s point of view: “I go to the search bar, press the “Filters” button, and choose “Price”.
- Backlog and progress: each feature should include a status update – to do, in progress, or done.
After making user stories documents, teams often discover that some use cases weren’t necessary at all, because they don’t correlate with user needs. It’s likely that developers will have to add some new user cases – so be ready to switch back-and-forth between the two documents.
4. Functional decomposition
This is a structure where complex functionality is broken down into structural parts. By breaking down features, you can simplify the development process early on and estimate project duration and costs more accurately. Also, if something goes wrong, you can refer back to the structure and figure out exactly which part of the system malfunctioned.
Non-functional requirements examples
Non functional definition is the criteria that all product’s features should fall under. These are attributes that will help you define crucial user expectations and control product quality. The list of non-functional requirements is very specific to the type of the product and industry, but we can boil it down to four main ones.
Usability evaluates the ability of a user to easily interact with a designed product to achieve their own needs. The product should be clear, intuitive, and simple. All features should directly respond to user needs – no necessary functions should be lacking.
- Users should easily understand the interface of the product during the first interaction;
- The site should quickly lead users to the fulfillment of their main goal: no distracting functionality or cluttered interface.
- Users should be able to recall their previous user experience and interface. If a person booked accommodation on a site once, doing it the second time has to be easier.
2. Legal or Regulatory requirements
Legal non-functional requirements refer to the product’s compliance with laws. You should know which industry’s laws your product has to comply with (for the medical field, for instance, it’s HIPAA) and be familiar with fines.
If you are operating in a particular region, you should have the licenses required by the local government. For instance, if a transportation company operates in London, the platform must be credited with approval from the local government.
This is a requirement that describes your product’s vulnerable points and solutions. To create a detailed reliability document, the team needs to:
- Analyze similar existing solutions, examine complaints, and try out their functionality,
- Examine safety risks by following technology reports, news, and industry insights;
- Evaluate typical problems with the tech stack; development languages and frameworks tend to have specific common tech issues that could jeopardize their performance, and the same logic is valid for any software development component. For instance, a typical problem with Node.js is a “callback hell,” Ruby tends to have slow performance, while Python is slow at processing real-time data.
Performance metric assesses how a product reacts to users’ actions, the speed of reaction to clicks, mouse hovering, and key presses, input and output correlation, and other aspects. Overall, performance-related non-functional requirements can be divided into several types.
- Design: the number of actions and requests the system requires to perform an action; the fewer – the better;
- Data: algorithms should be stable and constant, and perform well in low-latency conditions;
- Source-code: code should be readable, shortened, and achieve as much as possible with the lowest possible number of code lines;
- Build-level: developers evaluate the performance of each new build and compare it to the previous versions.
Non-functional requirements describe not what should be implemented but rather how. They are not as measurable, objective and functional requirements are. So, here’s the list of main challenges that you should be aware of during software development and digital transformation.
- Subjectivity: every non-functional requirement can be interpreted differently by team members and stakeholders, which is why the document should include clarifications and examples;
- Conflicting nature: one requirement can contradict another (for instance, laws can call for time-consuming practices or prohibit personalization features that could increase usability;
- Team misunderstandings: when you create a document with non-functional requirements, it’s easy to take some of them for a given. “Everybody knows that a page should be GDPR compliant. It’s obvious that statistics should be tracked by Google Analytics” – and so it goes. At the end of the day, these “obvious” requirements are unrecorded and missed during development.
How to determine and measure non-functional requirements?
To address all challenges, you need to adopt the best planning practices early on. Here’s a list of must-implement actions for the creation of documentation with non-functional requirements.
- Discuss non-functional criteria with all involved parties early on.
- Assess each requirement with a numeric score. Adopt the same scale for the entire document – you can evaluate each requirement with a grade from 1 to 10.
- Re-evaluate non-functional requirements during development, testing, maintenance, and scaling.
- Make sure to integrate users’ feedback. You can get the awareness of new functional requirements and discover that some of yours were irrelevant.
Difference between functional and non functional requirements
Now, we reviewed the main functional requirements vs technical requirements, and it’s time to put them side by side in the comparative table.
Drawing a line between business and non-functional requirements
Business requirements vs functional requirements refer to different aspects of product development. Business requirements determine the economic objectives of the company (amount of sales, company growth, getting a bigger market share, etc). Functional requirements refer to specific features that are supposed to help accomplish this goal.
However, the difference is between business requirements and nonfunctional requirements is a lot less obvious. In fact, understanding the difference between business and non-functional criteria is confusing to many developers – so let’s see how to tell them apart.
Business requirements describe the project form the business point of view – product owner, investors, partners form product ideas, goals, and vision. They describe how the software development product helps the company achieve higher conversion rates, bigger market shares, sales, and attract new clients.
On the other hand, what are non functional requirements? They represent the product criteria from users’ point of view and describe how a project should be done to develop the ultimate user experience. However, despite the differences, two types are connected: if non-functional requirements are fulfilled, it’s likely that business requirements will be met as well.
Business goals are overall easier to measure because they typically refer to specific financial goals. The increase in conversion rate, sales, market penetration number of clients, or penetrated niches can be easily measured, whereas subjective values like usability can’t be precisely defined numerically.
Relations to functional requirements
Business requirements stand further apart from functional requirements. The goal of getting more clients can be achieved in multiple ways. By the time you define business requirements, you don’t have yet to know which functionality you will be implementing.
Non-functional requirements, however, are directly connected to software features. To create precise criteria, you need to understand what functionality you are describing. So, the order of making a list of requirements would be: business comes first, functionality is at second place, and non-functionality criteria are the third (although the latter two can be written simultaneously).
Functional vs non functional requirements examples
It will be easier to draw a line between functional and non-functional requirements by analyzing real-life examples. We took well-known platforms and applications, and hypothesized how a development team would write their documentation. You can use the same logic for your development project.
Netflix is a video streaming service that is focused on personalization and accessibility. Let’s take a look at what functional requirements examples the development team can come up with before developing a similar service.
Examples of functional requirements
- Streaming: users should be able to immediately open any video by hovering its icon and clicking play (2 actions). A hover should lead to a panel that shows the video’s title and description. When an item is opened, the interface shows the video in a full web window.
- Title search: Netflix has a search bar where people can filter results by people and genres. Even if a user enters an imprecise name of a movie or TV show, the software should find similarly named items. Additionally, users should be able to look for a title in particular categories – “Movies,” “TV Shows,” “Recently Added.”
- Viewing history: the platform always updates users’ history and preferences, using data analytics. The contents of the main page depend on users’ favorite genres, actors, interests, interests of users who watch the same content, location, age, and other factors.
- Usability: the interface should be adapted to desktop and mobile devices. The main page has to clearly display items that are in progress and suggested titles. If there’s a new release on the platform, users should be notified in an undisturbing way. Search experience should be seamless – users should be able to search for many titles in a row with no interruptions, freely switching between tabs.
- Security: each user fills out a form with an email address, name, age, location, and provides financial information for paid subscriptions. Credit card data and private information should be stored safely.
- Performance: how much time does an average user require to find a needed title? How many clicks are needed to open a TV show or a movie? How many clicks are required for watching experience optimization (pausing, scrolling, etc.)?
- Legal requirements: how does a service handle copyright laws? What are the local regulations for payments and copyright? How is the service compliant with privacy laws in supported areas?
Instagram is an example of an intuitive app with terabytes of media content. All apps that handle huge amounts of photos and video can create similar functional and nonfunctional requirements. Here’s an example of how a list of requirements for Instagram could look like.
- Use stories: Instagram users want to upload with image and video content, write captions, and publish the updates. Similarly, they would like to react to content posted by other accounts, as well as commend and follow them.
- Use cases: when a user opens an Instagram mobile, web, or desktop app, the first page is the Feed. Here, a user sees the panel with recently posted stories, content updates (image + caption, video + caption), and advertising. Right on the Feed, a user can interact with the content leaving likes and comments.
- Additional functionality: push-notification, automated location tagging, automated expiration of Instagram stories, photo filters, search bars.
- Performance: content-loading speed is the priority. Instagram is a read-based program because most users spend time viewing content rather than uploading their own media files in a ratio of about 80/20.
- Usability: the application should allow users intuitive navigation between profiles, their subscriptions. They can interact with pictures, leave likes and comments, and send direct messages. Similarly, they should be able to upload pictures and videos in 1-2 clicks, as well as edit and publish them. Instagram should remember the most common locations and filters to make future uploads easier.
- Reliability and scalability: the system should perform well in low-latency conditions, show media content with the smallest delay possible, and scale to accommodate millions of new users.
- Safety: Instagram has detailed protocols for authentication, photo upload, API integration, photo embedding, encryption of direct messages and chat profiles, and user activity. Users can delete their profiles and all information associated with them.
We decided to review Uber because similar applications appeared all over the world in many industries. We have an Uber for tourism, e-commerce, beauty, healthcare, and other fields. So, you can re-use a similar logic for your project’s requirements.
- Location identification: Uber should integrate native iOs and Android APIs to track user’s location, determine the most efficient routes, and provide real-time vehicle tracking. A user should be able to book a ride from any location and track driver’s arrival,
- Driver assistance: Uber should support drivers by providing them with real-time directions that will help them to go to a client in the most efficient way. Integrating MapKit and Google Maps Android will provide fast native route design.
- Booking process: a user should be able to see the driver’s ratings and order a ride in less than 10-15 seconds. An app should estimate the arrival time and the cost of the ride.
- Notifications: Uber should notify a user several times: the first update is sent when the ride is accepted by a driver, the second one – when the driver reaches proximity. Finally, the third notification is reserved for ride cancellation.
- Payments: a user should be able to pay with promo codes, credit cars, and debit. Additionally, the system supports Braintree, Stripe, and Instacart.
- Usability: users should be able to book a ride in less than a minute, access personal accounts, get their payments process in less than a minute. The app should be transparent about the way it connects clients and drivers, record past activities, and provide detailed reports on all financial transactions.
- Legal requirements: Uber should comply with local transportation and employment laws. Additionally, personalization and data collection should comply with GDPR requirements.
- Reliability: Uber should provide fast and error-free performance in low-bandwidth zones. All payments, driver requests, and updates should go through smoothly.
- Security: how is the data on user location processed and stored? How is the financial information handled by the application? How is personal account information saved and encrypted?
Functional and non-functional requirements set the foundation for a successful software development project. When you define the necessary features of the product and set up requirements for each of them, the development itself will go a lot faster. Our experience and statistics show one thing clearly: you can’t miss out on defining project requirements. If done wrong, poor documentation will lend quite a hit on your project.
This is why we at Jelvix always start by defining product requirements – not just functional and non-functional, but the whole package. Clear documentation provides our clients and team with the bird-eye view on the project and cuts costs by 2-3 times. If you’d like to get started on your project, drop us a line – and we’ll immediately get up to speed with preparing requirements.