Channels ▼

Web Development

Complex Requirements On an Agile Project

Actual Usage Is Complex

Complex functional requirements can clearly be organized into collections of smaller functional requirements, a process called requirements disaggregation, but that doesn't imply that those smaller requirements still have value outside the context of the larger collection. For example, you could write user stories indicating that your system should capture the name and address of a customer, that it should produce a mailing list of customers, that it should enable you to narrow down that list given certain criteria, and that it should output that mailing list in a standard XML format. All interesting requirements, but each one on their own provides very little value until you put them in the greater context of sending out marketing literature to a targeted group of customers. Until all of those user stories, and more, are implemented your system really doesn't provide true business value to your stakeholders, regardless of the fact that you have been producing potentially shippable software every iteration up to that point.

Figure 2 shows how requirements on a stack can be related to one another. For example, the red requirements need to be shipped together even though one of them is further down the stack than others. The green requirements are also related to one another, although they are clustered closer to each other than the red ones. Once the product owner recognizes that there are relationships between items on the work item stack, and that a lower priority item may be preventing you from releasing higher priority items and thereby lengthening the time to value for your project, they may decide to rethink their strategy. This rethinking might mean that they reprioritize the work items or that they renegotiate with the larger group of stakeholders that they represent and drop the dependency on the lower priority work item.

Figure 2: Small functional requirements only support part of the usage workflow that provides actual value.

Understanding these more complex requirements requires a more sophisticated approach than user stories or features by themselves. A simple strategy is to organize them into "epics" or feature sets respectively, collections of small requirements that are somehow related to one another. This is similar to throwing the requirements into separate buckets—it organizes them but doesn't provide context. Context is better addressed through usage scenarios or use cases. Many Agilists are leery of use cases because they've only seen heavy use cases, often because the business analysts got out of control and wanted to capture every possible detail in the use cases. But as I show at, you can write very simple use cases in point form so as to think through the usage of your system without taking on the risk of needless documentation. Each of these bullet points could be addressed by zero or one user stories—the order of the use case steps and the "filler steps" that are addressed by manual activities or functionality implemented elsewhere provide the needed context that isn't captured by the individual user stories.

In "Scaling On-Site Customer" (, I argued that the role of XP's on-site customer—Scrum's product owner—is actually quite difficult because they need to represent a wide range of stakeholders, not just end users. This is why context is so important—different types of stakeholders will interact with the system in different ways, and you need to understand their various and often contradictory usage patterns and act accordingly. Sophisticated requirements artifacts such as use cases provide this context, the challenge then becomes writing use cases in an agile manner that avoids the needless bureaucracy often exhibited by traditional teams.

Related Reading

More Insights

Currently we allow the following HTML tags in comments:

Single tags


<br> Defines a single line break

<hr> Defines a horizontal line

Matching tags


<a> Defines an anchor

<b> Defines bold text

<big> Defines big text

<blockquote> Defines a long quotation

<caption> Defines a table caption

<cite> Defines a citation

<code> Defines computer code text

<em> Defines emphasized text

<fieldset> Defines a border around elements in a form

<h1> This is heading 1

<h2> This is heading 2

<h3> This is heading 3

<h4> This is heading 4

<h5> This is heading 5

<h6> This is heading 6

<i> Defines italic text

<p> Defines a paragraph

<pre> Defines preformatted text

<q> Defines a short quotation

<samp> Defines sample computer code text

<small> Defines small text

<span> Defines a section in a document

<s> Defines strikethrough text

<strike> Defines strikethrough text

<strong> Defines strong text

<sub> Defines subscripted text

<sup> Defines superscripted text

<u> Defines underlined text


Dr. Dobb's TV