Technical Note

The Challenges and Importances of Requirements Gathering

Personal summary from this page:
Bridge Global: Never Underestimate the Role of Requirements in Software Development!

Requirement Gathering (RG)

There are many reasons why RG is not easy, but some factors below are very relevant to personal experience:

There are various stakeholders, including technical & non-technical stakeholders
- clients
- end-users
- business analysts
- developers
- + managers
- + subject matter experts
Technical understanding is needed
- Non-technical stakeholders
  - might struggle to express their requirements
    - while developers need to understand these requirements to implement them accurately
- Developers
  - might find it challenging to explain technical constraints to non-technical stakeholders
Domain complexity
- When the project involves a complex domain, a deep understanding is required to accurately define the requirements

About software requirements & requirements gathering

Software requirements are of paramount importance in the software planning and development process.
RG/collecting requirements is not easy.
Defining clear and accurate requirements is challenging.
Ensuring the accuracy of the requirements in software development is very crucial.
It is often said as the most challenging aspect of software development
Requirements are the fundamental building blocks.
Requirements need to be comprehensive and clear.

The software requirements include the following

the description of features,
functionalities technical attributes, and
operations of the intended software system

Beware costly

Uncovering incorrect or misconstrued requirements
Rectifying incorrect/misconstrued requirements during the design or coding phase

(Full) Reasons why requirements gathering can be difficult

Communication Challenges
- understanding the needs and expectations of various stakeholders
- Miscommunication or lack of clear communication can lead to misunderstandings and inaccurate requirements
Ambiguity
- If vague or open to interpretation:
  - difficult for developers to implement them accurately
- Results:
  - features that don't meet user needs, or
  - unexpected results
Changing Requirements
- can change throughout the software development lifecycle, due to:
  - evolving business needs,
  - market changes, or
  - user feedback
- Managing these changes while keeping the project on track can be complex
Scope Creep
- When new features or functionalities are added during development
  - need proper evaluation or control
  - if not: it can lead to scope creep, delaying the project, and increasing costs.
Missing/incomplete Requirements
- can result in gaps in functionality,
- causing confusion among developers and users, and
- leading to unsatisfactory end products
Conflicting Requirements
- Different stakeholders
  - have conflicting needs or priorities
- Balancing these conflicting requirements while ensuring a coherent and functional solution can be challenging.
Assumptions
- if made during the requirements-gathering phase
  - can lead to misaligned expectations, and
  - incorrect implementation.
Technical Understanding
- Non-technical stakeholders
  - might struggle to express their requirements
    - in a way that developers can understand and implement accurately.
- Similarly, developers
  - might find it challenging to explain technical constraints to non-technical stakeholders.
User Experience
- Understanding and translating user needs
  - into effective user experiences
  - requires careful consideration of
    - usability,
    - user interface design, and
    - human-computer interaction principles.
Domain Complexity
- Some projects involve complex domains, such as
  - finance,
  - healthcare, or
  - engineering,
- which requires a deep understanding of
  - intricate business rules, and
  - processes
- to accurately define requirements.

Tips to address the challenges

Effective communication, involve all relevant stakeholders
Use prototypes to visualize the end product early in the process
- aids in clarifying requirements
- identifying potential gaps/misunderstanding
Embrace an iterative process
- gather feedback
- refine requirements
- repeat the process
  - to accommodate evolving needs
Create detailed requirement documents
- including functional & non-functional aspects
- serve as a reference point for both developers & stakeholders
Clearly prioritize requirements
- based on their importance
- based on their impact
Use visual tools
- to enhance understanding
- to reduce ambiguity
Regularly validate requirements with stakeholders
- to ensure accuracy & alignment
Maintain traceability between
- requirements
- design
- development
- testing phase
Encourage ongoing feedback between the development team & stakeholders
- Regular check-ins
  - to help validate gathered requirements
Greater involvement from clients (customer engagement) can bring greater benefits
- fewer revisions
- fewer requirement changes
- fewer delays

Beware unwanted results

unmatch expectation
iterative corrections
launch delays

What the customer needs to do

convey the vision to the developer
- through direct interaction, or
- through written communication
articulate
- the reason behind the decision
- the specific problem the software aims to address

What the developer needs to do

understand the business requirement
understand the software requirement
have clear product goals
- establish priorities
- achieve objectives

KEY TAKEAWAYS

wanted:
- detailed, clear, accurate, complete, comprehensive, and prioritized requirement
  - as reference point
- clear & effective communication
- understand need & expectation
- keep the project on track
- enhanced understanding, reduce ambiguity
- traceability
  - ensures each requirement is accounted for
challenge to embrace:
- changing requirements –> embrace iterative process
- evolving business needs
- market changes
- user feedback
- ensuring coherent & functional solution
new features/functionalities
- need proper evaluation & control
- to avoid scope creep
to avoid:
- ambiguity, vague, open to interpretation
- assumption
- conflicting requirements: conflicting needs, priorities
unwanted (result):
- incorrect implementation
- unmatched need, unexpected result
- difficult to implement accurately
- gaps in functionality
- confusion among developers and users
- unsatisfactory end products
do:
- use
  - prototype to visualize the end product early in the process
  - visual tool
    - flowchart, diagrams, wireframe
- clarify requirement
- identify potential gaps/misunderstandings
- embrace iterative process: gather feedback, refine requirements, repeat
- prioritize requirement
  - based on importance & impact
- regularly validates requirement
  - ensure accuracy & alignment