A Short Guide to Writing Software Requirements. Writing good software requirements takes skill, practice, and patience. The key questions we face are: What type of language do we use? What level of detail do we need? In what form should we document and present the requirements? When faced with the prospect of writing requirements, many. Software Requirements Specification Amazing Lunch Indicator Sarah Geagea 8. “Just Enough Requirements Management: Where Software Development Meets Marketing”, New York, Dorset House Publishing, 2005. For example show when there is a new update. Software requirement is a functional or non-functional need to be implemented in the system. Functional means providing particular service to the user. For example, in context to banking application the functional requirement will be when customer selects 'View Balance' they must be able to look at their latest account balance. For example, a new course added to the mainframe based registration system will require a source code change and recompilation of the main VRU program. 5.3 Proprietary hardware and software VRU system requires proprietary hardware and software from Call Center Technology in order to be operational. 5.4 Batch updates vs. (close) Real-time updates. Sep 18, 2017  An example is if the requirement is “Add Product to Cart,” a command that doesn’t account for other details like size and quantity. These can be fleshed out with the Analysis Model since it connects functional requirements with the design. Software Requirements Specification document with example A Software Requirements Specification (SRS) is a document that describes the nature of a project, software or application. In simple words, SRS document is a manual of a project provided it is prepared before you kick-start a project/application.

• Software Requirements Specification Example For Mobile Applications
• Example Of A Requirements Document
• Software Functional Requirements Examples
• Functional Requirements Software Examples

If there is any one thing any project must have in order not to be doomed to failure, that is a sensible and comprehensive collection of both the functional and non-functional requirements.

Any project’s requirements need to be well thought out, balanced and clearly understood by all involved, but perhaps of most importance is that they are not dropped or compromised halfway through the project.

However, what exactly is the difference between ‘functional’ and ‘non functional’ requirements? It’s not that complex, and once you understand the difference, the definition will be clear.

The official definition of ‘a functional requirement’ is that it essentially specifies something the system should do.

Typically, functional requirements will specify a behaviour or function, for example:
“Display the name, total size, available space and format of a flash drive connected to the USB port.” Other examples are “add customer” and “print invoice”.

A functional requirement for a milk carton would be “ability to contain fluid without leaking”

Some of the more typical functional requirements include:

Software Requirements Specification Example For Mobile Applications

• Business Rules
• Transaction corrections, adjustments and cancellations
• Administrative functions
• Authentication
• Authorization levels
• Audit Tracking
• External Interfaces
• Certification Requirements
• Reporting Requirements
• Historical Data
• Legal or Regulatory Requirements

So what about Non-Functional Requirements? What are those, and how are they different?

Simply put, the difference is that non-functional requirements describe how the system works, while functional requirements describe what the system should do.

The definition for a non-functional requirement is that it essentially specifies how the system should behave and that it is a constraint upon the systems behaviour. One could also think of non-functional requirements as quality attributes for of a system.

A non-functional requirement for a hard hat might be “must not break under pressure of less than 10,000 PSI”

Non-functional requirements cover all the remaining requirements which are not covered by the functional requirements. They specify criteria that judge the operation of a system, rather than specific behaviours, for example: “Modified data in a database should be updated for all users accessing it within 2 seconds.”

Some typical non-functional requirements are:

• Performance – for example Response Time, Throughput, Utilization, Static Volumetric
• Scalability
• Capacity
• Availability
• Reliability
• Recoverability
• Maintainability
• Serviceability
• Security
• Regulatory
• Manageability
• Environmental
• Data Integrity
• Usability
• Interoperability

As said above, non-functional requirements specify the system’s ‘quality characteristics’ or ‘quality attributes’.

Many different stakeholders have a vested interest in getting the non-functional requirements right particularly in the case of large systems where the buyer of the system is not necessarily also the user of the system.

The importance of non-functional requirements is therefore not to be trifled with. One way of ensuring that as few as possible non-functional requirements are left out is to use non-functional requirement groups. For an explanation on how to use non-functional requirement group, read this blog post which will give you four of the main groups to use.

Join 60,000+ Subscribers

For latest blogs, industry updates and exclusive tips.

*Your email is safe with us, we also hate spam

Home > Articles

1. 1.4 Characteristics of a Good Requirement

1.4 Characteristics of a Good Requirement

