Introduction to the Scrum PSM-I Exam

The PSM-I exam is designed to test a candidate's knowledge of Scrum theory, practices, and their ability to apply this knowledge in various situations. The exam consists of 80 multiple-choice questions that must be completed within 60 minutes. To pass, candidates must score at least 85%, which underscores the exam's rigor.

The exam covers a wide range of topics, including Scrum roles, events, artifacts, and the principles that underpin the framework. One area that often trips up candidates is the management of Non-Functional Requirements (NFRs). While functional requirements define what a system should do, NFRs describe how the system should perform these functions. Examples of NFRs include performance, scalability, security, and usability.

Definition of Scrum PSM-I Exam

The PSM-I exam is a comprehensive assessment that evaluates a candidate's understanding of Scrum principles and their ability to apply these principles in real-world scenarios. The exam is divided into several sections, each focusing on different aspects of Scrum, including roles, events, artifacts, and the principles that guide the framework.

One of the key areas covered in the exam is the management of Non-Functional Requirements (NFRs). NFRs are critical to the success of any project, as they define the quality attributes of the system being developed. However, NFRs are often overlooked or given less priority than functional requirements, which can lead to significant issues down the line.

Understanding Non-Functional Requirements (NFRs)

Non-Functional Requirements (NFRs) are the criteria that define the quality attributes of a system. Unlike functional requirements, which describe what the system should do, NFRs describe how the system should perform these functions. Examples of NFRs include:

  • Performance: How fast the system should respond to user inputs.
  • Scalability: The system's ability to handle increased loads.
  • Security: The measures in place to protect the system from unauthorized access.
  • Usability: The ease with which users can interact with the system.
  • Reliability: The system's ability to perform its functions consistently over time.

NFRs are often more challenging to define and measure than functional requirements, but they are just as important. Ignoring NFRs can lead to a system that meets all its functional requirements but fails to deliver a satisfactory user experience.

Why Non-Functional Requirements Need Visibility

One of the biggest challenges in managing NFRs is ensuring they receive the same level of visibility and attention as functional requirements. This is particularly true in Scrum, where the focus is often on delivering functional increments of the product.

However, NFRs are critical to the overall success of the project. If NFRs are not given adequate visibility, they can easily be overlooked, leading to a system that fails to meet user expectations. For example, a system that meets all its functional requirements but is slow, insecure, or difficult to use is unlikely to be successful.

To ensure that NFRs receive the attention they deserve, it is essential to make them visible throughout the Scrum process. This can be achieved in several ways, but two of the most effective are including NFRs in the Product Backlog and incorporating them into the Definition of Done (DoD).

First Effective Way: Include NFRs in the Product Backlog

The Product Backlog is a prioritized list of all the work that needs to be done to deliver the product. It is the single source of truth for the Scrum team, and it is used to plan and prioritize work during Sprint Planning.

One effective way to ensure that NFRs receive adequate visibility is to include them in the Product Backlog. This can be done by creating separate backlog items for each NFR or by including NFRs as part of the acceptance criteria for functional requirements.

For example, if one of the NFRs is that the system should be able to handle 1,000 concurrent users, this could be added as a separate backlog item. Alternatively, it could be included as part of the acceptance criteria for a functional requirement, such as "The system should allow users to log in and view their account information, with a response time of less than 2 seconds for up to 1,000 concurrent users."

Including NFRs in the Product Backlog ensures that they are visible to the entire Scrum team and that they are considered during Sprint Planning. This helps to ensure that NFRs are not overlooked and that they are given the same level of priority as functional requirements.

Second Effective Way: Incorporate NFRs into the Definition of Done (DoD)

The Definition of Done (DoD) is a set of criteria that must be met for a product increment to be considered complete. It is a shared understanding within the Scrum team of what it means for work to be done.

Another effective way to ensure that NFRs receive adequate visibility is to incorporate them into the DoD. This can be done by adding specific NFRs to the DoD or by including a general statement that all NFRs must be met.

For example, the DoD could include a statement such as "All product increments must meet the following NFRs: performance, scalability, security, and usability." Alternatively, specific NFRs could be added to the DoD, such as "The system must be able to handle 1,000 concurrent users with a response time of less than 2 seconds."

Incorporating NFRs into the DoD ensures that they are considered during every Sprint and that they are given the same level of importance as functional requirements. This helps to ensure that the final product meets all its NFRs and delivers a satisfactory user experience.

Comparison of the Two Approaches

Both approaches including NFRs in the Product Backlog and incorporating them into the Definition of Done—have their advantages and disadvantages.

Including NFRs in the Product Backlog:

  • Advantages:
    • Ensures that NFRs are visible to the entire Scrum team.
    • Allows NFRs to be prioritized alongside functional requirements.
    • Provides a clear record of all NFRs and their status.
  • Disadvantages:
    • Can lead to a cluttered Product Backlog if too many NFRs are added.
    • May require additional effort to manage and prioritize NFRs.

Incorporating NFRs into the Definition of Done:

  • Advantages:
    • Ensures that NFRs are considered during every Sprint.
    • Simplifies the management of NFRs by including them in the DoD.
    • Helps to ensure that the final product meets all its NFRs.
  • Disadvantages:
    • May make the DoD more complex and difficult to manage.
    • Requires a shared understanding within the Scrum team of what constitutes "done."

Ultimately, the best approach will depend on the specific needs of your team and project. Some teams may find that including NFRs in the Product Backlog works best, while others may prefer to incorporate them into the DoD. In some cases, a combination of both approaches may be the most effective solution.

Conclusion

Non-Functional Requirements (NFRs) are a critical component of any project, and they play a particularly important role in Scrum. Ensuring that NFRs receive adequate visibility is essential to the success of the project, and there are several ways to achieve this.

Two of the most effective ways to manage NFRs in Scrum are to include them in the Product Backlog and to incorporate them into the Definition of Done (DoD). Both approaches have their advantages and disadvantages, and the best approach will depend on the specific needs of your team and project.

By giving NFRs the visibility they deserve, you can ensure that your project delivers a product that not only meets all its functional requirements but also delivers a high-quality user experience. This, in turn, will help you to pass the Scrum PSM-I exam and become a certified Scrum Master who is well-equipped to lead successful Agile projects.

So, whether you're preparing for the PSM-I exam or looking to improve your Scrum practices, don't overlook the importance of Non-Functional Requirements. By managing them effectively, you can ensure the success of your projects and deliver products that truly meet the needs of your users.

Special Discount: Offer Valid For Limited Time “PSM-I Exam” Order Now!

Sample Questions for Scrum PSM-I Dumps

Actual exam question from Scrum PSM-I Exam.

What are two effective ways for the Scrum team to make non-functional requirements visible?

A) Add them to the Definition of Done

B) Discuss them only during the Sprint Retrospective

C) Include them in the Product Backlog as separate items

D) Ignore them as they are not part of user stories