Chapter 14 of 32

Software Requirements Specification (SRS)

In Requirements Engineering we learned how to discover, analyse and validate requirements. But requirements that live only in meeting notes, emails and people's memories are dangerous. Six months later, the client remembers one thing, the developer another, and the tester a third. The answer is to write them down in one agreed, organized, reviewable document: the Software Requirements Specification, or SRS.

A Software Requirements Specification (SRS) is a document that completely describes what a software system must do and the constraints under which it must operate, written so that customers, developers and testers share one precise understanding. It states what the software will do, not how it will be built.

Think of it as the "contract" between the customer and the development team. Design, coding, testing, cost estimation and acceptance all refer back to it.


Who Uses an SRS, and for What

ReaderUses the SRS to…
Customer / clientConfirm that their needs are understood; agree on scope; accept the final product
Project managerEstimate size, cost and schedule; plan releases; control scope changes
Designers and developersKnow exactly what to build
TestersWrite test cases and acceptance tests (every requirement should be testable)
Maintenance teamUnderstand the intended behaviour years later
Legal / contractsSettle disputes over what was promised

Benefits of a good SRS

  • Establishes agreement between customer and supplier on what is to be built.

  • Reduces development effort, because misunderstandings are found before design and code.

  • Provides a basis for estimating cost and schedule.

  • Provides a baseline for verification and validation (testing).

  • Serves as a basis for later enhancement and for change control.


The Standards Behind the SRS

For decades the reference was IEEE Std 830-1998, "Recommended Practice for Software Requirements Specifications". Most university syllabi and exam questions still use its outline and its list of "characteristics of a good SRS".

IEEE 830 has since been superseded by the international standard ISO/IEC/IEEE 29148 ("Systems and software engineering — Life cycle processes — Requirements engineering"), first published in 2011 and revised in 2018. The 2018 edition is still the current published one as of late 2026; a third edition is being drafted (it reached the Draft International Standard stage in 2026) but has not yet replaced it. 29148 covers the whole requirements engineering process and defines several documents, including the stakeholder requirements specification, the system requirements specification and the software requirements specification.

The ideas are very similar. Below we learn the classic 830 structure (what exams ask) and note where 29148 differs.


Structure of an SRS (IEEE 830 Outline)

1. Introduction
   1.1 Purpose
   1.2 Scope
   1.3 Definitions, acronyms and abbreviations
   1.4 References
   1.5 Overview
2. Overall description
   2.1 Product perspective
   2.2 Product functions
   2.3 User characteristics
   2.4 Constraints
   2.5 Assumptions and dependencies
   2.6 Apportioning of requirements
3. Specific requirements
   3.1 External interface requirements
       (user, hardware, software, communications interfaces)
   3.2 Functional requirements
   3.3 Performance requirements
   3.4 Logical database requirements
   3.5 Design constraints (incl. standards compliance)
   3.6 Software system attributes
       (reliability, availability, security, maintainability, portability)
   3.7 Other requirements
Appendixes
Index

What goes in each part

SectionContents
1.1 PurposeWhy this SRS exists and who should read it.
1.2 ScopeName of the product, what it will and will not do, its benefits and goals.
1.3 DefinitionsGlossary, so that terms such as "order", "pickup slot" or "admin" mean one thing.
2.1 Product perspectiveHow the product fits with other systems: standalone, or part of a bigger system; interfaces to them.
2.2 Product functionsA short summary of the major functions (details come in section 3).
2.3 User characteristicsWho the users are: education, experience, technical skill.
2.4 ConstraintsLimits on developers: regulations, hardware, interfaces to other applications, language, security considerations.
2.5 Assumptions and dependenciesThings assumed true which, if they change, change the requirements (e.g. "all students have a smartphone").
2.6 ApportioningRequirements deferred to future versions.
3. Specific requirementsThe heart of the SRS: every requirement in enough detail to design and test it. Section 3 may be organized by mode, user class, feature, object or stimulus.

What changed in ISO/IEC/IEEE 29148

  • Product perspective is broken into explicit interface types (system, user, hardware, software, communications), memory constraints, operations and site adaptation requirements.

  • "Specific requirements" becomes specified requirements, which add explicit sections such as usability and standards compliance.

  • A dedicated verification section states how each requirement will be verified (test, analysis, inspection or demonstration).


Characteristics of a Good SRS

IEEE 830 lists eight characteristics. This is one of the most frequently asked exam questions on the topic.