A requirement needs to meet several criteria to be considered a “good requirement” [HUL05][LEF03][LUD05][YOU01]. Good requirements should have the following characteristics:

• Unambiguous
• Testable (verifiable)
• Clear (concise, terse, simple, precise)
• Correct
• Understandable
• Feasible (realistic, possible)
• Independent
• Atomic
• Necessary
• Implementation-free (abstract)

Besides these criteria for individual requirements, three criteria apply to the set of requirements. The set should be

• Consistent
• Nonredundant
• Complete

The sample project used in this book is an online travel agency, as shown in Figure 1.2. You’re probably familiar with this type of application because variations of it can be found on several websites. The project is complex enough to show possible relationships between various requirements types, but it is small enough to be easily understood. Most of the examples in this chapter (and the other chapters) are related to this project.

Figure 1.2 The home page of an online travel agency.

Let’s discuss each of the criteria of a good requirement and show some examples.

Unambiguous

There should be only one way to interpret the requirement. Sometimes ambiguity is introduced by undefined acronyms:

• REQ1The system shall be implemented using ASP.

Does ASP mean Active Server Pages or Application Service Provider? To fix this, we can mention a full name and provide an acronym in parentheses:

• REQ1The system shall be implemented using Active Server Pages (ASP).

Here’s another example:

• REQ1The system shall not accept passwords longer than 15 characters.

It is not clear what the system is supposed to do:

• The system shall not let the user enter more than 15 characters.
• The system shall truncate the entered string to 15 characters.
• The system shall display an error message if the user enters more than 15 characters.

The corrected requirement reflects the clarification:

• REQ1The system shall not accept passwords longer than 15 characters. If the user enters more than 15 characters while choosing the password, an error message shall ask the user to correct it.

Some ambiguity may be introduced through the placement of a certain word:

• REQ1On the “Stored Flight” screen, the user can only view one record.

Does this mean that the user can “only view,” not delete or update, or does it mean that the user can view only one record, not two or three?

One way to fix the problem is to rewrite the requirement from the system’s point of view:

• REQ1On the “Stored Flight” screen, the system shall display only one flight.

Testable (Verifiable)

Testers should be able to verify whether the requirement is implemented correctly. The test should either pass or fail. To be testable, requirements should be clear, precise, and unambiguous. Some words can make a requirement untestable [LUD05]:

• Some adjectives: robust, safe, accurate, effective, efficient, expandable, flexible, maintainable, reliable, user-friendly, adequate
• Some adverbs and adverbial phrases: quickly, safely, in a timely manner
• Nonspecific words or acronyms: etc., and/or, TBD

Such a requirement might look something like this:

• REQ1The search facility should allow the user to find a reservation based on Last Name, Date, etc.

In this requirement, all search criteria should be explicitly listed. The designer and developer cannot guess what the user means by “etc.”

Other problems can be introduced by ambiguous words or phrasing:

• Modifying phrases: as appropriate, as required, if necessary, shall be considered
• Vague words: manage, handle
• Passive voice: the subject of the sentence receives the action of the verb rather than performing it

  • REQ1The airport code shall be entered by the user.

  • REQ2The airport code shall be entered.

The first example shows a classic example of passive voice. In active voice it would read “The user shall enter the airport code.” As the second example shows, another result of the use of passive voice is that the agent performing the action is sometimes omitted. Who should enter this code—the system or the user?

Example Of A Requirements Document

• Indefinite pronouns: few, many, most, much, several, any, anybody, anything, some, somebody, someone, etc.

  • REQ1The system shall resist concurrent usage by many users.

What number should be considered “many”—10, 100, 1,000?

Clear (Concise, Terse, Simple, Precise)

Requirements should not contain unnecessary verbiage or information. They should be stated clearly and simply:

• REQ1Sometimes the user will enter Airport Code, which the system will understand, but sometimes the closest city may replace it, so the user does not need to know what the airport code is, and it will still be understood by the system.

This sentence may be replaced by a simpler one:

• REQ1The system shall identify the airport based on either an Airport Code or a City Name.

Correct

If a requirement contains facts, these facts should be true:

• REQ1Car rental prices shall show all applicable taxes (including 6% state tax).

The tax depends on the state, so the provided 6% figure is incorrect.

Understandable

Requirements should be grammatically correct and written in a consistent style. Standard conventions should be used. The word “shall” should be used instead of “will,” “must,” or “may.”

Feasible (Realistic, Possible)

