Compute
Elastic Cloud Server
Huawei Cloud Flexus
Bare Metal Server
Auto Scaling
Image Management Service
Dedicated Host
FunctionGraph
Cloud Phone Host
Huawei Cloud EulerOS
Networking
Virtual Private Cloud
Elastic IP
Elastic Load Balance
NAT Gateway
Direct Connect
Virtual Private Network
VPC Endpoint
Cloud Connect
Enterprise Router
Enterprise Switch
Global Accelerator
Management & Governance
Cloud Eye
Identity and Access Management
Cloud Trace Service
Resource Formation Service
Tag Management Service
Log Tank Service
Config
OneAccess
Resource Access Manager
Simple Message Notification
Application Performance Management
Application Operations Management
Organizations
Optimization Advisor
IAM Identity Center
Cloud Operations Center
Resource Governance Center
Migration
Server Migration Service
Object Storage Migration Service
Cloud Data Migration
Migration Center
Cloud Ecosystem
KooGallery
Partner Center
User Support
My Account
Billing Center
Cost Center
Resource Center
Enterprise Management
Service Tickets
HUAWEI CLOUD (International) FAQs
ICP Filing
Support Plans
My Credentials
Customer Operation Capabilities
Partner Support Plans
Professional Services
Analytics
MapReduce Service
Data Lake Insight
CloudTable Service
Cloud Search Service
Data Lake Visualization
Data Ingestion Service
GaussDB(DWS)
DataArts Studio
Data Lake Factory
DataArts Lake Formation
IoT
IoT Device Access
Others
Product Pricing Details
System Permissions
Console Quick Start
Common FAQs
Instructions for Associating with a HUAWEI CLOUD Partner
Message Center
Security & Compliance
Security Technologies and Applications
Web Application Firewall
Host Security Service
Cloud Firewall
SecMaster
Anti-DDoS Service
Data Encryption Workshop
Database Security Service
Cloud Bastion Host
Data Security Center
Cloud Certificate Manager
Edge Security
Managed Threat Detection
Blockchain
Blockchain Service
Web3 Node Engine Service
Media Services
Media Processing Center
Video On Demand
Live
SparkRTC
MetaStudio
Storage
Object Storage Service
Elastic Volume Service
Cloud Backup and Recovery
Storage Disaster Recovery Service
Scalable File Service Turbo
Scalable File Service
Volume Backup Service
Cloud Server Backup Service
Data Express Service
Dedicated Distributed Storage Service
Containers
Cloud Container Engine
SoftWare Repository for Container
Application Service Mesh
Ubiquitous Cloud Native Service
Cloud Container Instance
Databases
Relational Database Service
Document Database Service
Data Admin Service
Data Replication Service
GeminiDB
GaussDB
Distributed Database Middleware
Database and Application Migration UGO
TaurusDB
Middleware
Distributed Cache Service
API Gateway
Distributed Message Service for Kafka
Distributed Message Service for RabbitMQ
Distributed Message Service for RocketMQ
Cloud Service Engine
Multi-Site High Availability Service
EventGrid
Dedicated Cloud
Dedicated Computing Cluster
Business Applications
Workspace
ROMA Connect
Message & SMS
Domain Name Service
Edge Data Center Management
Meeting
AI
Face Recognition Service
Graph Engine Service
Content Moderation
Image Recognition
Optical Character Recognition
ModelArts
ImageSearch
Conversational Bot Service
Speech Interaction Service
Huawei HiLens
Video Intelligent Analysis Service
Developer Tools
SDK Developer Guide
API Request Signing Guide
Terraform
Koo Command Line Interface
Content Delivery & Edge Computing
Content Delivery Network
Intelligent EdgeFabric
CloudPond
Intelligent EdgeCloud
Solutions
SAP Cloud
High Performance Computing
Developer Services
ServiceStage
CodeArts
CodeArts PerfTest
CodeArts Req
CodeArts Pipeline
CodeArts Build
CodeArts Deploy
CodeArts Artifact
CodeArts TestPlan
CodeArts Check
CodeArts Repo
Cloud Application Engine
MacroVerse aPaaS
KooMessage
KooPhone
KooDrive
Help Center/ CodeArts Req/ Best Practices/ Best Practices of Scrum Projects/ Requirement Management/ Making Effective Requirement Management and Planning When Software Project Requirements Change Frequently

Making Effective Requirement Management and Planning When Software Project Requirements Change Frequently

Updated on 2024-10-30 GMT+08:00

Overview

This section describes how to make effective management and planning for frequent project requirement changes in terms of background, problem analysis, and solution.

Background

Frequent requirement changes are the biggest constraint for both project-based software and product-based software development. According to China DevOps Status Report 2019, more than half of enterprises believe that frequent requirement changes are the main culprit behind delayed software delivery. Therefore, it is imperative to solve or mitigate the impact of frequent requirement changes.

Problem Analysis