CharacteristicMeaningViolation example
CorrectEvery requirement stated is one the software must actually meet.SRS says GST is 5% on everything, but some items are exempt.
UnambiguousEvery requirement has only one interpretation."Orders shall be processed quickly."
CompleteAll significant requirements are included; responses to all valid and invalid inputs are defined; all terms and figures are labelled; no "TBD" left unresolved.The SRS says what happens when payment succeeds, but not when it fails.
ConsistentNo requirements conflict with each other.FR-3: "Orders close at 11:30." FR-9: "Pre-orders accepted until noon."
Ranked for importance and/or stabilityEach requirement is marked with its priority (essential, conditional, optional) or how likely it is to change.All 200 requirements are treated as equally critical.
VerifiableThere is a finite, cost-effective process to check that the software meets each requirement."The system shall never crash."
ModifiableStructure and style allow changes easily and consistently: organized, indexed, no redundancy.The same rule copied into five sections; changing it misses two.
TraceableThe origin of each requirement is clear, and each can be referenced forward by design, code and tests (unique IDs).Requirements without numbers, written as paragraphs.

A simple mnemonic for the eight: "CUCC RVMT" — Correct, Unambiguous, Complete, Consistent, Ranked, Verifiable, Modifiable, Traceable.

The 29148 view

ISO/IEC/IEEE 29148 separates characteristics of each individual requirement from characteristics of the whole set:

  • An individual requirement should be necessary, appropriate, unambiguous, complete, singular, feasible, verifiable, correct and conforming (to a standard template or style).

  • The set of requirements as a whole should be, among other things, complete, consistent, feasible and comprehensible, and it must be possible to validate it against stakeholder needs.

"Singular" is a useful addition: one requirement should state one thing, not three joined by "and".


Worked Example: Excerpt from an SRS

Here is a short excerpt for the college canteen ordering system used in Requirements Engineering. A real SRS would be much longer, but the style is what matters.

1.2 Scope
  "CampusBite" lets students and staff of the college order food from the
  main canteen using an Android app or web browser, pay online, and collect
  the order at a pickup counter. It does NOT handle delivery, inventory
  purchasing, or staff payroll.

1.3 Definitions
  Order        : one or more menu items placed and paid for together.
  Pickup slot  : a 15-minute window in which an order is ready for collection.
  Kitchen user : canteen staff member who updates order status.

2.3 User characteristics
  Students and staff: familiar with smartphone apps and UPI payments.
  Kitchen users: basic smartphone literacy; interface must be usable
  with large buttons on a shared tablet.

2.5 Assumptions and dependencies
  A-1 The college single sign-on (SSO) service is available for login.
  A-2 The payment gateway confirms or rejects a payment within 60 s.

3.2 Functional requirements
  FR-05 (Priority: Essential)
        The system shall allow a logged-in user to place an order of 1 to 10
        items chosen from menu items currently marked "available".
  FR-06 (Essential)
        On successful payment, the system shall show a unique order number
        and the pickup slot.
  FR-07 (Essential)
        If payment fails or is not confirmed within 60 s, the system shall
        cancel the order and display "Payment failed. You have not been
        charged."
  FR-08 (Conditional)
        The system shall send an SMS to the user when the kitchen marks the
        order "Ready".

3.3 Performance requirements
  NFR-02 With 500 concurrent users, 95% of order placements (FR-05) shall
         complete within 2 seconds, excluding payment gateway time.

3.6 Software system attributes
  NFR-05 Availability: the system shall be available 99.5% of the time
         between 07:30 and 20:00 on working days, measured monthly.
  NFR-06 Security: passwords shall never be stored; authentication is
         delegated to the college SSO (see A-1).

Check this excerpt against the characteristics:

  • Unambiguous and verifiable: "1 to 10 items", "60 s", "95% … within 2 seconds", "99.5% … measured monthly" can all be tested.

  • Complete: FR-07 covers the failure path of payment, not just success.

  • Ranked: each requirement has an IEEE 830-style priority (Essential or Conditional).

  • Traceable: each has a unique ID that tests and design can refer to; NFR-06 refers back to assumption A-1.

  • Scope clearly says what the product does not do, which prevents arguments later.


Other Ways to Specify Requirements