The requirement should be doable within existing constraints such as time, money, and available resources:

• REQ1The system shall have a natural language interface that will understand commands given in English language.

This requirement may be not feasible within a short span of development time.

Independent

To understand the requirement, there should not be a need to know any other requirement:

• REQ1The list of available flights shall include flight numbers, departure time, and arrival time for every leg of a flight.

• REQ2It should be sorted by price.

The word “It” in the second sentence refers to the previous requirement. However, if the order of the requirements changes, this requirement will not be understandable.

Atomic

The requirement should contain a single traceable element:

• REQ1The system shall provide the opportunity to book the flight, purchase a ticket, reserve a hotel room, reserve a car, and provide information about attractions.

This requirement combines five atomic requirements, which makes traceability very difficult. Sentences including the words “and” or “but” should be reviewed to see if they can be broken into atomic requirements.

Necessary

Software Functional Requirements Examples

A requirement is unnecessary if

• None of the stakeholders needs the requirement.

or

• Removing the requirement will not affect the system.

An example of a requirement that is not needed by a stakeholder is a requirement that is added by developers and designers because they assume that users or customers want it. For example, the fact that a developer thinks that users would like a feature that displays a map of the airport and he knows how to implement it is not a valid reason to add this requirement.

An example of a requirement that can be removed because it does not provide any new information might look like the following:

• REQ1All requirements specified in the Vision document shall be implemented and tested.

Implementation-free (Abstract)

Requirements should not contain unnecessary design and implementation information:

• REQ1Content information shall be stored in a text file.

How the information is stored is transparent to the user and should be the designer’s or architect’s decision.

Consistent

There should not be any conflicts between the requirements. Conflicts may be direct or indirect. Direct conflicts occur when, in the same situation, different behavior is expected:

• REQ1Dates shall be displayed in the mm/dd/yyyy format.

• REQ2Dates shall be displayed in the dd/mm/yyyy format.

Sometimes it is possible to resolve the conflict by analyzing the conditions under which the requirement takes place. For example, if REQ1 was submitted by an American user and REQ2 by a French user, the preceding requirements may be rewritten as follows:

• REQ1For users in the U.S., dates shall be displayed in the mm/dd/yyyy format.

• REQ2For users in France, dates shall be displayed in the dd/mm/yyyy format.

This can eventually lead to the following requirement:

• REQ3Dates shall be displayed based on the format defined in the user’s web browser.

Another example of a direct conflict can be seen in these two requirements:

• REQ1Payment by PayPal shall be available.

• REQ2Only credit card payments shall be accepted.

In this case the conflict cannot be resolved by adding conditions, so one of the requirements should be changed or removed.

Indirect conflict occurs when requirements do not describe the same functionality, but it is not possible to fulfill both requirements at the same time:

• REQ1System should have a natural language interface.

• REQ2System shall be developed in three months.

Some requirements do not conflict, but they use inconsistent terminology:

• REQ1For outbound and inbound flights, the user shall be able to compare flight prices from other, nearby airports.

• REQ2The outbound and return flights shall be sorted by the smallest number of stops.

To describe the same concept, in the first requirement the term “inbound flights” is used, and in the second requirement the term “return flights” is used. The usage should be consistent.

Nonredundant

Each requirement should be expressed only once and should not overlap with another requirement:

• REQ1A calendar shall be available to help with entering the flight date.

• REQ2The system shall display a pop-up calendar when entering any date.

The first requirement (related to only the flight date) is a subset of the second one (related to any date entered by the user).

Complete

A requirement should be specified for all conditions that can occur:

• REQ1A destination country does not need to be displayed for flights within the U.S.

• REQ2For overseas flights, the system shall display a destination country.

What about flights to Canada and Mexico? They are neither “within the U.S.” nor“overseas.”

All applicable requirements should be specified. This is the toughest condition to be checked. There is really no way to be sure that all the requirements are captured and that one week before the production date one of the stakeholders won’t say, “I forgot to mention that I need one more feature in the application.”

A good requirement should have more criteria. However, they usually can be expressed as a combination of the criteria we have just discussed:

• Modifiable: If it is atomic and nonredundant, it is usually modifiable.

• Traceable: If it is atomic and has a unique ID, it is usually traceable.

Related Resources

• Book $34.39

• eBook (Watermarked) $27.99

Functional Requirements Software Examples

• Book $31.99