Customer collaboration models, personnel capabilities, and R&D processes vary with enterprises. Such variation causes different symptoms and root causes of frequent requirement changes. As a result, measures should be taken case by case. Based on our observation and communication with enterprises, we summarize the following scenarios:

  • Requirements are disordered and frequently changed, making it difficult to manage.
  • Requirement priorities are continuously adjusted, disrupting the development plan.
  • Requirements are missing.

The following is the detailed analysis of some scenarios:

  • Scenario 1: A software project has a clear structure at its early stage, but the requirements change frequently and in detail at the later stage. How can the requirements be effectively managed and planned?

    Project team members are troubled by unclear and incomplete requirements at the early stage. As a result, the requirements need to be modified at the later stage.

    In this case, requirements are not correctly planned. Requirement levels are not clearly divided and there is no standard mechanism. For example, a customer plans a user login function, as shown in the following figure. The customer plans to release the task of administrator login in the first version. Later, a mobile number login requirement is added. This task is set to be released in the second version. As a result, a story contains multiple tasks released in different versions (or sprints), which is inconvenient for management. In this case, the key to this problem is managing requirements in a structured manner and root causes are:

    1. Failed to distinguish fragmented requirements that are continuously generated during project implementation and iterative system/product functions and features
    2. Misunderstood and misused the "Epic-Feature-Story" requirement structure provided by CodeArts.
      Figure 1 Requirement structure
  • Scenario 2: Some leader wants to upgrade requirements in a software project. How can we deal with it in the agile R&D mode?
    Upgrading requirements means raising their priorities in implementation. Therefore, this problem is about requirement priority management. To solve this problem, we need to understand:
    • Why does the leader need to upgrade requirements? If it is reasonable, the team needs to optimize the work arrangement process to minimize the impact on R&D and improve the response speed and capability.
    • How often does this happen? Frequent requirement upgrades are a bad norm. The team needs to consider the causes and how to adjust the process, system, collaboration model, or personnel capabilities. For occasional requirement upgrades, find a solution accordingly. There is no need to adjust processes and regulations.
    • Is there anything in common of the requirements to be upgraded? For example, are they related to a customer or a function domain (such as refund)? We can figure out solutions based on commonalities.
  • Scenario 3: Some urgent requirements are often added due to external reasons.

    These requirements are unexpected and definitely important. Therefore, it is about managing requirement priorities.

    It is a problem of missing important requirements, which is caused by the failure to predict requirements. To deal with this problem, the team needs to know:
    • What are the external causes? Check whether these causes have something in common and take corresponding solutions.
    • Is there anything in common of the added requirements? If yes, handle them accordingly.
    • How temporary is the addition? If the team can adjust and respond more quickly so that the temporary requirements do not affect the team, this problem is no longer a problem.
    • Why does not the team adjust the process or work style? Is it unuseful, or does not the team know how to adjust the process or work style?

Solution

Based on the root causes obtained in the preceding analysis, the problems to be solved can be classified as follows:

  1. How can we manage requirements in a structured manner?
  2. How can we manage requirement priorities?
  3. How can we avoid missing important requirements?
  • How can we manage requirements in a structured manner?

    First, we do not need structured requirement management in all circumstances. Structured requirement management is required only when there are a large number of interrelated requirements and implemented requirements need to be managed and maintained. In this case, the team needs to use the Scrum project template in CodeArts, whose "Epic-Feature-Story" structure and requirement planning function are helpful for structured management. So what is this structure based on? The answer is product or system functions and features. Information such as versions, customers, and modules that software project management focuses on can be implemented through different attributes or even tags of requirements.

    Simply speaking, perform the following steps:

    1. Establish a CodeArts project for products or systems.
    2. Establish an "Epic-Feature-Story" requirement structure.
    3. Manage different modules and versions using the attributes of work items.

    For details, see Managing Requirements in a Structured Manner.

  • How can we manage requirement priorities?

    Requirement priority management helps determine the sequence of requirement fulfillment, thereby maximizing the return and minimizing the risk or investment. To properly manage priorities, we need to:

    1. Determine the priority model, such as Kano Model. The model includes factors to be considered and comprehensive judgment principle of the factors.
    2. Prioritize requirements based on specific factor quantification and sorting criteria. For example, cost-benefit approach determines the requirement sequence by revenue and profit.
    3. Adjust requirement priorities.
    4. Improve the priority model. Adjust the model or the implementation details based on the feedback.

    For details, see Managing Requirement Priorities.

  • How can we avoid missing important requirements?

    We can take measures based on different time points, that is, before, during, and after important requirement missing. According to the Pareto principle, we need to ensure that: (1) For general problems, there are solutions for software project members to follow. (2) In special cases, there is an emergency mechanism that guides on-site handling, and a troubleshooting review.

    1. In-event: Solve the problem using a common or special solution.
    2. Post-event: Perform a review based on the model or approach to form a new common practice or special handling method.
    3. Pre-event: Specify how to distinguish between common and special situations and develop corresponding handling methods or emergency mechanisms.

    For details, see Avoiding Missing Important Requirements.

We use cookies to improve our site and your experience. By continuing to browse our site you accept our cookie policy. Find out more

Feedback

Feedback

Feedback

0/500

Selected Content

Submit selected content with the feedback