Requirements engineering is the systematic investigation, documentation, analysis, validation, and management of what a system must accomplish and the constraints under which it must operate. It connects the purposes of an organization and the needs of affected people with the technical decisions involved in building, acquiring, operating, and changing a system. Although closely associated with software engineering, it also applies to systems combining software, hardware, human procedures, and physical processes.
A requirement may express an externally observable capability, a quality threshold, a legal obligation, an interface rule, or a restriction on the development or operating environment. Requirements engineering therefore involves more than collecting requested features. It examines whether proposed requirements address the underlying problem, whether they are mutually compatible and feasible, and what evidence would demonstrate their satisfaction. Its products include specifications, models, acceptance criteria, decision records, and maintained relationships between needs, designs, implementations, and tests.
Requirements work continues throughout a system’s life. Early activities establish purpose and scope; later activities refine uncertainties, resolve disagreements, assess changes, and incorporate operational evidence. The central difficulty is that requirements concern an evolving social and technical world whose participants may have incomplete knowledge, competing interests, and different interpretations of the same words.
Conceptual foundations and system boundaries
Requirements engineering begins by distinguishing a problem from a proposed solution. An organization may request a mobile application when its underlying need is to reduce missed appointments. An application is one possible intervention; changes to scheduling procedures, reminder channels, or staffing may address the same objective. Treating the requested implementation as the requirement can conceal alternatives and make success difficult to evaluate. A useful requirements description therefore identifies the intended outcome, the people or organizations affected, and the circumstances in which that outcome matters.
The system boundary determines which responsibilities belong to the proposed system and which belong to its environment. In an automated access gate, software may command an actuator, but successful entry also depends on sensors, electrical power, mechanical components, and human behavior. Requirements must distinguish observations available to the software from environmental conditions it cannot directly detect or control. Systems engineering addresses the allocation of responsibilities across the larger arrangement; software requirements refine the responsibilities assigned to software. The distinction is consequential because a correct program can still participate in an unsuccessful or unsafe overall system.
A formulation associated with Pamela Zave and Michael Jackson’s 1997 work expresses the relationship among domain assumptions, a specification, and requirements as
where represents relevant properties or assumptions about the environment, specifies the behavior of the machine to be built, and states the required effects in the problem world. The notation means that the environmental assumptions together with the specified machine behavior should entail the requirements. It does not imply that every project uses mathematical specifications. Its practical significance is that a specification cannot establish a real-world outcome without assumptions about the world in which the system operates.
Requirements are commonly organized at several levels. Business requirements describe objectives such as reducing processing time; stakeholder requirements describe needed capabilities from particular perspectives; system and software requirements define more precise obligations. These levels are not simply progressively longer documents. They represent different kinds of reasoning and responsibility. A business objective may be satisfied through several cooperating technical and organizational measures, while one technical capability may support several objectives. Requirements engineering preserves these relationships without assuming that every high-level statement decomposes neatly into an independent tree of lower-level requirements.
Historical development and professional standards
Requirements engineering developed as software projects grew beyond programs whose authors could retain a shared understanding of their purpose. Large defense, aerospace, industrial, and administrative systems required coordination among customers, contractors, operators, and specialist engineers. The 1968 NATO software engineering conference helped establish software development as an engineering concern, including the difficulty of defining what software should do. Early lifecycle models often represented requirements as an initial phase, but practical experience repeatedly showed that understanding changed during design, implementation, and use. Winston Royce’s 1970 paper, frequently associated with the waterfall model, itself discussed feedback and the risks of a simple sequential process.
During the 1970s and 1980s, structured analysis encouraged explicit representations of data movement, processing, and stored information. Data-flow diagrams, data dictionaries, and entity–relationship models made aspects of a proposed system inspectable before implementation. Formal specification research pursued another route: expressing behavior mathematically so that properties could be checked with greater precision. During the 1990s, object-oriented modeling, scenarios, and use cases broadened the repertoire. Ivar Jacobson and colleagues’ 1992 book Object-Oriented Software Engineering helped popularize use cases as descriptions of interactions through which users achieve goals.
The field also became an identifiable research community. The first IEEE International Symposium on Requirements Engineering was held in 1993, and the journal Requirements Engineering began publication in 1996. Research increasingly examined organizational context, stakeholder viewpoints, goal modeling, negotiation, and the evolution of requirements rather than treating specification as a purely technical writing task. Goal-oriented requirements engineering, including approaches such as KAOS and i*, represented objectives, alternative means of achieving them, and dependencies among actors. These approaches made disagreements about purposes and responsibilities more explicit.
Standards supplied shared terminology and guidance for industrial practice. IEEE 830-1998 described recommended practices for software requirements specifications and became widely associated with document-oriented requirements work. ISO/IEC/IEEE 29148, first published in 2011 and revised in 2018, addresses requirements engineering processes and requirements-related information items across systems and software. ISO/IEC/IEEE 15288:2023 places stakeholder needs and system requirements within system lifecycle processes, while ISO/IEC/IEEE 12207:2017 addresses software lifecycle processes. These standards define expectations and information structures rather than prescribing a single development method. A project can use iterative development, models, managed requirement records, or combinations of these while still applying disciplined requirements practices.
Stakeholder identification and requirements elicitation
Elicitation is the investigation through which requirements-related knowledge is discovered, articulated, and challenged. The word is preferable to “collection” because requirements rarely exist as a complete set of statements waiting to be recorded. Participants may know their work without being able to describe all its rules, may omit exceptions they regard as obvious, or may frame requests in terms of familiar technology. The investigator must distinguish observations, preferences, assumptions, obligations, and proposed solutions. A statement such as “the report must be available every morning” invites questions about who uses it, which decisions depend on it, and what happens when its source data arrive late.
Stakeholder identification extends beyond the purchaser and intended end user. Relevant groups can include operators, maintainers, administrators, support staff, auditors, external service providers, and people indirectly affected by a system. Authority to approve a requirement does not necessarily imply detailed knowledge of the work it concerns. Conversely, frontline workers may possess essential operational knowledge without controlling the project budget. A stakeholder analysis therefore examines influence, responsibility, expertise, and exposure to consequences. In public-facing systems, accessibility needs may be missed if participation is limited to people who already use existing digital services successfully.
Different elicitation methods expose different kinds of evidence. Interviews permit detailed questioning, while workshops help participants compare interpretations and negotiate shared terminology. Observation and contextual inquiry reveal workarounds, interruptions, and tacit practices that retrospective accounts may omit. Document analysis identifies established policies, contracts, forms, and interface obligations. Surveys can reach larger populations but provide less opportunity to clarify ambiguous answers. Operational logs can show frequent pathways and failure patterns, although recorded behavior reflects the constraints of the existing system rather than necessarily revealing what people need. Methods drawn from human–computer interaction are particularly useful when work depends on interaction details and situated practice.
Scenarios and prototypes turn abstract discussion into concrete examination. A prototype of an appointment system may reveal that staff must reserve emergency capacity, distinguish provisional bookings from confirmed ones, and recover when a caller disconnects. Exceptional and negative scenarios are as important as the ordinary success path. Elicitation records also benefit from separating what was directly observed from what was inferred, and from preserving the source and rationale of significant statements. Conflicting accounts are not merely documentation defects: they may reveal different local procedures, incompatible incentives, or unresolved policy decisions that the new system cannot settle by implementation alone.
Analysis, prioritization, and negotiation
Requirements analysis transforms elicited material into a coherent account of the problem and the obligations proposed for the system. Typical activities include defining terminology, identifying missing cases, separating compound statements, classifying requirements, and examining dependencies. For example, a requirement to “approve and notify applicants immediately” combines an authorization decision, a notification action, and a timing expectation. Each may depend on different information and fail independently. Analysis makes these distinctions explicit so that design choices and acceptance evidence can address them. A shared domain vocabulary is especially important where everyday words such as “customer,” “account,” or “completed” have specialized meanings.
Models support analysis by presenting relationships that prose can obscure. A process model can reveal a missing handoff between departments; a state model can expose an action permitted after cancellation; and a data model can reveal that two departments assign different identities to what they call the same record. A finite-state machine for an order might distinguish created, authorized, fulfilled, cancelled, and refunded states, together with permitted transitions. Requirements about payments can then be examined against those transitions. The purpose is not to maximize the number of models but to select representations that expose consequential uncertainties and contradictions.
Prioritization allocates limited time, funding, and implementation capacity. Common approaches include ranked lists, pairwise comparisons, cost–value analysis, and categories such as MoSCoW: must have, should have, could have, and will not have for the current delivery. A priority label alone is insufficient when participants use “must” to protect departmental interests. Decisions also depend on dependencies, risk reduction, delivery timing, and the cost of postponement. A low-visibility capability such as restoring a database may be a prerequisite for operational readiness even if users rank it below visible features. Numerical scoring can structure discussion, but its weights and estimates embody judgments rather than eliminating them.
Negotiation addresses incompatibilities among stakeholder interests and system constraints. Stronger authentication may reduce unauthorized access while increasing completion time; extensive logging may support investigation while conflicting with data minimization. Some apparent conflicts disappear when requirements are made more precise, while others require an explicit trade-off or a change in scope. Documented rationale records which alternatives were considered, what evidence informed the choice, and who had decision authority. Unresolved assumptions can be tested through prototypes, technical experiments, or limited deployments. This prevents uncertain estimates from silently becoming contractual promises and distinguishes an agreed compromise from an inconsistency that remains hidden in the specification.
Specification languages, models, and requirement statements
A requirements specification communicates obligations with enough precision to support agreement, development, and evaluation. It may take the form of a structured document, a repository of individually managed records, executable examples, diagrams, formal expressions, or a combination. Each requirement commonly has an identifier and attributes such as source, rationale, priority, status, and verification method. These attributes serve different purposes from the requirement statement itself. A rationale explains why an obligation exists; it should not introduce an additional obligation that is absent from the controlled statement.
Natural language remains common because many stakeholders can read and review it. Its weaknesses include ambiguous pronouns, undefined qualifiers, hidden conditions, and conjunctions that combine distinct obligations. “The service shall respond quickly” leaves the operation, workload, response boundary, and meaning of “quickly” unspecified. A more testable statement might require that at least 95 percent of valid search requests receive a complete response within two seconds under a defined workload and test environment. Even this statement needs definitions of measurement interval, excluded failures, and relevant data volume. Precision comes from a shared interpretation of the measurement procedure, not merely from adding numbers.
Structured forms constrain expression without requiring a fully mathematical language. A use case describes actors, preconditions, a main interaction sequence, alternatives, and outcomes. A user story often follows the pattern “As a role, I want a capability, so that a benefit,” but the sentence is usually a prompt for further conversation rather than a complete specification. Acceptance criteria add concrete conditions. Scenario-oriented formats such as Given–When–Then describe an initial situation, an event, and an observable result. Such examples are valuable for exposing boundary cases, but a finite collection of examples may leave general behavior unspecified.
Formal specifications use mathematically defined languages to express states, operations, invariants, or temporal behavior. An inventory invariant might require that the recorded available quantity never become negative; a temporal property might require that every accepted request eventually receive a terminal outcome, under stated environmental assumptions. Formal verification and model checking can examine these properties with greater rigor than an informal reading permits. Their findings remain relative to the model and assumptions supplied. A logically consistent specification may still describe the wrong business process, omit an affected stakeholder, or formalize an unsafe assumption. Formal precision therefore complements rather than replaces elicitation and stakeholder validation.
Quality attributes, constraints, and cross-cutting concerns
Requirements are often divided into functional requirements and non-functional requirements. Functional requirements describe capabilities or behavior; the second category commonly includes performance, reliability, usability, security, maintainability, and other qualities. The division is useful but imperfect. A security requirement may prescribe a concrete function, such as locking an account after specified failed attempts, while a performance requirement directly constrains observable behavior. “Quality requirements” and “constraints” are often more informative labels than treating everything outside the feature list as one residual category. The important distinction is what obligation a statement imposes and how satisfaction will be established.
Quality attributes require an operational context. Availability may be expressed as the proportion of an agreed service period during which the service is usable, but the calculation depends on the service boundary, treatment of planned maintenance, and definition of failure. A target of 99.9 percent permits approximately 8.76 hours of unavailability in a 365-day year if all time is included. That figure says nothing by itself about the distribution of outages: one long interruption and many brief interruptions can have different consequences. Similarly, average response time can conceal severe delays for a minority of requests. Percentiles, workload profiles, recovery conditions, and measurement locations make requirements interpretable.
Security, privacy, and safety frequently require analysis of undesirable behavior rather than only intended use. A threat model identifies assets, adversaries, entry points, trust boundaries, and plausible attacks. Resulting requirements may concern access control, auditability, encryption, or separation of duties. Privacy requirements can constrain collection purposes, retention periods, disclosure, and deletion. Safety analysis examines conditions in which system behavior could contribute to harm, including correct software operating with incorrect sensor data or mistaken human actions. These concerns cross component boundaries and often require coordinated technical and procedural measures.
Requirements also constrain interfaces, deployment environments, and architectural choices. An application programming interface may need defined error semantics, compatibility rules, and limits on request rates. Interoperability requires agreement about the meaning of exchanged information, not just its syntax. A contractual service-level agreement may establish measurable service commitments, whereas an internal engineering requirement must identify the behavior and resources needed to support them. Some constraints mandate a technology or platform; others state an outcome while leaving the design open. Distinguishing these cases preserves freedom in software architecture where it is legitimate and exposes restrictions that need explicit justification.
Validation, verification, and acceptance evidence
Requirements validation asks whether the stated requirements adequately represent stakeholder needs and the intended use of the system. Verification of requirements examines whether the requirements artifacts satisfy defined quality rules, such as clarity, consistency, and appropriate structure. Separately, verification of an implemented system asks whether that implementation conforms to its specified requirements. Terminology varies across standards and organizations, so a project must identify what object is being checked and against which criteria. The familiar contrast between “building the right system” and “building the system right” is helpful but does not replace these more precise distinctions.
Reviews are a principal means of evaluating requirements before implementation. A multidisciplinary review may include domain specialists, developers, testers, operations personnel, and stakeholder representatives. Reviewers examine whether each statement is necessary, feasible, understandable, and verifiable, and whether the set covers relevant situations. Missing requirements are often harder to detect than defective sentences because there is no explicit statement to challenge. Checklists, scenario walkthroughs, interface analysis, and comparisons with domain models help reveal omissions. A reservation requirement, for example, may describe successful booking accurately while saying nothing about concurrent attempts to obtain the final available place.
Different requirements call for different evidence. Tests demonstrate behavior under selected conditions; inspections examine artifacts or configurations; demonstrations show observable operation; and analyses derive conclusions from models, calculations, or other evidence. A timing requirement may require load testing under a specified environment, while a structural restriction may be established through inspection. A property about all reachable states may be investigated through model checking. No single method is universally sufficient. Testing cannot exhaust an unrestricted input space, while a proof cannot establish that unmodeled environmental assumptions hold in operation.
Acceptance criteria define the conditions under which a delivery, capability, or contractual obligation will be regarded as satisfied. They must distinguish observable outcomes from implementation intentions. For an account-recovery process, criteria might cover legitimate recovery, expired credentials, repeated attempts, notification, and audit events, rather than merely require that a recovery screen exist. Bidirectional relationships between requirements and tests help reveal requirements without evidence and tests without an understood purpose. Nevertheless, passing every recorded test is not equivalent to satisfying every stakeholder need. Validation may still expose an inappropriate workflow, misunderstood terminology, or an operating condition excluded from the test environment.
Traceability, baselines, and controlled change
Requirements traceability is the ability to follow a requirement’s origins and its relationships with other development and operational artifacts. Backward links connect requirements to stakeholder needs, regulations, contracts, or observations; forward links connect them to architecture, implementation elements, tests, and acceptance evidence. Relationships also exist among requirements, including refinement, dependency, conflict, and allocation. These links explain why a capability exists, where it is realized, and what may be affected when it changes. Traceability is particularly important when evidence must be reconstructed long after the original participants have left.
A baseline is an identified and agreed set of artifacts used as a reference for subsequent work. Establishing one does not mean requirements can never change. It makes the difference between an authorized state and a proposed modification explicit. Requirement identifiers should remain stable enough to preserve historical relationships, while revisions record changes in meaning and status. Version control can preserve textual history, but a sequence of file revisions alone may not capture approval authority, rationale, or semantic dependencies. Requirements management therefore overlaps with, but is not identical to, configuration management.
Change control evaluates proposed modifications in relation to value, cost, timing, risk, and affected commitments. A request to retain records for a longer period may alter storage capacity, backup procedures, deletion behavior, privacy obligations, and operational costs. Impact analysis follows relevant dependencies rather than treating the request as an isolated sentence edit. The responsible authority may approve the change, reject it, defer it, or request further investigation. Formal change boards are useful in some contractual and regulated settings; smaller teams may use lighter decision mechanisms. In either case, the essential issue is whether consequential decisions are visible and made by appropriate participants.
Traceability has costs and limitations. Links become unreliable when artifacts change without maintenance, and excessive linking creates noise rather than understanding. A relationship marked “implements” may conceal only partial coverage or depend on an outdated interpretation. Useful traceability therefore distinguishes relationship types and concentrates on decisions and evidence that matter. Graph-based queries can identify a requirement whose associated test is obsolete or an architectural component affected by several proposed changes. Such findings are starting points for investigation: the existence of a link does not prove that the linked artifact correctly satisfies the requirement.
Iterative development, operational learning, and emerging automation
Agile software development changes the timing and packaging of requirements work rather than removing it. The 2001 Manifesto for Agile Software Development emphasized collaboration and responding to change, encouraging shorter feedback cycles and evolving plans. Teams may maintain a prioritized backlog and refine near-term work in greater detail than distant possibilities. Product goals, user stories, acceptance criteria, and release decisions distribute requirements information across several artifacts and conversations. This arrangement can reduce premature detail, but it can also lose rationale and cross-cutting obligations if essential knowledge remains only in participants’ memories.
Iterative work distinguishes discovery from commitment. A prototype or experiment may investigate whether a proposed capability is useful, while a delivery increment establishes behavior intended for operational use. These activities provide different kinds of evidence. Observed engagement can inform a hypothesis about usability or value, but it does not establish compliance with all system obligations. In continuous delivery, automated checks and deployment pipelines can rapidly evaluate selected acceptance criteria, while operational monitoring reveals failures and workloads that were not apparent during development. Feedback becomes input to requirements revision rather than merely a post-release maintenance concern.
Systems based on machine learning make some requirements especially difficult to express as deterministic rules. A classifier’s performance depends on the population and conditions on which it is evaluated, not solely on its program text. Requirements may therefore specify acceptable error measures, evaluation data characteristics, subgroup performance, operational limits, monitoring, and escalation behavior. Distribution shift can invalidate assumptions after deployment, even when no software component changes. A requirement for a fraud detector, for example, must consider the consequences of both missed fraud and incorrect alerts, together with the review capacity available to handle those alerts.
Automation supports requirements work through document comparison, terminology checking, duplicate detection, trace-link suggestions, and analysis of inconsistencies. Natural language processing can identify vague wording or classify requirement statements, although linguistic patterns do not reliably establish semantic correctness. Large language models can draft candidate requirements, summarize stakeholder material, and propose scenarios, but generated statements may introduce unsupported assumptions or omit unusual cases. Their outputs require examination against authoritative domain evidence and actual stakeholder decisions. The continuing research problem is not simply how to generate more requirement text, but how to preserve provenance, expose uncertainty, and determine whether evolving specifications remain justified by the systems and environments they describe.