Requirements Engineering Blog
Practical guides on why, when, and how to write requirements — for students and working engineers.
The 10x–100x Rule: What a Late Fix Actually Costs
Everyone says late fixes are expensive. Here is the actual number, where it comes from, and the one lever that changes it.
Requirements for AI & Data-Driven Systems: Specifying What You Cannot Predict
Classical requirements assume deterministic behavior. Machine learning does not. Here is how to specify systems whose behavior emerges from data.
Agile vs the V-Model: Where Requirements Live in Each
Agile does not remove requirements — it moves them. Here is where they live in each model, when each wins, and how real projects blend the two.
A Requirement Is a Contract, Not a Wish List
The written spec’s real job is not documentation — it is alignment and de-risking. Here is what a requirement does when you treat it like a contract.
Prioritizing Requirements: MoSCoW, Kano, and Saying No
A specification without priorities is just a wish list again. MoSCoW and Kano are the two tools that turn a list of wants into a plan.
Requirements for Safety-Critical & Regulated Systems
In regulated domains the spec is not optional — it is the audit trail. Here is what IEC 62304, ISO 26262, and DO-178C actually demand of your requirements.
Requirements Smells: 10 Phrases That Belong in No Spec
Ban these ten phrases and you remove most of the ambiguity from any requirements document — with a concrete fix for each.
Requirements in Embedded & Firmware Projects: Freeze the Spec Early
In embedded systems a late requirement change is the most expensive mistake there is — the hardware is fabbed, the firmware is flashed, and the units are in the field. Here is what to pin down, and when.
Three Real Specs That Killed a Project (and What They Cost)
Mars Climate Orbiter, Denver’s baggage system, and the FBI’s Virtual Case File — three famous failures, each with a single requirements lesson.
After the Spec Is Written: Traceability, Versioning, and Change
The spec is the start, not the end. Traceability, baselines, and change control are what turn a requirements document into a system.
From User Story to Acceptance Criterion: Given/When/Then Done Right
A user story without acceptance criteria is a wish. Here is how to write stories and Given/When/Then criteria that a team can actually build and test.
Why Do Projects Really Fail? (It’s Almost Never the Code)
The decision that kills a project is usually made weeks before anyone writes code — at the spec. Here is why, and what it costs.
When Do You Actually Need a Written Requirements Spec?
Not every project needs a formal specification. Here is the decision rule that tells you when to write one — and when to skip it and start building.
Lastenheft vs Pflichtenheft: The What and the How, Separated
Why German engineering separates the requirements spec (Lastenheft) from the design spec (Pflichtenheft) — and how the split prevents the most expensive argument in engineering.
How to Write a Requirement That Cannot Be Misread
EARS notation, the IEEE 29148 quality bar, and the shall/should/may discipline — a repeatable template for writing requirements that are unambiguous and testable.
Requirements Engineering 101: Why, When, and How to Write Requirements
A practical introduction to requirements engineering — why written requirements matter, when you need them, and how to write ones that cannot be misread.