Ways to Improve Agile Requirements Gathering [#AgileImprovements #AgileRequirements #RequirementsGathering]

Ways to Improve Agile Requirements Gathering [#AgileImprovements #AgileRequirements #RequirementsGathering]

1. Supplement user stories
2. Involve stakeholders regularly
3. Prioritize requirements
4. Focus on executable requirements
5. Use the INVEST principle
6. Think layers, not slices
7. Prototype and update

1. Supplement user stories
User stories do not always include enough information for development decisions.

Complex or mission-critical projects especially demand more detail.

Some projects must have documentation to meet compliance or process standards.

In these cases, development teams can supplement user stories with relevant details, such as use cases and decision tables.

2. Involve stakeholders regularly
Developers can face enormous challenges when they are isolated from project stakeholders, such as users and product owners.

Too often, stakeholders get involved early, but do not see the results of the work until late in the project.

Projects can fail when stakeholders and developers fail to communicate.

Stakeholders are the experts in a project’s requirements.

They should share ideas, make suggestions and model and document requirements in each iteration.

Developers can then build and adjust the product accordingly.

Project and product owners generally prioritize those requirements for developers.

Reconsider the project if the development team cannot identify appropriate stakeholders, or if those stakeholders do not take an active role.

3. Prioritize requirements
Once a requirement is outlined, developers estimate the time and money necessary to implement the feature or functionality.

The list of requirements and estimates for the iteration can take shape as a stack of index cards, or some other method.

Due to time and budget limitations, not all requirements make it into a given iteration.

A project or product owner works with developers to prioritize the list of requirements.

They sort the stack into high- or low-priority work items for the available time and budget.

Generally, the higher priority the requirement, the more detailed the item should be.

Development teams often shelve low-priority requirements for future iterations, though it is possible to add or remove items from the list at any time.

4. Focus on executable requirements
Agile teams typically model requirements, write code, and then refine and refactor it to implement those models.

This process is called test-first design.

Modeling translates requirements into code.

Executable requirements focus on what something needs to do, and how that thing should work.

When developers work through executable models upfront, they can identify cross-requirement dependencies.

Developers can also spot potential problems via highly focused approaches, such as test-driven development.

5. Use the INVEST principle
User stories are easy to create.

Good user stories are harder to create.

To write valuable user stories, Agile teams often use the INVEST mnemonic:

Independent: Each user story should stand on its own, independent from other stories.

Negotiable: Stories are not contracts, rather opportunities for negotiation and change.

Valuable: Every story should add value for users and stakeholders.

Estimable: Every story’s time and budget costs should be calculable, based on domain and technical knowledge.

Small: User stories should be small enough to estimate and implement simply.

Testable: Make sure you can test the user story through criteria the story itself explains.
Small software requirements.

6. Think layers, not slices
With Agile requirements, it is helpful to think small.

Smaller requirements and feature sets correspond to user stories that are easier to estimate, prioritize and build.

Larger, more complex requirements tend to create dependencies, going against the INVEST principle.

Compose user stories with an eye toward the software stack, such as the front end, middleware, back end and database.

7. Prototype and update
Agile development paradigms facilitate developer experimentation, while mitigating risk through tests.

Prototyping is a useful practice to test ideas and encourage discussion with stakeholders.

Developers can update the prototype to refine the software and solidify its design.

The resulting code often is usable for the build.

7 techniques for better Agile requirements gathering
TechTarget

Like this? Leave your thoughts below...

Your email address will not be published.

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

Posted in: ,


Don`t copy text!