Atomic Requirements

Each requirement you write represents a single market need, that you either satisfy or fail to satisfy.  A well written requirement is independently deliverable and represents an incremental increase in the value of your software.  That is the definition of an atomic requirement.  Read on to see why atomic requirements are important.

Atomic Requirements – Revisiting

As part of the ongoing series, Writing Good Requirements – The Big Ten Rules, I wrote about the importance of atomic requirements first in 2006.  That article touched on only one aspect of atomic requirements – being able to ask “is it done?”

Writing atomic requirements is important from two perspectives – delivering value to your customers, and operating efficiently.  You get benefits both operationally, and in how you are delivering value when you write atomic requirements.

Atomic Requirements Accelerate Value Delivery

In a recent article, I proposed methods for splitting user stories when they are too large to be delivered within a single Scrum sprint.  That article looked at ways to break up complete user stories (an agile requirement artifact, similar to a use case) that were already atomic, making them even smaller.  Think of that article as Atomic Requirements 301 – sort of an advanced class on splitting the atom.  There are opportunities to subdivide molecular requirements – those made up of multiple atomic goals – the topic of this article, which would be Atomic Requirements 101.

If you’re using an agile development process like Scrum, consider a user story like the following:

  • As an online shopper, I need to find and compare similar products, a few times a year, so that I can make an informed purchasing decision.

The key element, from an atomicity perspective, is find and compare.  These are actually discrete user goals, although it may not be immediately obvious.  Rewriting as follows, will highlight this:

  • As an online shopper, I need to find products and compare similar products, a few times a year, so that I can make an informed purchase.

Rewritten like this, find products and compare similar products are clearly different activities supporting different user goals.  They should be split into separate, atomic user stories.

  1. As an online shopper, I need to find products, a few times a year, so that I can purchase desired products.
  2. As an online shopper, I need to compare similar products when shopping online, so that I can make an informed purchase.

These two user stories can be delivered separately.  If this example were for B2B (business-to-business) eCommerce, the example would be different – because the online shopper is (often) not the right persona.  A typical situation in B2B is that one person will do the research to determine what to buy, and another person will make the decision of from whom to buy it.

This rule applies for non-agile requirements development as well – consider the following “BRD-style” requirement example:

  • The system must record all purchases and submit them to the fulfillment system for processing.

Recording purchases and submitting them for processing are two different activities.  While they likely support the same goal, they may also support different goals and could be implemented separately.  Recording purchases is important not only for fulfillment, but potentially also for analytics.  Pushing data to a fulfillment system can be done in either a manual or automated fashion – providing a distinct cost-reduction opportunity.  To write these as atomic requirements, they must be separated.

  1. The system must record all purchases.
  2. The system must submit all recorded purchases to the fulfillment system for processing.

This example shows only the bare bones – there is more involved in writing either requirement, particularly around defining the non-functional requirements and business rules (see also: why you benefit when you separate rules from requirements, and the difference between business rules and business requirements) that affect and constrain each requirement.  This is easier to see when the requirements are atomic. These two atomic requirements may be rewritten as follows:

  1. The system must record all purchases on the same day that they are created, recording information per [BR117: Purchase Data Rules].
  2. The system must submit all recorded purchases to the fulfillment system for processing per [BR231: Fulfillment System Data Interchange Specification].

These additional constraints are not non-atomic additional requirements, they are constraints that specify how the system must perform the atomic actions.

The previous examples allude to another key benefit of atomicity – clean traceability.  Each requirement (or user story) exists to support one or more goals.  Requirements traceability can get complex, when many goals are dependent upon multiple requirements to be realized and many requirements enable multiple goals.  This approach to representing goal-decomposition (or user story decomposition) is critical to assuring that you are writing valuable requirements.

The simple version of traceability can be visualized with this view of structured requirements, presenting (and slightly extending) some of Karl Wiegers’ work on requirements.  If you’re doing any work in requirements of any kind, you need to read Karl’s stuff – his Software Requirements is a must-have.

This diagram makes it seem pretty straightforward.  Where it gets messy is when the multi-goal-per-requirement and multi-requirement-per-goal dependencies (that always exist) turn it from a simple tree into a complex graph.  Non-atomic requirements make that graph messier (a hassle, but not a problem)as each “requirement that is really multiple requirements” ads extra dependency relationships to your traceability model.  This becomes a problem, however, when you need to change.

Every project has implementation tasks that take longer than originally expected.  Using a time-box approach to managing the content of each release gives you a straightforward framework for determining how much stuff will be delivered in each release.  When you have to slip something, you have to revisit prioritization.  With well-defined requirements, each valuable requirement that could be delivered provides value by enabling users (or systems as users) to achieve a goal.  When you have to delay the implementation of a requirement, you delay the goals that it supports.

As soon as you realize you are considering delaying part of a requirement, that is a red flag that your requirement is not atomic.

Atomic Requirements Simplify Operations

