A Novel Approach for Software Requirement
Prioritization Based Upon Non Functional Requirements
Kashif Ayub, Farooque Azam, Muhammad Waseem Anwar, Anam Amjad and Muhammad Shah Jahan
Department of Computer Software Engineering, National University of Sciences & Technology (NUST),
Abstract- Software becomes an essential part of our lives
because of the required automation in every field. A software
requirement plays an important role in its development. In
requirement engineering, requirement prioritization is the
crucial activity to
ly deliver the software system.
Numerous techniques exist for software requirement
prioritization such as Cumulative Voting, Hieratical
Cumulative Voting, Planning Games (PG), and MOSCOW etc.
But it is analyzed that these techniques are insufficient to
prioritize large number of requirements and in most of the
cases requirement engineer just prioritizes the functional
requirements and ignore non
functional requirements. It
becomes a challenge to prioritize Non-Functional
Requirements (NFRs) in order to justify which requirement
has higher priority along with functional requirements in large
software systems. In order to overcome this gap, we have
proposed a novel approach ”PGAHP” for Requirements
Prioritization by merging Planning Games (PG) and analytical
hierarchy process (AHP) c
oncepts. Proposed approach
PGAHP is validated using Library Management System case
study. Results shows that complexity to prioritize requirements
is decreased by using ”PGAHP”by performing thirty one (31)
pair of comparison as compare to AHP which has (105) pair
wise comparison for the same number of functional and non-
Keywords-Components: Software requirement
prioritization; analytical hierarchy process; Non-functional
Requirements are very important aspect of software
development. Software projects like other projects have
tight schedule, scope and cost. There should be some type of
requirement prioritization so that the development team
manages their resource and the customer could get their
most important functionally as soon as possible. Among the
activities of Software Development Life Cycle (SDLC)
which includes feasibility study, requirement collection,
requirement validation, requirement specification and
management. Requirement prioritization is one of the most
important activities of requirement engineering process.
Until, we do not categorize the requirements according to
business value or its ro
le to obtain business goals, it is not
possible to achieve success of the software project.
For this purpose, we need to prioritize the Functional
requirements (FRs)  in such a way that we can visualize
which requirements should be implemented first and which
should be in next release. There are different requirement
prioritization techniques among which Analytical Hierarchy
Processing (AHP) is one of the popular techniques of
prioritizing requirements  which helps to find out the
order of requirements by comparing each requirement with
other requirements to ease requirement engineer.
Other well-known requirements prioritization techniques
are Planning Game (PG), Cumulative voting and MOSCOW
etc. . A new trend is use of fuzzy logic in different
existing techniques for requirement prioritization like 
Fuzzy Logic  and Decision Tree Adaptive Fuzzy
Hierarchical Cumulative Voting and
Fuzzy Moscow etc.
The need to prioritize the requirements  is to avoid
project delays and failures. If we do not use appropriate
requirement prioritization technique, its leads to project
failure . It is analyzed that most research studies focus on
the functional requirement prioritization and neglect the
NFRs while prioritizing FRs . It is also observed that
non-functional requirements are avoide
d in those cases
where requirement engineer deals with large number of
requirements. It means if we have hundreds of requirements
and if we want to apply AHP on those requirements this
way will be very complex to deal with the N*M number of
requirements. If we have fifteen (15) requirements, we need
to construct one hundred and five (105) pairwise
comparisons. It becomes time consuming activity and it is
difficult to manage.
As shown in Fig.
1, our proposed novel approach 
“PGAHP” is the combination of planning games, AHP and
also Non-functional requirements. We will apply planning
games on all functional requirements which helps to reduce
the complexity by dividing all FRs into three sections
according to their business value and it will also resolve the
problem of the two or more requirements which have same
priority by the help of NFRs. User involvement is very
important because of the successful implementation of
2019 7th International Conference in Software Engineering Research and Innovation (CONISOFT)
978-1-7281-2524-4/19/$31.00 ©2019 IEEE
Fig.1. Overview of research
Rest of the paper is structured as follows. Section II
provides the extensive literature review on requirement
prioritization techniques. In Section III, proposed
methodology is described. Section IV highlights the
validation of the proposed approach using case study. The
discussion is carried out in Section V. Finally, Section VI
concludes the research with future directions.
II. LITERATURE REVIEW
Umang Garg.  Presented that software system is
developed on the basis of functional requirements. If we do
not prioritize the functional requirements, then it will affect
badly while delivering the software because in most of the
cases prioritization is performed on the basis of functional
requirement and neglects the non-functional requirements.
In this paper, author has
used a pairwise comparison to
assign the important value to Non-Functional Requirements
(NFRs) and then prioritize the Functional Requirement
(FRs) on the basic of non-functional requirements using
Analytical Hierarchy Processing (AHP).
Richard R. Maiti.  describes that while developing
software in agile which is a quick pr
ocess of d
also favors the functional requirement and disregard non-
functional requirements which can have adverse effect on
the software. Result will be low quality and high cost. They
use CEP methodology which use to Alpha Beta Gamma
Framework in prioritizing NFRs. The flexibility of the
process is the ease of allowing sub processes to be
interchange by other technique.
Fadoua Fellir  presented that in most of the cases
software applications are developed on the basis of FRs and
disregard NFRs which have negative impact on
development process and also on the of deployment will
increase the cost and time reduce the quality on the
software. In this paper, they present pairwise prioritization
process by considering interdependency relationship
between FR and NFR. This is also very useful to overcome
the weak points of the AHP.
Raj Kumar Chopra.  described the importance of the
functional requirements which is not demanded by the
user. They use three approaches for requirement
prioritization for functional and nonfunctional requirements
using AHP and then prove the better approach. They have
proposed hybrid approach in which NFRs are prioritized
independently like FR but their selection must be
accordance to functionality of the software.
Mohamad Kassab.  Contributed in the direction of
NFRs which are very difficult to manage because they are
highly interdependent with each other and changing one
requirement can have a great effect on the other
requirements. To solve this problem, authors have used
NFRs existing framework with AHP to overcome the
problem of dependency. Similarly, in another paper,
Mohammad Dabbagh.  Highlighted that requirements
prioritization is critical but neglected during software
development. They introduce an approach Named Hybrid
Assessment Method (HAM) with state of the art approach
AHP to prioritize both function and non-functional
requirement at the same time.
Nelly Condori-Fernandez.  used nominal based
prioritization technique. This technique collects Top 10
requirements at which one requirement is more important
than the other. The ordinal based technique (e.g. CV and
ranking) are not able to quantify the relative priority of
Few research studies proposed new requirement
prioritization technique such as Sher, F., et al.  proposed
software requirement prioritization techniques depending
upon technical, business and client aspect. It compares not
only existing nine techniques like bubble sort, AHP, NAT
etc. but also a hybrid approach which is using Planning
Game(PG) with AHP. First divide requirements into three
groups which are on ordinal scale and then apply AHP.
Sadiq.  proposed
a new algorithm for
Software Requirement Prioritization which is
AHP_GORE_PSR. This algorithm works using AHP on
AGORA. In AGORA there is no support to check whether
the decision was consistent or nor. They apply AHP on this
set of requirements.
Among these requirement prioritization techniques,
every technique has advantages and disadvantages. To
overcome the issue of prioritizing large number of
functional and non-functional requirements, we have
selected planning game and AHP which are widely used in
A. Planning games
The planning game technique is mostly used in
the software planning process in context of
agile development . The planning game is a meeting
consisting of both the developers and the customers.
Planning games is used to prioritize the requirements in
three sections defined by the user according to its business
objectives. These sections will be according to “th
without which the system will not function”, “those that are
less essential but significant business value” and “Those
would be nice to have”. User will drop its extremely
important requirements in first section and very important in
second section and least important in third section
accordingly. This will reduce the complexity and of n (n-
This is mostly used technique introduced by Thomas
Satty in 1970.Pairwise comparison[3, 17] is used in this
technique to estimate the importance of the requirements
with each other. By this we become able to justify which
requirement is most important and which is least important.
This helps us to determine which requirements should be
included in the first release and vice versa.
This technique uses pairwise comparison of all user
requirements. The requirement umber of comparison grows
polynomial, for example if we have n number of
requirements then the comparison, we need to do n(n-1)/2
comparisons which are quite complex for large set of
III. PROPOSED METHODOLOGY
In this section, we will explain our proposed technique
which is the combination of planning games, AHP and non-
functional requirements. We will apply AHP on planning
games and then also resolve the problem of two or more
requirements having same priority.
Table I: PGAHP as novel approach
Now, we will define our approach which is the
combination of planning games and AHP and NFRs at last
. The main purpose of requirements prioritization is to
provide most important requirements of the user in first
release and so on. Planning games divide the requirements
into three sections which reduces the complexity while
handling and make us able to visualize which is most
important for user. If we are dealing with big project then
it’s very difficult to deliver all high priority requirements
which rely in first section at the same time. This is because
we will apply AHP on each section it will help us to make
us able to know which requirements have more priority in
same section. Our proposed methodology includes
following steps as represented in Fig.2.
1. Collect all functional and their related non-
functional requirements from the user using a good
elicitation technique and well defined format
2. Define three section (“1.those without which the
system will not function”, “2.those that are less
essential but significant business value” and
“3.Those would be nice to have”) and ask user to
ts requirements into these section according
to its business objectives.
3. Construct pairwise comparison of all the functional
requirements in section 1 and take sum of each
4. Take average of each field and normalize the
5. Take sum of each row and get priority sum and
produce percentage of each requirement.
6. Collect those functional requirements which
same probability. If yes move to step 7 else move
to step 10.
7. Collect NFRs of the functional requirements
related to them which have same probability.
8. Apply pairwise comparison using AHP on FRs and
their related NFRs.
9. Compare the requirements and produce the result
in prioritized form.
10. Make decision and start from step 3 for 2nd section
and so on till no section left.
Overview of PGAHP
As the user participation is increased it will help the
requirements engineer to give idea which requirements are
more important for user to achieve their business goal and
also provide idea which requirements are need to deliver
first. It is important to mention that requirements for
proposed solution are mentioned. It includes the following
1. Collect all function and their related non-functional
2. Requirements should be in textual form using well
defined elicitation technique.
3. User should have knowledge of its business goals
and objectives to divide its requirements into three
sections in planning games.
4. Developer should have knowledge of non-
functional requirements related to each functional
requirement to get from user for applying AHP on
5. The format of output will be textual. Tabular data
will be presented.
Here, our proposed technique is validated using Library
Management System (LMS) case study. The aim of this
Library Management system is to provide functionality of
issues in book to the students of different courses. Library
Management System will show all the available books,
generate the priority of students, send SMS to users when
book available, candidate returned books on date if not then
will submit fine of RS.
20 per day as late returned fee.
Step 1: Collect all the functional requirements and NFRs in
R1: There should be a Login module of LMS
R2: There must be a Check the availability of the books
R3: The system would generate the priority of the students
R4: Information of availability of books would be sent
R5: There should be list of Candidates who have submitted
books after due date
R6: fee should be submitted for late book
R7: It could inform the Chief Librarian, if the book is not
available for a particular course
R8: It must provide inter-library loan module
R9: The data of all users and books should be stored in
R10: There Must provide electronic packing slip when
provide a book as loan
R11: Should authenticate the checkout of journals, books
Check out the returning material must be using
R13: When a student brings personal books, it would be
R14: The librarian should add new books or update existing
R15: It must provide online public access catalog providing
Step 2: Apply planning games technique on all FRs and ask
user to divide requirements into three set according to its
Table II: Applying planning games
Section 1 (Extremely
User involvement is very important to make this partition.
This partition is totally defined on the basis of user business
priorities and according to the need of the user to get their
business goals. So we develop a partition As shown in Table
, R8, R10, R12, R15 belongs to section 1 which means
“those without which the system will not function” we will
give these requirements in the first release. R2, R5, R6, R9,
R11, R14 belongs to section 2 which means “those that are
less essential but significant business value” and R3, R4,
R7, R13 belongs to section 3 which means “Those would be
nice to have”.
Step 3:Now apply AHP on all functional requirements
of first section using pairwise comparison matrix.
Table III: Pairwise comparison matrix
As shown in Table III, we will construct a pairwise for
comparing FRs in section 1 with each other. We will
compare each requirement with all other requirements in
first section and assign intensity of importance to each
requirement as shown Table II. And then we will calculate
the sum of all the columns separately. Pairwise comparison
value for section 1 will be 5(5-1)/2=10. If do not apply
planning games then for all the requirements will be 15(15-
1)/2=105 and it becomes very difficult to deal with large
number of requirements.
Step 4: In this section we will take average of each field by
taking the sum of its related column and then normalize
Table IV: Averaging and normalizing of matrix
Step 5: Take the sum of all the rows and then divide the sum
by the number of requirements
By performing this action, we will be able to visualize
which requirement has more probability and will generate
the percentage of each requirement by multiplying priority
sum by hundred.
Table V: Priority Values and Percentage
Sum of Row
Step 6: In this section we will collect functional
requirements R1 and R15 because both have same
probability as shown in Table V.
Table VI: Percentage
Step 7: In this step we will collect NFRs,  related to
these two functional requirements. As we know both
requirements have same priority.
Table VII: Pairwise comparison
R1 have following NFRs
NFR2: budget constrain
NFR3: response time constraint
NFR4: Using C++ language is needed
R15 have following NFRs
NFR1: using existing software resources
Step 8: In this step we will apply pairwise comparison
using AHP  on the both functional and their related
AHP for R1
Comparison between R1 and its related non-functional
Table VIII: Pairwise comparison matrix
Sum of column
Averaging and adjustment: In this step, we will divide
each field by the sum of columns.
Table IX: Averaging and normalizing of matrix
Get Sum of Rows And priority Sum: Here, we will take
the sum of each row and also calculate the priority sum by
dividing sum of row by number of requirements
Table X: Priority Values and percentage
Sum of Rows
AHP for R15: Comparison between R15 and its related
non-functional requirements is shown below.
TABLE XI: Pairwise comparison matrix
Sum of Column
Averaging and adjustment: In this section we will divide
each field by the sum of column as presented.
Table XII: Averaging and normalizing of matrix
Get sum of rows And priority Sum: Here we will take the
sum of each row and also calculate the priority sum by
dividing sum of row by number of requirement.
Table XIII: Priority Values
Step 9: Here we will compare the functional requirement
priority or percentage with its related non-functional
Before applying AHP on functional and its related non-
After apply AHP on functional and its related non-
functional requirement NFR1 have greater priority then R1.
After this we can clearly see
After this the requirement engineer can clear visualize
which requirements out of both requirements have more
priority. And its help which implementation of the
Step 10: In this section requirement engineer will implement
the requirements or leave this here and move to the next.
This step is up to the organization. After the completion of
this step, proceed to step 3 for 2nd
on and implement all
the steps for second sections and so on till no section left.
As we defined before we are reducing the complexity and
memory of pairwise comparison by applying AHP. We can
prove it simply by applying the formula for counting the
total number of pairwise comparison n(n-1)/2. Here n is
number of requirements if put values in it.
Number of pairwise comparison for section 1
Numbers of requirements in section 1 are five (5). By
putting the values in formula we obtain following number of
Number of pairwise comparison for section 2
Numbers of requirements in section 2 are six (6) and by
putting the values in formula, we get following number of
Number of pairwise comparison for section 2
Numbers of requirements in section 3 are four (4) and by
putting the values in formula, we get the following results.
Total number of pairwise comparison for all three sections
will be thirty one (10+15+6=31).
Total number of comparison without planning games:
Total number of requirements is one. By putting values, we
get following number of comparisons.
As we can clearly see in Fig. 3, we can reduce the
complexity by applying planning games on requirements.
Fig.3. PGAHP and AHP pairwise comparison on 15 FRS
VI. CONCLUSION AND FUTURE WORK
In order to perform efficient requirement prioritization,
few problems are analyzed which are length of comparison
matrix for hundreds of requirements and ignorance of Non-
Functional Requirements. To resolve these fundamental
issues, PGAHP is proposed which is a novel approach for
software requirement prioritization based upon non-
functional requirements. Following contributions are made.
Firstly we are dealing with the length of pairwise
comparison for hundreds of requirements by dividing all the
rements using planning games. Secondly,
prioritization of all the functional requirements by applying
AHP on each set of requirements is performed. Lastly, we
found those requirements which have same priority and also
find their related non-functional requirements. Our proposed
technique is applicable also on those projects which have
large number of requirements. Moreover, this approach can
be extended with user’s involvement which is also very
essential because of the planning games implement
 Ahuja, H. and G. Purohit. Understanding
requirement prioritization techniques. in 2016
International Conference on Computing,
Communication and Automation (ICCCA). 2016.
 Sufian, M., et al. A Systematic Literature Review:
Software Requirements Prioritization Techniques.
in 2018 IEEE International Conference on
Frontiers of Information Technology (FIT). 2018.
 Amelia, T. and R.B. Mohamed. Review on Cost-
Value Approach for Requirements Prioritization
Techniques. in 2018 5th International Conference
on Information Technology, Computer, and
Electrical Engineering (ICITACEE). 2018. IEEE.
 Jawale, B.B., G.K. Patnaik, and A.T. Bhole.
Requirement prioritization using adaptive fuzzy
hierarchical cumulative voting. in 2017 IEEE 7th
International Advance Computing Conference
(IACC). 2017. IEEE.
 Yousuf, M., M.U. Bokhari, and M. Zeyauddin. An
analysis of software requirements prioritization
techniques: A detailed survey. in 2016 3rd
International Conference on
Sustainable Global Development (INDIACom).
 Chandani, P. and C. Gupta. Requirement Risk
Prioritization Using Analytic Hierarchy Process: A
Gateway to Identify Risky Requirements. in 2018
Eleventh International Conference on
Contemporary Computing (IC3). 2018. IEEE.
 Santos, R., A. Albuquerque, and P.R. Pinheiro,
Towards the Applied Hybrid Model in
Requirements Prioritization. Procedia Computer
Science, 2016. 91: p. 909-918.
 Garg, U. and A. Singhal. Software requirement
rioritization based on non-functional
requirements. in 2017 7th IEEE International
Conference on Cloud Computing, Data Science &
 Maiti, R.R. and F.J. Mitropoulos. Prioritizing non-
functional requirements in agile software
engineering. in Proceedings of the SouthEast
Conference. 2017. ACM.
 Fellir, F., K. Nafil, and R. Touahni. System
requirements prioritization based on AHP. in 2014
Third IEEE International Colloquium in
Information Science and Technology (CIST). 2014.
 Chopra, R.K., V. Gupta, and D.S. Chauhan,
Experimentation on accuracy of non functional
requirement prioritization approaches for different
complexity projects. Perspectives in Science, 2016.
8: p. 79-82.
 Kassab, M. An integrated approach of AHP and
NFRs framework. in IEEE 7th International
Conference on Research Challenges in Information
Science (RCIS). 2013.
 Dabbagh, M. and S.P. Lee, An approach for
integrating the prioritization of functional and
nonfunctional requirements. The Scientific World
 Condori-Fernandez, N., M.F. Granda, and T.E.
Vos. Towards a functional requirements
prioritization with early mutation testing. in
Proceedings of the 5th ACM International
Workshop on Requirements Engineering and
 Sher, F., et al. Requirements prioritization
techniques and different aspects for prioritization a
systematic literature review protocol. in 2014 8th.
IEEE Malaysian Software Engineering Conference
 Asghar, A.R., et al. Impact and challenges of
requirements elicitation & prioritization in quality
to agile process: Scrum as a case scenario. in 2017
IEEE International Conference on Communication
Technologies (ComTech). 2017.
 Sadiq, M., T. Hassan, and S. Nazneen.
AHP_GORE_PSR: Applying analytic hierarchy
process in goal oriented requirements elicitation
method for the prioritization of software
requirements. in 2017 3rd IEEE International
Conference on Computational Intelligence &
Communication Technology (CICT). 2017.
 Asghar, A.R., et al., The impact of analytical
assessment of requirements prioritization models:
an empirical study. 2017.
 Shao, F., et al., DRank: A semi-automated
requirements prioritization method based on
preferences and dependencies. Journal of Systems
and Software, 2017. 126: p. 141-156.
 Ahmad, K.S., et al. Fuzzy_MoSCoW: A fuzzy
based MoSCoW method for the prioritization of
software requirements. in 2017 IEEE International
Conference on Intelligent Computing,
Instrumentation and Control Technologies