Software Engineering & Object-Oriented Analysis & Design β Software Process and Requirements, NEC licence examination syllabus (Nepal Engineering Council).
Requirements Validation and Management
Checking you wrote down the right thing β then surviving the fact that it changes.
π Where this lives: requirements change is not a project failure, it is the normal condition of software. Businesses reorganise, laws are amended, competitors ship features, and users discover what they actually wanted only after using v1. The projects that fail are not the ones whose requirements changed β it is the ones that had no way to absorb the change, so each amendment quietly broke something nobody realised was connected. Requirements management is the machinery that makes change survivable, and it is why every serious codebase has an issue tracker linking changes back to reasons. Search "requirements creep vs requirements change management".
Validation β the right requirements, not just well-written ones
REQUIREMENTS VALIDATION is concerned with demonstrating that
the requirements define the system that the CUSTOMER REALLY
WANTS.
VERIFICATION vs VALIDATION, applied to requirements:
verification β are we writing the document right?
validation β are we writing the right document?
WHY IT MATTERS SO MUCH: requirements-error costs are HIGH.
Fixing a requirements error after delivery may cost up to 100
TIMES the cost of fixing an implementation error β because it
invalidates design, code and tests, and possibly the
architecture.
THE FIVE CHECKS TO PERFORM ON EVERY REQUIREMENT:
VALIDITY CHECKS does the system provide the functions
that BEST support the customer's needs?
(Different stakeholders' needs may
combine into a function nobody
individually asked for.)
CONSISTENCY CHECKS are there conflicts?
COMPLETENESS CHECKS are all functions required by the
customer included?
REALISM CHECKS can the requirements be implemented
given the available budget, technology
and schedule?
VERIFIABILITY can each requirement be tested? Write
the test now, on paper, to find out.
THE TECHNIQUES:
REQUIREMENTS REVIEWS
Systematic manual analysis by a team including both customer
and developer representatives. Formal or informal. Good
communication between all parties resolves problems at an
early stage.
A review CHECKLIST asks of each requirement:
VERIFIABILITY is it realistically testable?
COMPREHENSIBILITY is it properly understood?
TRACEABILITY is the origin clearly stated?
ADAPTABILITY can it be changed without large-scale
effects on other requirements?
PROTOTYPING
An executable model is demonstrated to end-users and
customers. The most effective validation technique there is,
because users respond to what they can touch, and a
misunderstanding that survives three document reviews dies
in thirty seconds of use.
TEST-CASE GENERATION
Requirements should be testable. Developing tests DURING
validation frequently reveals requirements problems β if a
test is hard to design, the requirement is usually
incomplete or ambiguous. This is the cheapest high-yield
technique on the list.
AUTOMATED CONSISTENCY ANALYSIS
For requirements expressed in a structured or formal
notation, a tool can check structural and internal
consistency. Limited to what the notation captures.
REQUIREMENTS SHOULD NEVER BE ASSUMED VALIDATED. It is
difficult to demonstrate that a set of requirements meets a
user's needs, because users must imagine the system in
operation. Validation is a matter of raising confidence, not
achieving proof.
Management β absorbing change without breaking things
REQUIREMENTS MANAGEMENT is the process of managing changing
requirements during the requirements engineering process and
system development.
Requirements are INEVITABLY INCOMPLETE AND INCONSISTENT:
Β· new requirements emerge as the system is developed and
the business context changes
Β· different stakeholders have different and possibly
contradictory priorities
Β· the people paying for the system and the users are rarely
the same people
Β· the business environment changes, changing the priorities
ENDURING vs VOLATILE REQUIREMENTS β the key planning
distinction:
ENDURING stable, derived from the core activity of the
organisation. A hospital will always have
patients, doctors and records. These relate to
the domain and change slowly.
VOLATILE change during development or in use. Government
health-policy requirements, tax rules, reporting
formats.
β design so that VOLATILE requirements are isolated in few
modules. That is what "design for change" concretely
means, and it is why this distinction is a design input,
not just a planning note.
CLASSES OF VOLATILE REQUIREMENT:
MUTABLE change because of the system's environment
EMERGENT emerge as understanding of the system
develops
CONSEQUENTIAL result from the introduction of the system
itself β the system changes how people work,
which creates new requirements
COMPATIBILITY depend on other equipment or processes
THE CHANGE MANAGEMENT PROCESS β three stages:
1. PROBLEM ANALYSIS AND CHANGE SPECIFICATION
The problem or change proposal is analysed to check it is
valid. The result is fed back, and may be withdrawn.
2. CHANGE ANALYSIS AND COSTING
The effect is assessed using TRACEABILITY INFORMATION and
general knowledge of the requirements. Cost is estimated
in terms of modifications to the requirements document,
the system design and the implementation. Once done, a
decision is made whether to proceed.
3. CHANGE IMPLEMENTATION
The requirements document, and where necessary the design
and implementation, are modified. The document should be
organised so changes can be made WITHOUT extensive
rewriting β which means minimal cross-referencing, and
modular structure.
THE RULE THAT MAKES IT WORK: changes must be applied to the
DOCUMENT FIRST, then the code. If urgent changes are made
directly to the system, the document and the system diverge β
and the document becomes worthless, at which point nobody
maintains it, and the project has lost its only record of why
the system is the way it is.
TRACEABILITY β what makes change analysis possible at all:
SOURCE traceability requirement β the stakeholder who
proposed it, so you can ask them
REQUIREMENTS trace. requirement β dependent
requirements
DESIGN traceability requirement β the design/code
modules implementing it
Held in a TRACEABILITY MATRIX. Without it, "how much would
this change cost?" has no answerable form, and every estimate
is a guess.
A change request, costed
CHANGE REQUEST CR-114
"Licence fees shall vary by district, not be a single national
rate."
STAGE 1 β PROBLEM ANALYSIS
Valid: arises from a genuine policy amendment. Source: Ministry
circular 2026/07. Not withdrawable.
STAGE 2 β CHANGE ANALYSIS USING TRACEABILITY
Traceability matrix query: what touches requirement R-042
("fee shall be NPR 2,500")?
requirements R-042 fee amount β EDIT
R-043 fee display on receipt β EDIT (must
now show which district rate applied)
R-088 refund calculation β EDIT
R-091 annual revenue report β EDIT (must
now break down by district)
design FeeCalculator, ReceiptRenderer,
RefundService, RevenueReport β 4 modules
database new district_fee table; existing rows need a
district assigned β a MIGRATION, and the
historical rows must keep the OLD rate or
every past receipt reprints wrongly
tests 17 test cases reference the constant 2500
interfaces the payment gateway request carries the
amount β no interface change
documents SRS Β§4.6, Β§6.3, Β§9.2
ESTIMATE
requirements edits 6 person-hours
design + implementation 40 person-hours
data migration + backfill 16 person-hours
test updates 20 person-hours
regression + UAT 24 person-hours
βββββββββββββββ
106 person-hours β 13 person-days
THE FINDING THAT JUSTIFIES THE WHOLE EXERCISE: the historical-
rate problem in the migration. Nobody proposing this change
thought about reprinting old receipts, and without the
traceability matrix it would have been discovered in
production, by an auditor.
STAGE 3 β DECISION AND IMPLEMENTATION
Approved. SRS amended first (new version 2.4, with the change
rationale recorded in the preface), then design, then code,
then tests. R-042 is reclassified VOLATILE, and FeeCalculator
is refactored so future rate changes are configuration rather
than code β because a requirement that changed once will
change again.
That last line is the practical payoff of the enduring/volatile distinction. Once a requirement has demonstrated that it is volatile, the correct response is not just to implement the change but to move it out of code and into configuration, so the next change costs hours instead of days. Requirements management feeds design.
π Go further: everything in this topic has a running-code equivalent you can look at today. Traceability is a commit message linking to an issue id; the change control board is a pull-request review; "document first, then code" is the rule that an API change updates its OpenAPI spec in the same commit; and regression tests are automated change analysis β they tell you what a modification broke, in minutes, without a matrix. The concepts did not go away with waterfall; they moved into the tooling, which is why a repository with meaningless commit messages is genuinely harder to change than one with traceable ones. Search "conventional commits traceability change management".
π‘ Exam angle: distinguish validation (right requirements) from verification (requirements written right), and list the five checks β validity, consistency, completeness, realism, verifiability β and the techniques (reviews, prototyping, test-case generation, automated consistency analysis) with the review checklist. Quote the 100Γ cost figure for post-delivery requirements errors. For management, define enduring vs volatile requirements, name the volatile classes (mutable, emergent, consequential, compatibility), draw the three-stage change management process, and explain the three kinds of traceability. The commonly missed mark is the rule that the document is changed before the code.
Syllabus points
Validation; requirements management
Create a free account to tick topics off, take notes as you read, watch the video lessons and get a day-by-day study plan built around your exam date.
Related topics in Software Process and Requirements