Understanding Requirements
Requirements for a system are the descriptions of the services it provides and the
constraints it operates under. These requirements reflect what the customer needs the
system to do to solve a particular problem.
For example, Instagram was created to address the need for users to easily share photos
and videos with friends, follow updates from others, and discover new content. Defining
what Instagram should do and how it should function is what we call requirements
engineering (RE).
The process of requirements engineering involves finding out, analysing,
documenting, and verifying these requirements.
Example with Instagram:
Instagram’s requirements include services like sharing posts, stories, and reels, as well
as constraints like privacy settings and the requirement that all users must be over a
certain age.
types of readers or stakeholders who need to read and understand each.
1. User Requirements:
o These are high-level, general descriptions of what the system should do, usually
expressed in plain language. They are intended for people who need to
understand what the system will achieve but are not concerned with the
technical details of how it will be implemented.
o Readers of User Requirements:
Client Managers: Decision-makers from the client’s organization who
are concerned with how the system will meet business needs.
System End-Users: The people who will actually use the system once
it’s deployed. They are interested in the functionality and usability of
the system.
Client Engineers: Engineers from the client’s organization who need a
clear understanding of the system’s purpose and capabilities.
Contractor Managers: Managers responsible for overseeing the
project on behalf of the contracting company, ensuring it meets the
agreed specifications.
System Architects: High-level technical planners who need to
understand the overall goals of the system to create an appropriate
design.
2. System Requirements:
o These are detailed, precise descriptions of the system’s functions, features, and
constraints. System requirements provide technical specifics and leave little
ambiguity, often forming the basis for design and implementation.
o Readers of System Requirements:
System End-Users: In some cases, end-users might still need to
understand specific system functionalities at a more detailed level,
especially for advanced features.
Client Engineers: They need these specifics to align the system’s
capabilities with the client’s existing infrastructure or workflows.
System Architects: Architects use these details to develop a
comprehensive, technically sound design for the system.
Software Developers: Developers rely on system requirements as a
blueprint to build the system according to detailed specifications.
2. Types of Requirements
The term "requirement" can refer to different levels of detail, from high-level needs to
detailed technical specifications. We generally categorize them as
User Requirements and System Requirements.
2a. User requirements describe what users expect from the system in everyday
language(Natural Language).These are high-level, abstract statements of what the
system should provide and any constraints it should operate under. They are written in
simple language so they are easy for anyone, even those without technical knowledge,
to understand.
User requirements describe the overall goals of the system in natural language and
diagrams. They do not include details about how the system will work internally. User
requirements are important because they help set broad goals and expectations.
Example with Instagram: For Instagram, a user requirement might be "Allow
users to post photos and videos to share with their followers." Another user
requirement could be "Ensure all posts are only visible to the followers if the
user’s account is private."
2b. System requirements
System requirements are the detailed specifications of what a system should do. They
are more technical than user requirements and are written in a way that software
developers, engineers, and architects can use to guide the system’s actual
implementation. System requirements outline the specific functions, operations,
constraints, and interactions that the system must meet to satisfy the user and business
needs.
In general, system requirements are categorized into two types: Functional
Requirements and Non-functional Requirements.
1. Functional Requirements
Definition: Functional requirements specify what the system should do. They describe
the behavior, actions, and operations the system must perform. These requirements
focus on specific functions and features, like data input, data processing, and expected
outputs.
Functional requirements often answer questions like:
What functions should the system perform?
How should the system respond to specific inputs?
What operations or processes should the system complete?
Example with Instagram: Let’s consider some functional requirements for Instagram
to help understand this concept:
Post Photos and Videos: The system should allow users to upload photos and
videos with a limit of 10 MB per file. Users should be able to add captions and
tags to each post.
Like and Comment on Posts: The system should allow users to like and
comment on others' posts. Each comment should display the username and
timestamp.
Direct Messaging: The system should enable users to send private messages to
other users. Messages should support text, images, and emojis.
User Authentication: The system should authenticate users using a username
and password. It should support account recovery in case a user forgets their
password.
Each of these functional requirements outlines a specific action the system must
perform, often with some details about limits or constraints.
2. Non-functional Requirements
Definition: Non-functional requirements describe the quality attributes, performance,
and constraints of the system. They do not focus on specific functions but rather on how
the system performs under certain conditions. Non-functional requirements are crucial
for defining the user experience, security, and overall system reliability.
Non-functional requirements answer questions like:
How fast should the system respond?
How secure should user data be?
What should the user experience look like?
How many users should the system handle simultaneously?
Non-functional requirements can be further categorized into types, such as:
a. Performance Requirements
Example with Instagram: The system should load images and videos in under
2 seconds on standard 4G internet. The app should support up to 100,000 active
users at any given time.
b. Security Requirements
Example with Instagram: All user data should be encrypted in transit and at
rest. Users should be automatically logged out after 15 minutes of inactivity.
c. Usability Requirements
Example with Instagram: The user interface should be intuitive, allowing new
users to learn to navigate within 5 minutes. Features like "posting" and
"messaging" should be easily accessible.
d. Availability Requirements
Example with Instagram: The system should be available 99.9% of the time,
with a maximum downtime of 1 hour per month. Regular maintenance updates
should be scheduled during off-peak hours.
e. Maintainability Requirements
Example with Instagram: The codebase should be modular to support future
updates and changes with minimal disruption. Developers should be able to add
new features or fix bugs without affecting existing functionality.
Importance of System Requirements
System requirements are crucial because they:
Guide Development: By defining exact requirements, they give developers a
clear roadmap on how to build the system.
Reduce Errors: Well-defined system requirements help prevent
misunderstandings, reducing the risk of rework or errors later in the development
process.
Ensure Quality: Non-functional requirements ensure that the system meets
quality standards, so it’s not just functional but also performs well, is secure, and
is user-friendly.
Example of System Requirements Document for Instagram
Here is a brief example of what a section of a system requirements document might
look like for Instagram, combining both functional and non-functional requirements.
1. Functional Requirements
FR1: The system shall allow users to create and manage a profile, including
adding a profile picture, bio, and other personal information.
FR2: The system shall allow users to post photos and videos, with support for
captions and tagging other users.
FR3: The system shall enable users to like and comment on posts, with each
comment displaying the username and timestamp.
FR4: The system shall allow users to follow and unfollow other users.
FR5: The system shall provide a search feature that allows users to search for
profiles, hashtags, and locations.
2. Non-functional Requirements
NFR1 (Performance): The system should be capable of handling 1,000,000
concurrent users with an average response time of less than 3 seconds.
NFR2 (Security): All user data should be encrypted using AES-256 during
storage and SSL/TLS during transmission.
NFR3 (Usability): New users should be able to understand how to upload a
photo within their first 5 minutes of using the app.
NFR4 (Availability): The application should be available 99.9% of the time,
allowing for scheduled maintenance only once a month.
NFR5 (Maintainability): The application code should be structured to support
modular updates without affecting existing features. Each module should be
documented for future development.
Why Are System Requirements Important?
Having clear and well-defined system requirements ensures that all aspects of the app
are well thought-out, from the functionality that users interact with to the internal
structure that developers maintain. System requirements help the development team
stay aligned with the business goals, while also ensuring that technical performance,
security, and usability expectations are met.
System requirements bridge the gap between the business's vision and the technical
implementation by specifying both what the system should do (functional requirements)
and how well it should do it (non-functional requirements).
This structure not only ensures that Instagram (or any app) meets user expectations but
also allows it to scale, remain secure, and be easily maintainable in the long term.