Requirement validation and the SRS
Requirement validation ensures the SRS (Software Requirements Specification) correctly, completely and testably captures stakeholder needs so the system built is the right system.
Drafted with Aria, reviewed by the AiCanCode.org team · Updated . How we write and check our notes. Spotted an error? Use Give Feedback at the bottom of the page.
Why it matters
Requirement validation is used by engineers to check the SRS before design and coding begin so costly rework is avoided. Validation ensures the documented requirements truly reflect stakeholder needs and are testable, unambiguous, and feasible.
Key ideas
Start from first principles: software is built to satisfy stakeholder needs. The main artifact at the boundary between stakeholders and developers is the SRS.
Software Requirements Specification (SRS): a complete, organized document that records all functional and non-functional requirements and interfaces for a software system. Assumption: the SRS is the authoritative input to design, test and project planning. Reference: aligns with ISO/IEC/IEEE 29148:2018 terminology (superseding IEEE 830-1998) commonly cited in exams.
Requirement: a condition or capability needed by a stakeholder to solve a problem or achieve an objective. Assumption: each requirement maps to one or more stakeholder needs.
Functional requirement: a requirement that describes a function the system must perform (actions, processing, data transformation). Example form: "The system shall allow user X to do Y under conditions Z." Assumption: functional requirements are observable via inputs/outputs.
Non-functional requirement (NFR): a requirement that constrains the system's operation or quality (performance, security, usability). Assumption: NFRs are measurable or must be made measurable to be testable.
Domain requirement: a requirement derived from domain rules (regulation, standards) rather than direct stakeholder wish.
Verification vs Validation: exact definitions used in software engineering exams:
- Verification: "Are we building the product right?" — checks the product against specifications (internal consistency, completeness). Assumption: verification works with design and code artifacts.
- Validation: "Are we building the right product?" — checks the requirements/specification against stakeholder needs and the real-world environment. Assumption: validation requires stakeholder involvement.
Requirement validation: the set of activities that confirm requirements in the SRS correctly and sufficiently represent stakeholder needs and constraints and are testable. Formal statement: A requirement R is validated if (1) R is consistent with stakeholder goals, (2) R is expressible unambiguously, (3) R is feasible with respect to constraints, and (4) R is verifiable by test or inspection.
SRS quality properties (precise checklist form; each property must hold for a good SRS):
- Correct: every stated requirement is a true reflection of stakeholder intent. Assumption: validation steps include stakeholder review.
- Complete: all significant requirements and significant external interfaces are included. Assumption: scope boundaries are defined.
- Consistent: no two requirements contradict each other. Assumption: shared terminology is defined.
- Unambiguous: each requirement has exactly one interpretation. Assumption: definitions and glossaries exist for domain terms.
- Verifiable: each requirement can be checked by inspection, demonstration, test, or analysis. Assumption: test criteria or acceptance criteria are provided.
- Modifiable: the SRS structure allows requirements to be changed without unpredictable side effects. Assumption: numbering, sections, traceability help modifiability.
- Traceable: each requirement can be traced back to its origin (stakeholder, regulation) and forward to design and tests. Assumption: traceability matrix or tool exists.
- Prioritized (often required): requirements have stakeholder-assigned priority to guide scope decisions. Also commonly cited (per ISO/IEC/IEEE 29148) for individual requirements: necessary, feasible, singular (atomic), and implementation-free (design independent).
Validation techniques (define and explain):
- Reviews and inspections: formal meetings using checklists to detect defects. Inspection defined: a structured peer review with assigned roles (moderator, reader, recorder, author).
- Prototyping: build a throwaway or evolutionary prototype to reveal missing or misunderstood requirements. Assumption: stakeholders can exercise prototypes.
- Model validation: validate requirement models (use cases, scenarios, data models) by walk-throughs and simulation.
- Test-case generation: derive acceptance tests from requirements and check if every requirement maps to one or more tests.
- Traceability analysis: create and inspect a traceability matrix mapping requirements to sources and tests to ensure coverage.
- Consistency and ambiguity analysis: use controlled language, glossary and formalization where possible to find ambiguities.
When to validate? Important points: validation is early and iterative. It should occur after initial elicitation, after SRS drafting, and whenever requirements change (assumption: validation activities are lightweight and continuous in agile projects).
The V-model diagram (what to draw in an answer): draw a large letter V. On the left descending side label in order: "Stakeholder needs" → "System requirements / SRS" → "High-level design" → "Detailed design". On the right ascending side label (bottom to top): "Unit tests" → "Integration tests" → "System tests" → "Acceptance tests". Draw arrows across to show the usual mapping: Stakeholder needs ↔ Acceptance tests (validation), SRS ↔ System tests (verification), High-level design ↔ Integration tests (verification), Detailed design ↔ Unit tests (verification). Label each cross-link as verify or validate as appropriate (no need to label the whole V or the baseline).
Formulas
SRS_quality = Correct ∧ Complete ∧ Consistent ∧ Unambiguous ∧ Verifiable ∧ Modifiable ∧ Traceable
- Symbols: ∧ means logical AND; the formula states all listed properties must hold for high-quality SRS. Applies when assessing SRS quality.
Coverage = (Number_of_requirements_with_tests / Total_number_of_requirements) × 100 %
- Coverage: fraction of requirements that have one or more mapped acceptance tests. Unit: percent. Use to measure testability.
Traceability_ratio = (Verified_links / Total_links_expected)
- Verified_links: number of requirement→test (and requirement→design) links verified. Unit: ratio (0..1). Use to measure traceability completeness.
If you prefer syntax points to remember:
- Use a traceability matrix table with rows = requirements, columns = sources, use-cases, design modules, tests. Mark links with X.
Worked examples
Example 1 — Finding and fixing ambiguity in an SRS excerpt (step-by-step): Given SRS sentence: "The system shall respond quickly to user queries." (assume this appears in online bookstore SRS).
- Identify problem: "quickly" is ambiguous and non-verifiable.
- Turn into verifiable NFR by adding measurable criteria: decide stakeholder-acceptable value, e.g., 2 seconds.
- Corrected requirement: "The system shall display search results for queries from a logged-in user within 2.0 seconds 95% of the time under peak load of 2000 concurrent users."
- Validation actions: create acceptance test: generate 2000 simulated users with typical query mix, measure 1000 queries, compute the 95th percentile of response time. Pass if the 95th percentile ≤ 2.0 s. Final answer: show original, flaw, corrected requirement, and explicit acceptance test.
Example 2 — Traceability matrix and coverage calculation (step-by-step): Requirements: R1: Login; R2: Search; R3: Purchase. Tests: T1: Login test; T2: Search test; T3: Purchase test.
- Build matrix (rows R1..R3, columns T1..T3). Put X where test covers requirement: R1↔T1(X), R2↔T2(X), R3↔T3(X).
- Coverage = (3 mapped requirements / 3 total) × 100% = 100%.
- If later R2 had no test, Coverage = (2/3)×100% = 66.67%. Show how missing test reveals validation gap.
Example 3 — Model answer: Describe three validation techniques and when to use them (short essay model answer):
- Give definitions, steps for reviews, steps for prototyping, steps for test-case derivation, and explain trade-offs (cost, stakeholder availability, risk). A full-marks answer names roles for inspection, lists checklist items and gives a short scenario where each technique is best.
Common mistakes
- Writing vague NFRs (using adjectives like "fast", "secure" without measurable criteria).
- Assuming completeness: not showing how to detect missing requirements (traceability and stakeholder review needed).
- Omitting acceptance test derivation when asked to validate a requirement.
- Ignoring conflicts between requirements (e.g., security vs. usability) and not showing trade-off or priority.
- Not drawing or labelling the V-model clearly when asked.
- Presenting a traceability matrix but not computing coverage or explaining what missing links mean.
For your exam
Typical question types:
- Define terms (SRS, verification, validation, functional vs non-functional). Full-marks: precise textbook definition and a one-line example.
- Short note on SRS qualities or validation techniques. Full-marks: list properties, short explanation and at least one concrete validation technique with steps.
- Diagram question (V-model): draw and label with verification/validation mapping. Full-marks: correct left/right phases, arrows across, labels "Verification" and "Validation".
- Given SRS excerpt: find defects and rewrite requirements. Full-marks: identify specific defects (ambiguous, incomplete, untestable), corrected requirement, and at least one acceptance test.
- Traceability/numerical: build a traceability matrix and compute coverage. Full-marks: correct matrix and percentage calculation.
Exam strategy: always provide acceptance/test criteria for NFRs, include a glossary for domain terms, and include traceability entries if asked about coverage or change impact.
Quick check
- What is the primary difference between verification and validation?
- Give one precise, verifiable form of the requirement "The system should be secure."
- What does a traceability matrix map from and to?
Answers: 1) Verification = "are we building the product right?" checks artifacts against specs; Validation = "are we building the right product?" checks specs against stakeholder needs. 2) Example: "All user passwords shall be stored using a salted, memory-hard password hashing function (e.g., Argon2id with agreed parameters in the SRS) and the system shall lock the account after 5 failed login attempts within any 10-minute window" (include measurable criteria). 3) A traceability matrix maps requirements to origins (stakeholders, documents), to design modules/use-cases and to tests (acceptance, system, unit).
Note to reviewer: I have listed typical standards and techniques but I may be unsure about specific standard numbers and wording (see verify list). I tried to be precise about required SRS properties and validation steps; please correct any missing formal references or preferred phrasing for university answers.
Finished this topic? Mark it so your progress, study plan and readiness keep up.
Stuck on something here?