NotationExample / descriptionStrengthWeakness
Natural language ("shall" statements)As in the excerpt aboveEveryone can read itProne to ambiguity
Structured natural language / templatesFixed fields: ID, description, inputs, outputs, pre-condition, post-condition, priorityUniform and more completeCan feel rigid
Use case specificationsActor, main flow, alternative flows, pre/post-conditionsGood for interaction behaviourWeak for non-functional needs
Graphical modelsUse case diagrams, data flow diagrams, state diagrams (each covered in its own chapter later in this tutorial)Show structure and flow clearlyNeed explanation for non-technical readers
Formal specificationMathematical notations such as Z, B or VDMPrecise; can be provedHard to write and read; used mainly for safety-critical systems
User stories + acceptance criteriaAgile backlogsLightweight, close to usersOverall picture and NFRs can get lost

A use case in structured form

Use case    : UC-2 Place Order
Actor       : Student
Precondition: Student is logged in; canteen is open for orders.
Main flow   :
  1. Student selects items and quantities from the menu.
  2. System shows the total and available pickup slots.
  3. Student chooses a slot and pays.
  4. System confirms payment, shows order number and slot (FR-06).
Alternative flows:
  1a. An item becomes unavailable → system removes it and informs student.
  3a. Payment fails or times out → system cancels order (FR-07).
Postcondition: Order is stored with status "Placed" and visible to kitchen.

SRS in Agile Projects

Agile teams rarely write a single large SRS up front, because requirements are expected to evolve (see Agile Methodology). Instead, the same information is spread across:

  • A Product Backlog of user stories with acceptance criteria.

  • A short product vision and a list of non-functional requirements (often as part of the Definition of Done).

  • Living documentation such as automated acceptance tests.

But a formal SRS is still standard, and often contractually required, for government projects, fixed-price outsourcing, and safety- or finance-critical systems such as medical devices, avionics and banking. Understanding the SRS also makes you better at writing user stories, since the quality characteristics apply to both.


Common Mistakes

  • Putting design in the SRS (database tables, class names, algorithms) unless they are real constraints. The SRS says what, the design says how.

  • Describing only the happy path. Completeness requires responses to invalid input and failures.

  • Vague words: "fast", "user-friendly", "secure", "etc.", "as required".

  • Requirements without IDs or priorities, which makes tracing and planning impossible.

  • Treating the SRS as finished once signed. It must be updated through change control as requirements change.

  • Saying IEEE 830 is the current standard. It is superseded by ISO/IEC/IEEE 29148, though its outline is still widely taught.


Interview and Exam Questions

Q1. What is an SRS? Why is it called a contract?

A document that fully specifies what the software must do and under which constraints. It is called a contract because customer and developer agree on it; the delivered software is accepted (or disputed) against it.

Q2. List the characteristics of a good SRS (IEEE 830).

Correct, unambiguous, complete, consistent, ranked for importance and/or stability, verifiable, modifiable, traceable.

Q3. Which characteristic is violated by "The system shall respond quickly"?

It is ambiguous (unambiguity is violated) and therefore also not verifiable: no test can decide whether "quickly" is met.

Q4. Which characteristic is violated if FR-3 says "Max 5 items per order" and FR-12 says "Max 10 items per order"?

Consistency: two requirements contradict each other.

Q5. Should an SRS contain design details?

Generally no; it states what the system must do, not how. Design details belong in the design document. An exception is a genuine design constraint imposed by the customer or environment (for example, "must run on the college's existing Linux servers"), which goes in the constraints section.

Q6. Which standard replaced IEEE 830?

ISO/IEC/IEEE 29148 (first edition 2011, current edition 2018; a third edition is in draft), which covers requirements engineering processes and the content of requirements documents including the SRS.

Q7. What are the three main sections of an IEEE 830 SRS?

Introduction, Overall description, Specific requirements (followed by appendixes and index).


Summary

  • An SRS documents what the software must do and its constraints; it is the shared reference for customer, developers and testers.

  • Classic outline (IEEE 830): Introduction; Overall description; Specific requirements; appendixes and index.

  • A good SRS is correct, unambiguous, complete, consistent, ranked, verifiable, modifiable and traceable.

  • IEEE 830 is superseded by ISO/IEC/IEEE 29148, which adds per-requirement qualities such as singular, feasible and necessary, and a verification section.

  • Requirements can be specified in natural language, templates, use cases, models or formal notations; agile teams use backlogs and acceptance criteria.

An SRS is good when a tester can derive tests from it and a client can sign it without guessing.