What are functional requirements?
Functional requirements define a system’s features and functions. In other words, they describe what exactly the software product must do under normal conditions to meet the user’s needs. From a developer’s standpoint, functional requirements are the features that have to be implemented so that the system works as it should.Note that functional requirements describe both essential product features (e.g., authorization or payment flow) and nice-to-haves that can enhance user experience but aren’t necessary for the system to function (e.g., leaving reviews or having multiple filtering options).
To better understand functional requirements and how they differ from other types, let’s take a brief look at BABOK’s classification schema, considered an industry standard. According to it, requirements can be categorized in the following way.
Classification of requirements in business analysis
Business requirements define the organization’s high-level objectives, goals, and needs. Recorded in the business requirements document, they help all the parties involved to understand why the project is initiated.Stakeholder (User) requirements express the needs and expectations of different stakeholders. They serve as a link between most high-level business requirements and more specific solution requirements.
Solution requirements are the detailed description of the expected features and characteristics of the system or product. This category includes functional requirements and non-functional requirements.
Transition requirements outline which steps must be taken to implement the system successfully. They are short-term in nature and are only necessary to facilitate the transition from the current state to the future state.
Solution requirements typically cause the most confusion, so let’s have a closer look at what they include.
Functional requirements vs non-functional requirements
As we said, functional requirements are used to describe the system's desired capabilities or functionality or what the system must do. On the contrary, non-functional requirements focus on the system’s quality attributes, such as speed, security, reliability, etc., and define how the product must work.
Functional requirements vs non-functional requirements
You can find more information in our detailed comparison of functional and non-functional requirements. You can also explore the non-functional ones together with Neo and his gang in the video below.
Non-functional requirements explained
Functional requirements examples
So what might functional requirements look like? Here are some examples.
The system allows users to leave comments through a contact form.
The system generates the report and shows it on the screen after the user chooses the time period.
The system sends a confirmation email to the user after they have booked a flight.
The user can log into their account after entering the correct name and password.
The user can add the promocode and get a discount before checkout.
Only users with an admin level of access can view revenue data.
Different types of systems will have a number of typical requirements. Some of them will overlap with other product types, but others will be unique. Here, the variety is huge, so we’ll only provide a few examples.
An eCommerce website must have functional requirements that define how customers search for items, review their characteristics, make an order, pay, and receive confirmation.
Gaming software development will include functional requirements that describe how users overcome challenges, view their progress, receive rewards upon successful completion, etc.
Hotel management software must allow staff to manage incoming reservations, create and manage rate plans, accept payments, generate reports, etc.
Business intelligence applications must include various data management and visualization features, interactive options, analytical capabilities, and so on.
Now that you have a general idea, let’s dive a bit deeper and scrutinize the types of functional requirements.
Types of functional requirements
Just as you can categorize, say, monkeys by their color, size, or mischievousness levels, you can break down functional requirements into groups according to different criteria. We’ll explore the most widespread approaches.
Types based on the workflows covered
As we said, functional requirements define how the system or its components behave – and that includes a multitude of diverse workflows. Here are the main ones.
Business rules are usually the biggest group as they define how the system responds to commands in the main user flow.
Administrative functions include authorization permissions and related levels of access.
Data management concerns all the actions with information, such as storage, search, retrieval, archiving, deletion, etc.
Transaction management is about processing, correcting, adjusting, and canceling payments.
Reporting requirements outline how the reports are generated and managed.
External interfaces are the group of requirements that define how interfaces outside the main system are handled (e.g., a partner's website).
Legal and regulatory compliance ensures that the system adheres to policies, laws, regulations, and so on.
Types based on how functional requirements are documented
Even though the Agile philosophy is all about reducing the amount of technical documentation and time spent writing it, some paperwork still needs to be done. And requirements must also be written down so that they are clearly defined and shareable.
Check our video on how tech documentation is created and managed in software development
So the most popular functional requirements classification approach is related to their format. Here are the main ways they can be documented.
Software requirements specification (SRS) or product requirement document includes a list of all the functional and non-functional requirements the system or product must have. It also outlines the project purpose and description, team roles and responsibilities, assumptions, constraints, dependencies, and other information.
A sample SRS template. Source: Aha!
SRS can be a single document that contains all the requirement-related details, or it can be complemented by other formats like use cases, user stories, visuals, etc.
Use cases explain how users or other systems interact with the product via three components: actor, system, and goals. So use cases basically describe what the actor does, how the system responds, and which objective is achieved through this interaction.
Each use case is written as a sequence of simple steps and must include all possible scenarios of system behavior. They also outline the preconditions and exceptions to each interaction scenario.
Use cases can be presented in textual form (use case specification) that describes the interaction flow or in visual form (use case diagram) that outlines the main relationships between components.
A sample use case diagram. Source: UML diagrams
User stories describe the system functionality from the user’s perspective. They are succinct expressions written in an informal style and usually follow the format As a <type of user>, I want to <perform some action> so that <some reason or benefit>.
Unlike use cases, user stories themselves don’t give interaction details but rather provide general guidance, leaving developers room for creativity. However, accompanied by acceptance criteria, they exhaustively specify the requirements.
They also inspire communication over product design and help involve all stakeholders (even nontechnical ones) in discussions.
Work breakdown structure (WBS) or functional decomposition is a visual format that allows for presenting the system functionality as a diagram with a multilevel structure. It can be
- deliverable-based that breaks down the project into deliverables and the work scope required for each of them or
- phase-based that outlines key project stages and then defines either substages or deliverables for each stage.
A sample phase-based WBS for house construction. Source: Workbreakdownstructure.com
Prototypes are the early, most basic versions of a product or system with which users can interact. They aren’t written in code but created in special interactive tools. Prototypes are a simple, uncomplicated yet highly illustrative embodiment of functional requirements, so it’s a great way to help stakeholders actually see what the product will look like – and discover possible improvements at early stages.
You can learn more about prototypes, functional prototypes, and minimum viable products (as a form of advanced prototypes) in our dedicated posts.
Besides the most common formats we described, sometimes other approaches are also used such as creating models, diagrams, wireframes, mockups, etc.
How to write functional requirements: best practices
Gathering, documenting, and managing requirements is an important part of the development process that business analysts are responsible for – starting at the initiation phase and throughout the entire project. Well-documented functional requirements are crucial for the project's success because
- They provide guidance for developers;
- They create a clear vision of the end product and keep all stakeholders on the same page;
- They enable time and budget estimations; and
- They help discover gaps and areas for improvement.
Let’s look at every stage of requirements management and talk about how to optimize activities within them.
Requirements gathering
As we mentioned, it’s usually the business analyst’s task to collect requirements and manage them (though sometimes it can be the product manager's). Here are some tips about gathering functional requirements.
Define stakeholders. Identifying project stakeholders is an important first step since they will become the main source of requirements. Write a list of people who are involved in the project, can influence it, or are somehow interested in its outcome.
Select the interview format and prepare. It can be a casual conversation, a group brainstorming session, or an email questionnaire – choose the technique that suits the situation best and try to elicit maximum details from the interviewee. You can also prepare prototypes or use case scenarios to make it easier for stakeholders to define the exact requirements.
Interview stakeholders. Hold discussion sessions with stakeholders and ask questions about the product and their expectations of it.
Pro tip: Document everything. Take notes, save emails, and record your conversations. You might not need all the information later on, but this way, you’ll be sure not to miss anything important, and also you’ll have evidence in case of possible claims or miscommunications.
Choose the right stakeholders. Be careful about who to talk to because not all stakeholders have to be interviewed. For example, you definitely must talk to your customer, but probably interviewing such external stakeholders as regulatory bodies or data providers won’t help much.
Pro tip: Remember about internal stakeholders. Discuss the project scope with the project manager, developers, designers, testers, and other team members as they’ll probably have some valuable ideas about the product.
Research the market. You can also elicit information by exploring similar products on the market. Scrutinize what your competitors offer and examine the functionality of their products. Chances are you’ll come up with an idea or two.
Review the current system. In case you have to collect the requirements to work on an already existing product (that might need enhancement or modernization), test and observe the current system. Plus, scrutinize all the related documentation and articulate your interview questions accordingly to get as many details as possible.
Documenting requirements
Now that you have roughly outlined your functional requirements, you have to formalize them. No matter which format you choose, we have a few recommendations for you.
Follow the SMART schema. Well-written requirements are
- specific,
- measurable,
- achievable,
- relevant, and
- time-bound.
So when you write your requirements, evaluate them against these criteria to make sure they are workable.
Go into detail. Make your functional requirements granular. Also, record all possible use case scenarios and add as many acceptance criteria to your user stories as you can. It will help you better define the project scope and provide the basis for assessing product readiness.
Consider writing the SRS. Even though it takes time and contradicts some Agile frameworks (like Extreme Programming which tends to minimize documentation), consider creating a comprehensive requirement specification to have a shareable, detailed plan of your project with all requirements gathered in one place.
Get approval from stakeholders. Discuss your requirements documentation with stakeholders and make sure everyone agrees on the project scope and product functionality.
Requirements management
Writing a requirements document isn’t the end of the story. You have to manage requirements throughout the development process. That means reviewing them regularly, modifying them if needed, and/or adding new ones if new ideas come up as you iterate through the project. Here are several final tips from us.
Use software tools. Consider implementing specialized project management software where you can assign tasks, communicate, do visual planning, update requirements, and monitor progress (though, of course, you can just as well go with those Kanban boards and sticky notes).
Conduct backlog grooming. It’s basically the process of reviewing, validating, and prioritizing requirements. Read about backlog grooming in our dedicated explainer.
Collaborate. Engage stakeholders in the requirements reviewal process and encourage feedback and creativity.
Create a knowledge base. One of the ways to facilitate collaboration and keep everyone in the loop is by creating an internal knowledge base where you can store and manage all the project-related information.
Track progress. Update the status of the requirements regularly to keep stakeholders informed of your progress.
Test requirements. The final step of your work with functional requirements is testing or validation after they are implemented to make sure the product meets the user’s needs. You can learn how to conduct user acceptance testing in detail from our separate post.