Atomic requirements allow you to make these on-the-fly prioritization decisions with much better insight into the resultant delay in value.  This allows you to better manage communication with your stakeholders – validating that you are delaying the realization of the right goals.

The same benefits apply when originally planning your software iterations and releases.  Conceptually, you can imagine “scheduling” everything for the first release, immediately discovering that most things need to slip to future releases.  That’s how most* software projects really play out.

*There are times when you intentionally delay particular capabilities, based on external factors – market positioning, customer-adoption cadences, sales-team capacity (to absorb change), etc.


Writing atomic requirements helps you

  • Organize and describe why you are asking the team to build what they are building, and how stakeholders will benefit from what will be built.
  • Understand the assignable value of each requirement by maximizing clarity in the dependency tree – each requirement is in place for specific reasons.
  • Communicate the relevance of each requirement to the implementation team – informing cost-benefit discussions around the inevitable schedule-change discussions.
  • Test the deliverables – atomic requirements get graded as pass-fail, not “X% working.”


  • Thanks clix for both “atomic” photos!

24 thoughts on “Atomic Requirements

  1. Pingback: Mark Lipowicz
  2. Pingback: Yama
  3. Pingback: Kevin Brennan
  4. Pingback: Cliff Gerrish
  5. Pingback: Alltop Agile
  6. Pingback: Elena Plop
  7. Pingback: Cranky Product Mgr
  8. Pingback: Jaron Lambert
  9. Pingback: Eric Provost
  10. Pingback: Shardul Mehta
  11. Pingback: ProductCamp DC
  12. Pingback: itbusinessanaly
  13. Pingback: VasilyKomarov_RSS
  14. Pingback: Andrea Moe
  15. Pingback: CJ Allen
  16. Pingback: brainmates
  17. Pingback: Benoît H. Dicaire
  18. As a fan of use cases, I see things a little differently, but hold the same fundamental rule.

    Use Cases (before Alister Cockburn made them into mini specs – another story) were simple and fundamentally atomic. “What one thing does that actor want to achieve!” The expression can NOT have two verbs, nor two objects, nor even qualifiers that imply a second goal.

    There is an acronym that describes the concept of a use case.


    One Thing – One Goal. There may be secondary use cases, but they each themselves have one distinct goal. (two verbs [goals] in a use case description and you NOT only fail the questions, but should have your total marks for the whole paper halved!!!!!)

    For secondary use cases the goal describes a necessary significant step on the road to completing the primary goal. The secondary goal, as well as being distinct, MUST be already in the primary goal.
    For the goal must lie outside the scope of the primary goal.
    For generics, you have to think carefully.

    One Time – One computer session. If you can NOT get it done, you MUST have an alternate path that allows you to suspend the action, and another use case that ‘Continues the Operation’. A good guide for making use cases discrete is to ask “Could I go to lunch after I have performed this one?”

    One Place – For a person, this usually implies one user interface. When scanning documents, the operator is the primary actor and the scanning device is a secondary actor called by primary actor’s computer. The actor may stop working on the computer and assist the secondary actor by loading paper or whatever, but then they are NOT performing that use case.

    One Person (Actor) – I have worked on teams where the lead analyst happily approved two actors working at the same time on one use case.

    Given that these conditions are met, then I agree most heartily with what you describe. That was the point of Jacobson introducing the Use Case concept. They are totally ‘discrete’ or ‘atomic’ as you call it.

    I allow developers to adopt a use case as a user story.
    If it is too large for a sprint, then they may want to split it to perhaps just the ‘Happy Path’ without a couple of bells. That is fine, but it is no longer a use case, because it is NOT ‘atomic’.
    I also find that they do often want to have a user story that cleans up user interfaces, refactors things etc. These can usually be expressed as user stories but NEVER as use cases, largely because they are NOT atomic.


    1. Thanks again, Gil!

      I think we’re generally in agreement about use cases, with a minor differences. However, your point about splitting use cases and them no longer being atomic if you do, didn’t quite resonate with me. I just published Use Cases for Interactive Development which takes this part of the conversation further.

      In a nutshell, you can split use cases (or user stories) across sprints and still have them be atomic. I would love to know what you think, so check it out and let us know.

      Thanks again,


  19. I have been got at by the system. I wanted to distinguish -includes- and -extends- as use in UML, with chevrons in place of the dashes shown here. Apparently, the discussion system gives meanings to chevrons and omits them and their contents. Hence the paragraph starting with ‘For secondary use cases should read ‘for -included- secondary use cases’ and the next sentence should read #For -extended- use cases.



    1. No worries Gil, sorry about that – and great to see you here again – been a while :).

      WordPress “protects” me (us) from people trying to hack / exploit the site by stripping out anything that could be used by a ne’er-do-well who might try to enter nefarious code into a comment.

      I’ll take a look at your awesome comment in more depth asap. It deserves a more considered response than I can give at this hour on a Friday night.

      Thanks again!

Leave a Reply

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.