While non-functional requirements (NFRs) are crucial to delivering high-quality products, dealing with them in an Agile environment such as Scrum teams can be challenging as they don’t map cleanly to specific product features and are often poorly understood by the team.
On the other hand, neglecting NFRs leads to technical debt accumulation and poor system quality. So how should a Scrum team deal with non-functional requirements?
In this article, we’ll cover strategies for making NFRs visible, testing them continuously, and engaging stakeholders to prioritize them. With the right approach, your team can ship robust systems that meet critical NFRs without compromising on feature delivery.
Whether you are a Scrum Master, QA, Developer, or Product Owner on the team, you’ll discover actionable best practices for capturing NFRs in the backlog, addressing them in Sprints, validating them through integration testing, and tracking the progress with metrics.
What Are Non-Functional Requirements?
Non-functional requirements (NFRs) define the quality attributes and constraints of a software system, as opposed to the specific functionality delivered to users.
They determine how well your system works, not just what it does, and place constraints on how your team delivers features.
Scrum teams must account for critical NFRs to build robust products that customers can trust. If NFRs are ignored, the team ends up accumulating technical debt, creating fragile systems, and delivering poor user experiences.
Carefully managing NFRs alongside functional requirements is essential for maximizing customer satisfaction and minimizing cost overruns from quality issues down the line.
7 Non-functional Requirements Examples
Non-functional requirements define the quality attributes and performance standards that a software system must meet.
Here are some of the 7 key NFRs that Scrum teams need to manage:
1. Performance
The performance of a system directly impacts its usability and utility to end users. Performance NFRs cover metrics like:
- Response Time: The time to return a response to a user request, such as page load times
- Throughput: The maximum rate at which the system can handle requests
- Capacity: The concurrent user load and data volumes the system can support while meeting other performance targets
- Resource Utilization: The ability to efficiently use available computing resources like CPU, memory, and I/O
Setting quantitative performance requirements, load testing early, and continuously optimizing bottlenecks helps ensure responsive systems.
2. Usability
Usability NFRs relate to how easy and intuitive the system is for users to operate. Important usability attributes include:
- Learnability: How fast users can start completing tasks the first time they encounter the system
- Efficiency: How quickly users can perform tasks once familiar with the system
- Memorability: The ease of reestablishing proficiency after a period of non-use
- Error Frequency: The rate at which users make mistakes while using the system
- Subjective Satisfaction: The perceived comfort and user-friendliness
Usability is validated through user testing with real users early and often. Setting measurable usability targets and iteratively improving UX drives adoption.
3. Security
Security NFRs aim to protect the confidentiality, integrity, and availability of the system and its data. Key aspects include:
- Authentication: Validating the identity of users accessing the system
- Authorization: Controlling access permissions and privileges of authenticated users
- Encryption: Encoding data in transit and at rest to prevent unauthorized access
- Input Validation: Sanitizing untrusted input to prevent attacks like code injection
- Session Management: Storing and validating session IDs to track logged-in users
- Auditing: Logging system activity for analysis and accountability
Continuous security testing and threat modeling are musts for identifying vulnerabilities early.
4. Operability
Operability NFRs focus on keeping a system up and running smoothly. The metrics for this NFR include:
- Availability; The percentage of time a system is operational and accessible to users
- Recoverability: The time and effort needed to restore the system after an outage or failure
- Continuity: The ability to run continuously without requiring resets or reboots
- Serviceability: The simplicity of troubleshooting and applying updates or fixes
- Adaptability: How easily the system can be modified to support changing needs
High operability reduces downtime and allows easier maintenance.
5. Capacity
Capacity NFRs specify the load volumes a system must handle with acceptable performance. Capacity metrics include:
- Concurrent Users: The number of simultaneous active users the system can support
- Data Storage: The volume of data that can be persisted and queried
- Request Rates: The throughput of read/write requests from users and subsystems
- Bandwidth: The network IOs the system must sustain without degrading
Setting capacity NFRs prevents short-term scalability shortfalls.
6. Reliability
Reliability NFRs quantify the level of system uptime and fault tolerance. Key metrics include:
- Availability: The percentage of total time the system is operational
- Durability: The probability of data being retained over a given time period
- Resilience: The ability to recover from hardware and software failures
- MTBF: The mean time between system failures for a repairable system
High reliability builds trust and enables dependence on the system.
7. Scalability
Scalability NFRs determine the ease of growing the system:
- Vertical Scaling: Increasing capacity of existing hardware resources
- Horizontal Scaling: Adding more nodes/servers to the system
- Elasticity: Automating the provisioning of resources to match demand peaks
- Performance Impact: The degradation in performance as load increases
Good scalability allows cost-efficient growth to handle increasing users and data.
How Should a Scrum Team Deal with Non-Functional Requirements?
Now that you understand the importance of managing non-functional requirements, here are some strategies that a Scrum team can use to deal with non-functional requirements:
Prioritizing NFRs
Prioritizing NFRs can be challenging for Scrum teams when stakeholders are focused on new features. In this, your team should make a case for investing in NFRs like security and performance to build a scalable platform.
The highest-risk NFRs should be identified through analysis while working with the Product Owner, and NFR-focused Sprints should be scheduled intermittently. Estimate the effort required to address key NFRs to plan capacity, and track NFR-related technical debt using relevant metrics to convey urgency.
With continuous education and evidence-based insights, you can align stakeholders on the importance of prioritizing NFR work.
Engaging with Stakeholders
Engaging stakeholders on NFRs requires ongoing collaboration. Educate them on how NFRs impact system quality and productivity and maintain an NFR backlog visible to stakeholders.
Involve them in reviews to uncover overlaps between NFRs and features. Clarify the definition and importance of NFRs that lack consensus, and conduct workshops to align on NFR priority and acceptance criteria.
Frequent engagement builds stakeholder trust that you are managing NFRs diligently in the team.
Creating Definitions of Done
Clear Definitions of Done (DoD) enable tracking of progress on addressing NFRs. For response time NFRs, define specific timing thresholds per endpoint. For security, specify completion of threat modeling and penetration testing.
Specify quantitative targets wherever possible, like uptime percentage or number of concurrent users supported. Align QA and ops teams around NFR-specific acceptance criteria during sprint demos.
Well-defined done criteria help ensure NFRs are completely addressed, not just code complete.
Using Prototypes to Validate NFRs
Prototyping delivers quick validation of NFRs like usability and performance. Start with low-fidelity prototypes to test UX concepts and flows. Use disposable prototyping tools to fail fast and iterate.
As the design solidifies, build higher-fidelity prototypes for more realistic user testing. Instrument prototypes to capture detailed usage data to inform NFR priorities.
Prototypes also enable early load testing and performance benchmarking. Embrace prototyping to validate assumptions and focus your NFR efforts.
Breaking Down NFRs
It’s easy to get overwhelmed by broad NFRs like “high performance” and “extreme reliability.” Breaking down NFRs into granular, measurable requirements helps take them from vague to concrete.
Define specific metrics like response time at the 95th percentile. Add platform stories in the backlog to meet scaling targets. Develop NFR-focused acceptance criteria for features leveraging the system.
Splitting big NFRs into smaller pieces helps drive incremental progress rather than trying to solve them all at once.
Being Flexible and Adaptable
In Agile development, it helps to be flexible and adaptable in your approach to managing NFRs. As the system and context evolve, review your NFR priorities continuously.
Accommodate emerging NFRs raised by stakeholders or incidents through priority shaping. Factor in new NFR constraints uncovered by testing into your definition of done.
Be ready to refine your architecture and platforms to meet revised NFRs. Maintaining flexibility helps you respond to changing NFR needs as your product grows.
Best Practices for Integrating Non-functional Requirements
Further, here are some ways you can leverage to integrate non-functional requirements into your Scrum events and activities:
Capturing NFRs in the Product Backlog
For a Scrum team, capturing NFRs in the backlog makes them transparent and actionable. Document NFRs like security, reliability, and performance as standalone epic stories. Specify measurable targets and acceptance criteria for each NFR, and link features to relevant NFR epics as dependencies.
Maintain a prioritized NFR backlog visible to all stakeholders. This integrates NFRs into your existing workflow rather than treating them separately. Product and Sprint Backlogs reflecting both functional and non-functional needs lead to high-quality outcomes.
Addressing NFRs During Sprint Planning
Sprint Planning presents a key opportunity to evaluate NFRs and schedule work addressing them. Review the priority, risk, and urgency of current NFR backlog items. Select a few key NFRs to focus on for the upcoming Sprint. Identify enablers, dependencies, and acceptance criteria to clarify the work involved.
Schedule NFR-related tasks and scope functional stories accordingly. Assign capacity to NFR work items along with feature development. Planning Sprints with consideration for both functions and NFRs leads to holistic progress.
Testing NFRs in Integration Sprints
Integration Sprints focused on testing NFRs like performance, reliability, and operability complement your feature sprints. Use integration sprints to baseline system qualities and analyze trends. Automate NFR tests for efficient regression testing and run scaled load tests to validate capacity and identify bottlenecks.
Test disaster scenarios via chaos experiments. Dedicated integration testing sprints provide a cadence for evaluating NFRs separate from feature development.
Validating NFRs with Stakeholders After Integration
Each integration Sprint offers an opportunity for stakeholder validation of NFR priorities and quality thresholds. Demo the integrated system for feedback on NFRs like usability and security. Review error rates, response times, and other test results.
Discuss any gaps between quality metrics and stakeholder expectations. Updating acceptance criteria and adding new NFR user stories provides continuous alignment. Stakeholder validation after integration sprints helps ensure you deliver the right quality attributes.
Metrics for tracking NFRs
Defining metrics is key to tracking progress on addressing NFRs. Monitor performance with rates like request throughput and response times. Measure reliability via system uptime and availability. Use security metrics like vulnerabilities identified from penetration testing.
Leverage usability metrics like task completion rates. Visualize metrics, set targets based on NFR priorities, and analyze trends. Data-driven insights help guide efforts toward the most critical NFR improvements.
Automated Testing for NFRs
Test automation is essential for continuously validating NFRs like performance and security at scale. Automate repetitive NFR test cases for efficiency. Implement performance testing in your CI/CD pipeline to catch regressions.
Shift security left by integrating static and dynamic analysis tools. Leverage test data generation and chaos testing to cover edge cases. When NFR testing is automated, you gain rapid feedback and can prevent quality issues from reaching users.
Challenges of Scrum Teams in Dealing with Non-functional Requirements
Dealing with non-functional requirements can be challenging and it’s vital that your team knows and anticipates these challenges:
Lack of visibility into NFRs
Scrum teams often struggle to maintain visibility into non-functional requirements (NFRs) like performance, reliability, and scalability. Unlike functional requirements that manifest as concrete stories and features, NFRs lack clear representation in the product backlog.
Without visibility into overall NFRs, you risk overlooking critical quality attributes as you incrementally deliver features. This leads to technical debt accumulation and poor system qualities like performance bottlenecks. Improving visibility into NFRs across the backlog is key to managing them effectively.
Difficulty Prioritizing NFRs
Prioritizing NFRs against functional features is another key challenge. While stakeholders understand the value of new features, communicating the importance of NFRs is difficult. NFRs like security and usability often translate into foundational platform work that is invisible to users.
As a result, NFRs get deprioritized versus new features with obvious value. To manage NFRs well, you need to engage with stakeholders continuously to prioritize these invisible requirements.
Testing Challenge
Validating NFRs like scalability and reliability requires comprehensive testing across the full integrated system. However, attempting to test them at the feature-level or in isolation leads to flawed results. NFRs often emerge from interactions between components and only manifest under realistic conditions.
To properly test them, you need to build integration testing sprints and mature test automation expertise within the team. Lacking good NFR testing practices makes it hard to ensure these critical qualities.
Lack of stakeholder agreement on NFRs
Another key NFR challenge is the lack of consensus among stakeholders regarding their relative importance and precise definitions. For instance, stakeholders may conflict over the required performance metrics or how much technical debt is acceptable.
Resolving ambiguity early around NFRs, and continually aligning with stakeholders on priority and acceptance criteria, is essential to avoiding quality issues down the line.
Conclusion
While effectively managing non-functional requirements is critical for Scrum teams to deliver high-quality products users love, it also presents a challenge especially as the Scrum Guide does not talk about NFRs.
However, with diligence and the right practices, your team can ship robust systems that meet urgent user needs while still upholding important quality standards. Your proactive management of NFRs will pay dividends in the long run.
