Common Mistakes in Managing Requirements
From Requirements Management School
A good Requirements Management process is critical in keeping software projects on track. Mistakes in managing requirements can lead to:
- Project failure
- Project overspends, and
- Projects running overtime.
Some software projects are not as successful as they could be. Some software development projects are total disasters. The projects that fall into these categories tend to have some or all of the following mistakes in common:
1. No comprehensive set of requirements – It is a poor practice to start developing a piece of software without a set of requirements. Unfortunately this is not unheard of. Projects starting based on a conversation or email will undoubtedly lead to an unsatisfying experience for all parties. Mitigate this problem, even on a small project, by following the requirements management process of:
- Elicitation
- Analysis
- Specification
- Validation
- Management
2. Ambiguous requirements – Requirements must not be open to different interpretations by the stakeholders. This is a difficult mistake to avoid but it can be mitigated. The validation process is where any ambiguity should be identified. When the draft Requirements Document is issued it should include test cases and system requirements. This will ensure that the likelihood of the document being interpreted differently by different stakeholders is minimized.
3. Not getting all the stakeholders involved in the requirements process – It is very important to get all stakeholders involved to avoid requirements falling through the gaps. Adding new requirements that could have been identified at the projects outset can cause huge issues for the project from lengthened project times; increased costs; and even degradation of code. This mistake is easily mitigated. When a project is initiated the business process should be reviewed from end to end. Carrying out this review will ensure that every stakeholder is identified. Once identified they should be fully engaged with throughout the lifecycle of the project.
4. No adequate managements of the requirements after the initiation stage – Firm management and control are required to ensure that there is minimal requirements creep. A couple of things that will help mitigate this are:
- Clearly identifying the scope of the project from the outset. This will help deflect new requirements that fall outside the original scope.
- Have a robust process for reviewing, validating and approving change requests.
5. Developers including functionality not in the requirements document – Developers can sometimes get a little carried away. They have to be managed in the same way as the other stakeholders. Sometimes developers can be overtaken by creativity and try to add unrequested functionality. This is known as “gold plating”. This can be mitigated by making sure that the developers keep to the “KISS” principle. Keeping it simple means creating a robust, lean and simple design. This mistake is mitigated by ensuring that traceability of the functionality is bidirectional to the requirements and to the code.
The biggest cause of overspend and overrun in software projects is rework cause by the mistakes outlined above and related mistakes. Requirements that are properly elicited, defined, validated and managed will help maximize the overall success of a project.
