By Theresa Mathabire, MPM, PMP
Modern software engineering has shifted its focus from measuring outputs to delivering meaningful outcomes.
The Limitations of KPI-Driven Delivery
For decades, KPIs have served as the dominant framework for measuring success in software engineering and project delivery. These metrics typically evaluate past performance and are widely used to track efficiency, productivity, and throughput. However, KPIs are inherently lagging indicators, meaning they measure outcomes that have already occurred and provide limited ability to influence future results (Geddes, n.d.). This challenge reflects a broader issue in measurement theory, where metrics designed for evaluation are often misused as targets, ultimately distorting behavior.
This reliance on lagging indicators creates systemic challenges. Teams often optimize metric attainment rather than value delivery, leading to behaviors such as inflating estimates, prioritizing volume over quality, or focusing on easily measurable outputs. Research has shown that agile teams frequently struggle to align performance metrics with strategic business objectives, resulting in a disconnect between delivery activity and actual value creation (Adewusi et al., 2022).
As software systems grow more complex and organizations increasingly adopt AI-enabled development practices, the limitations of KPI-driven measurement become more pronounced. There is a growing need for a new approach that not only measures performance but also actively guides teams toward meaningful outcomes.
The Shift Toward Value-Centric Delivery
Modern software engineering has evolved from a focus on output to a focus on outcomes. Organizations are no longer concerned solely with how much work is delivered, but with whether that work generates tangible value for customers and the business. This shift is reflected in the field of Value-Based Software Engineering (VBSE), which emphasizes aligning development practices with stakeholder value and organizational goals (Haindl & Plösch, 2021).
Despite this evolution, a significant gap remains in how value is measured. While frameworks exist for identifying value-oriented metrics, research indicates that many organizations struggle to operationalize these concepts into practical measurement systems (Salleh et al., 2023). This gap highlights the need for a more structured and actionable approach to value measurement, one that can guide teams in real time and align delivery efforts with strategic objectives.
Defining Key Value Indicators (KVIs)
Key Value Indicators (KVIs) represent an emerging framework for addressing the limitations of traditional performance metrics. KVIs are best understood as forward-looking, outcome-driven indicators that measure the value impact of delivery activities rather than their output or efficiency.
Emerging research describes KVIs as metrics that connect operational performance to stakeholder value, risk, and long-term outcomes, providing a more holistic and decision-oriented view of systems (Shokrnezhad et al., 2025). Similarly, ICT research frameworks position KVIs as tools for assessing value-related outcomes in technology systems, emphasizing their role in guiding strategic decisions rather than merely reporting performance (Gavras, 2024).
This reframing shifts the central question from “How well did we perform?” to “What impact are we creating?” By focusing on outcomes rather than outputs, KVIs encourage behaviors that align with long-term value creation and organizational priorities.
From Lagging Metrics to Value-Driven Indicators
The distinction between KPIs and KVIs can be understood through the lens of leading and lagging indicators. Lagging indicators measure past performance and are typically easier to quantify, but they offer limited ability to influence future outcomes. In contrast, leading indicators provide early signals that can guide decision-making and enable proactive adjustments (Leung, 2025).
KVIs extend this concept by incorporating not only predictive insights but also explicit connections to value creation. While KPIs provide visibility into operational performance, KVIs guide teams toward outcomes that matter to stakeholders and the broader organization. This shift reduces the risk of metric gaming and fosters a culture focused on delivering meaningful impact. While these differences highlight the conceptual advantages of KVIs, the most significant distinction lies in the behaviors each framework induces within teams.
Behavioral Implications of Measurement Frameworks
A critical, yet often overlooked, aspect of performance measurement systems is their influence on behavior. Metrics do not merely evaluate outcomes, they actively shape how teams prioritize work, make decisions, and allocate effort. The comparative analysis of KPIs and KVIs reveals a fundamental distinction: KPIs tend to incentivize activity optimization, while KVIs promote value optimization. This distinction has significant implications for software delivery teams.
Under KPI-driven models, teams are frequently incentivized to meet predefined numerical targets, which can unintentionally encourage counterproductive behaviors. For example, metrics such as test coverage percentages may lead to the creation of superficial tests designed to increase coverage without improving reliability. Similarly, deployment frequency metrics may encourage teams to increase the number of deployments without regard to stability, resulting in increased rollbacks and production risk. This dynamic reflects Goodhart’s Law, which highlights the inherent risk of metric-driven systems, where the act of targeting a measure undermines its validity as an indicator of true performance (Goodhart, 1975; Strathern, 1997).
In contrast, KVIs shift the focus toward outcomes that directly reflect business value and system health. Metrics such as test reliability, safe deployment velocity, and vulnerability response time encourage teams to prioritize quality, resilience, and customer impact. The behaviors induced by KVIs are inherently aligned with organizational objectives, as they emphasize meaningful outcomes rather than intermediate activities.
This distinction can be observed across multiple dimensions of software delivery. KVI-based metrics consistently drive proactive behaviors such as strengthening test suites, improving CI/CD pipelines, addressing technical debt, and focusing on critical user experiences. In contrast, KPI-based metrics often result in reactive optimization, where teams adjust their behavior to meet targets without necessarily improving underlying outcomes.
The implication for organizations is significant: the choice of measurement framework directly influences team culture and effectiveness. By adopting KVIs, organizations can foster a culture of continuous improvement, accountability, and value-driven execution. This represents a shift from measuring effort to enabling impact.
Applications in Software Delivery
The practical implications of KVIs can be illustrated through common software delivery metrics. Traditional KPIs such as test coverage, deployment frequency, and vulnerability often measure activity rather than effectiveness. For instance, test coverage may increase without improving the reliability of tests, while deployment frequency may rise without ensuring stable releases. In contrast, KVIs focus on outcomes such as test reliability, safe deployment velocity, and vulnerability response time. These metrics align more closely with stakeholder value by emphasizing quality, stability, and responsiveness. Research on value-oriented metrics supports this approach, highlighting the importance of aligning technical measurements with business and customer outcomes (Haindl & Plösch, 2021).
Even widely adopted frameworks such as DORA metrics, while valuable, primarily provide operational visibility and do not inherently measure business impact (Rajakumar & Singh, 2025). KVIs build upon these metrics by connecting them more directly to value creation.
AI as an Enabler of Value-Based Measurement
The rise of artificial intelligence and large language models introduces new possibilities for evolving measurement frameworks. Traditional metric systems often require significant manual effort to define, collect, and analyze data. In contrast, AI enables the automation of metric generation, pattern recognition, and insight extraction.
Recent research highlights the importance of predictive and value-aligned metrics in improving engineering productivity and decision-making (Biswas, 2025). By leveraging AI, organizations can move from static reporting systems to adaptive frameworks that continuously learn and evolve.
Applied Experiment: KVI Development and Dashboard Visualization
To explore the practical application of KVIs, an experimental approach was conducted using GitHub Copilot. Leveraging AI-assisted analysis, traditional KPI-based metrics were re-evaluated and transformed into value-oriented indicators. These indicators were then visualized through a lightweight dashboard designed to provide real-time insights into delivery health and value creation.
Importantly, these KVIs were socialized with multiple development teams within an enterprise environment to validate their relevance and applicability. Feedback from practitioners indicated that KVIs were more intuitive for decision-making discussions and better aligned with team priorities compared to traditional KPIs.
Figure 1. KVI Dashboard for Software Delivery Teams
The dashboard presents a set of eight KVIs across categories such as quality, security, velocity, and community. Key examples include a Test Reliability Score, Dependency Health Score, Production Incident Rate, and Vulnerability Response Time. Each indicator is constructed using composite formulas that combine multiple contributing factors, enabling a more holistic view of system health and value delivery.
Visually, the dashboard emphasizes progress toward targets, trend indicators, and areas requiring attention. Aggregate metrics such as overall health percentage and alert counts provide a high-level summary, while individual indicators offer actionable insights. This structure demonstrates how KVIs can be operationalized into a practical, scalable measurement system.
Figure 2. KVI Data Sources and Tier Mapping
Operationalizing KVIs: Tiers and Data Architecture
To ensure that KVIs are not only conceptually sound but also practically implementable, a structured model was introduced to organize indicators by relative importance and operational context. This model consists of a tiered framework and a clearly defined data architecture.
The tiered model categorizes KVIs into four levels based on their impact on system health and business outcomes. Tier 1 indicators represent the most critical measures, forming the foundational layer required to ensure system stability, quality, and reliability. These include metrics such as test reliability, dependency health, and production incident rates. Tier 2 indicators focus on high-priority dimensions such as velocity and security, enabling organizations to balance speed with risk management. Tier 3 indicators emphasize sustainability and long-term maintainability, while Tier 4 indicators are context-specific and can be tailored to individual team or domain needs.
This tiered approach introduces a prioritization mechanism that allows organizations to focus on the most impactful indicators first, ensuring that measurement efforts align with both operational and strategic priorities.
Equally important is the underlying data architecture required to support KVIs. Each indicator is derived from data sources within the software development lifecycle, including test runners, code coverage tools, CI/CD pipelines, security scanners, and monitoring platforms. These data sources are accessed via APIs and aggregated to calculate composite KVI scores. By explicitly defining data sources and collection methods, KVIs move from abstract concepts to actionable metrics that can be implemented within existing toolchains.
Figure 2 illustrates how KVIs are mapped to their respective tiers and data sources, demonstrating a scalable and repeatable model for value-based measurement.
Implementation and Hybrid Measurement Model
The adoption of KVIs does not necessitate the elimination of KPIs. Instead, a hybrid model offers the most effective approach. In this model, KPIs continue to serve as operational indicators for system health, compliance, and performance monitoring, while KVIs guide strategic decision-making and value alignment.
Frameworks such as SAFe emphasize the importance of measuring outcomes alongside flow and competency, reinforcing the need for balanced measurement systems (SAFe, 2025). Similarly, research on leading and lagging metrics underscores the importance of combining both types of indicators to achieve a comprehensive understanding of performance (Howard, 2025).
By integrating KVIs into existing measurement frameworks, organizations can enhance their ability to deliver value while maintaining operational stability.
Conclusion
The evolving landscape of software engineering demands a shift in how success is measured. Traditional KPI-driven approaches, while useful for reporting historical performance, are insufficient for guiding teams toward future value creation. As organizations increasingly adopt Agile, DevOps, and AI-driven practices, measurement frameworks must evolve to reflect these changes.
This paper has demonstrated that Key Value Indicators provide a viable and necessary evolution of performance measurement. By focusing on outcomes rather than outputs, KVIs align engineering activities with business objectives, reduce the risk of metric manipulation, and enable more informed decision-making. The integration of AI further enhances this capability by enabling adaptive, data-driven insights that were previously difficult to achieve. The applied experiment presented in this paper reinforces the practical viability of KVIs. The development and validation of a KVI dashboard, combined with feedback from engineering teams, demonstrates how value-based measurement can be operationalized within real-world environments without disrupting existing workflows.
The transition from KPIs to KVIs is not simply a change in metrics, but a shift in mindset. Organizations that prioritize value-driven measurement will be better positioned to navigate complexity, improve delivery outcomes, and maintain alignment with strategic goals. A hybrid approach that integrates both KPIs and KVIs offers a balanced path forward, enabling organizations to retain operational visibility while advancing toward a more intelligent and value-centric future. Ultimately, the distinction between KPIs and KVIs is not merely a difference in measurement technique, but a difference in the behaviors they induce, making measurement design a critical lever for organizational transformation.
Appendix A
KPI vs KVI Behavioral Comparison Summary
| Area | KPI Focus | KVI Focus | Key Behavioral Difference |
| Testing | Code coverage % | Test reliability | Quantity vs effectiveness |
| Deployment | Deployment frequency | Safe deployment velocity | Speed vs reliability |
| Security | Vulnerabilities scanned | Vulnerability response time | Detection vs resolution |
| Stability | Bugs closed | Incident rate | Activity vs customer impact |
| Productivity | Story points | Customer impact | Output vs outcomes |
| Dependencies | Outdated packages | Dependency health | Count vs risk management |
| Documentation | Comments per LOC | Documentation coverage | Volume vs usability |
This appendix provides a detailed comparison of KPI-based and KVI-based measurement approaches across key areas of software delivery. Each example highlights the behaviors induced by traditional performance metrics compared to value-driven indicators, illustrating how measurement design directly influences team outcomes.
A.1 Test Coverage vs Test Reliability
KPI Approach: Test Coverage
- Metric: Percentage of code covered by tests (e.g., 85%)
- Limitation: Encourages measurement of test quantity rather than effectiveness
- Behavior Induced:
- Writing superficial tests to increase coverage
- Testing trivial or low-risk code paths
- Ignoring critical edge cases not covered by percentage targets
- Result: High coverage metrics with low confidence in production stability
KVI Approach: Test Reliability Score
- Metric: Percentage of defects detected prior to production release
- Focus: Confidence in safe and reliable deployments
- Behavior Induced:
- Prioritization of critical user paths and edge cases
- Reduction of flaky or unreliable tests
- Emphasis on defect prevention rather than detection volume
- Result: Increased deployment confidence and reduced production defects
Insight:
While KPIs optimize for test quantity, KVIs optimize for test effectiveness, directly aligning engineering effort with system reliability and customer impact.
A.2 Deployment Frequency vs Safe Deployment Velocity
KPI Approach: Deployment Frequency
- Metric: Number of deployments within a given period
- Limitation: Measures of activity without considering quality or outcomes
- Behavior Induced:
- Splitting changes into smaller deployments to inflate counts
- Prioritizing speed over stability
- Reducing testing rigor to increase deployment rate
- Result: Increased deployment volume with higher risk of instability and rollbacks
KVI Approach: Safe Deployment Velocity
- Metric: Deployment rate combined with success indicators (e.g., no rollbacks, high uptime)
- Focus: Delivering value rapidly without compromising system stability
- Behavior Induced:
- Investment in CI/CD pipeline robustness
- Strengthening automated testing and validation processes
- Implementation of safe deployment strategies (e.g., canary releases)
- Result: Faster, more stable releases that maintain customer trust
Insight:
While KPIs emphasize speed, KVIs balance speed with reliability, ensuring that delivery performance translates into meaningful value creation.
A.3 Vulnerability Scanning vs Vulnerability Response Time
KPI Approach: Vulnerabilities Scanned
- Metric: Number of systems or dependencies scanned for vulnerabilities
- Limitation: Measures of activity rather than risk reduction
- Behavior Induced:
- Repeated scanning to meet targets.
- Limited prioritization of remediation efforts
- Lack of accountability for resolving identified issues
- Result: High scanning activity with persistent unresolved vulnerabilities
KVI Approach: Vulnerability Response Time
- Metric: Time taken to remediate vulnerabilities, weighted by severity
- Focus: Rapid mitigation of security risks and protection of systems
- Behavior Induced:
- Prioritization of critical vulnerabilities
- Implementation of automated alerting and remediation workflows
- Establishment of clear ownership and response processes
- Result: Reduced exposure to security risks and improved system resilience
Insight:
KPIs measure the detection of potential issues, whereas KVIs measure the resolution of actual risks, directly improving security outcomes.
A.4 Production Incident Rate vs Bug Count
KPI Approach: Bug Count
Metric: Number of bugs closed within a given period
Limitation: Measures activity rather than system stability
Behavior Induced:
- Closing low-priority or duplicate bugs to meet targets
- Reclassifying or deferring complex issues.
- Prioritizing quantity of fixes over severity
Result: High bug closure rates with continued production instability
KVI Approach: Production Incident Rate
Metric: Number of production incidents per period (e.g., outages, critical failures)
Focus: Stability and reliability of production systems
Behavior Induced:
- Strengthening pre-release testing and validation
- Improving monitoring and alerting systems
- Conducting root cause analysis and post-incident reviews
- Prioritizing system reliability over superficial fixes
Result: Reduced production disruptions and improved customer trust
Insight:
KPIs measures internal activity, while KVIs measure real-world system impact, aligning engineering efforts with customer experience.
A.5 Developer Productivity vs Customer Impact
KPI Approach: Story Points Completed
Metric: Number of story points completed per sprint
Limitation: Based on subjective estimates and easily manipulated
Behavior Induced:
- Inflating story point estimates
- Selecting low-complexity tasks to increase throughput
- Avoiding complex, high-value work
Result: High reported productivity with limited customer value
KVI Approach: Feature Completion with Customer Impact
Metric: Number of completed features tied to measurable customer outcomes (e.g., reduced support tickets, increased adoption)
Focus: Delivering features that create meaningful value
Behavior Induced:
- Prioritizing completion over starting new work
- Focusing on features that solve real customer problems.
- Measuring the impact of delivered functionality
Result: Increased customer satisfaction and reduced work-in-progress
Insight:
KPIs incentivize output, while KVIs incentivize outcomes, ensuring that development effort translates into real value.
A.6 Dependency Health vs Outdated Package Count
KPI Approach: Outdated Packages Count
Metric: Number of outdated dependencies
Limitation: Lacks context regarding risk, severity, or impact
Behavior Induced:
- Updating trivial dependencies to reduce count
- Ignoring critical dependencies with known vulnerabilities
- Prioritizing easy updates over impactful ones
Result: Lower outdated counts without meaningful reduction in risk
KVI Approach: Dependency Health Score
Metric: Composite score based on up-to-date packages, vulnerability exposure, maintenance activity, and deprecation status
Focus: Security, maintainability, and ecosystem resilience
Behavior Induced:
- Prioritizing updates for critical and vulnerable dependencies
- Evaluating dependency health before adoption
- Removing deprecated or unsupported libraries
- Automating dependency management workflows
Result: Reduced supply chain risk and improved long-term maintainability
Insight:
KPIs measure quantity, while KVIs measure risk and sustainability, aligning engineering decisions with long-term system health.
A.7 Documentation Coverage vs Comment Density
KPI Approach: Comment Density
Metric: Number of comment lines per lines of code
Limitation: Measures volume of comments without assessing usefulness
Behavior Induced:
- Writing redundant or obvious comments
- Copying template-based documentation
- Neglecting higher-level documentation needs
Result: Increased documentation volume with minimal usability improvement
KVI Approach: Documentation Coverage Score
Metric: Proportion of critical documentation artifacts available (e.g., APIs, architecture, onboarding guides)
Focus: Accessibility and usability of documentation
Behavior Induced:
- Creating onboarding guides for new contributors
- Documenting complex workflows and system architecture
- Maintaining up-to-date and relevant documentation
- Improving knowledge sharing across teams
Result: Faster onboarding, reduced dependency on individuals, improved collaboration
Insight:
KPIs measure documentation volume, while KVIs measure documentation usefulness and impact.
A.8 Code Quality vs Technical Debt Ratio
KPI Approach: Lines of Code (LOC) / Function Count
Metric: Total lines of code written or number of functions created
Limitation: Assumes more code equates to higher productivity or quality
Behavior Induced:
- Writing verbose or redundant code to increase output
- Copying and duplicating logic instead of reusing components
- Avoiding refactoring since it reduces overall code count.
- Prioritizing quantity of code over quality of implementation
Result: Larger, more complex codebase that is harder to maintain and evolve
KVI Approach: Technical Debt Ratio
Metric: Proportion of code requiring refactoring, maintenance, or remediation
Focus: Long-term sustainability and maintainability of the codebase
Behavior Induced:
- Refactoring complex or inefficient code
- Reducing duplication and improving modular design
- Updating outdated dependencies and frameworks
- Addressing known issues before introducing new features
Result: Cleaner, maintainable codebase that supports scalability and long-term value delivery
Insight:
KPIs encourage code quantity, while KVIs promote code quality and sustainability, ensuring that engineering effort contributes to long-term system health.
A.9 Developer Experience (DevEx) vs Build Time
KPI Approach: Build Time
Metric: Time required to complete a build process
Limitation: Focuses on a single aspect of developer workflow
Behavior Induced:
- Optimizing build steps while ignoring testing delays
- Skipping checks to reduce build duration
- Neglecting broader developer workflow inefficiencies
Result: Faster builds with inefficient overall development experience
KVI Approach: Developer Experience Score
Metric: Composite measure including build time, test duration, feedback loops, and CI/CD performance
Focus: Developer productivity and efficiency
Behavior Induced:
- Optimizing end-to-end feedback cycles
- Improving CI/CD pipeline efficiency
- Reducing delays in testing and deployment
- Enhancing tooling and workflow integration
Result: Improved developer productivity and faster value delivery
Insight:
KPIs optimize isolated metrics, while KVIs optimize the entire system, enabling sustained productivity improvements.
Appendix Closing Summary
Across these comparisons, a consistent pattern emerges: KPI-driven metrics primarily incentivize activity optimization, while KVI-driven metrics promote value optimization. This distinction highlights critical insight, measurement systems are not passive tools, but active drivers of behavior. KPI-based approaches often lead teams to focus on achieving numerical targets, which can result in unintended consequences such as metric manipulation, misaligned priorities, and superficial performance improvements.
In contrast, KVIs align measurement with meaningful outcomes, encouraging behaviors that enhance system reliability, customer experience, and long-term sustainability. By focusing on value creation rather than activity, KVIs enable teams to make more informed decisions and prioritize work that directly contributes to organizational success. These findings reinforce the central argument of this paper: the design of measurement frameworks plays a pivotal role in shaping both team behavior and delivery outcomes. Organizations that adopt value-driven indicators are better positioned to align effort with impact and achieve sustained, strategic success.
Author: Theresa Mathabire (MPM, PMP) people-centered Scrum Master and Delivery Enablement Leader who thrives in fast-paced, innovation-driven environments. I specialize in helping globally distributed engineering teams navigate complexity through clarity, collaboration, and continuous improvement. My approach focuses on enabling teams rather than directing them, strengthening cross-team communication, fostering psychological safety, and removing delivery obstacles so teams can perform at their best and deliver meaningful outcomes.
References
Adewusi, B. A., Adekunle, B. I., Mustapha, S. D., & Uzoka, A. C. (2022). Systematic review
of performance metrics and OKR alignment in agile product teams.
https://www.researchgate.net/publication/392688908
Biswas, S. (2025). Predictive metrics: Transforming engineering productivity and software.
quality. International Journal of Computer Trends and Technology.
https://ijcttjournal.org/2025/Volume-73%20Issue-1/IJCTT-V73I1P106.pdf
Gavras, A. (2024). Key value indicators: A framework for values-driven ICT development.
Telecommunication Policy Journal.
https://www.eurescom.eu/publication-key-value-indicators-a-framework-for-values-driven-next-generation-ict-solutions/
Goodhart, C. A. E. (1975). Problems of monetary management: The U.K. experience. In A.
S. Courakis (Ed.), Monetary theory and practice (pp. 91–121). Macmillan.
Haindl, P., & Plösch, R. (2021). Value-oriented quality metrics in software development. IET
Software. https://ietresearch.onlinelibrary.wiley.com/doi/10.1049/sfw2.12051
Howard, S. (2025). Leading vs lagging metrics for performance measurement.
Pintor, L., Atzori, L., & Iera, A. (2025). Sustainability in telecommunication networks and
KVIs. https://arxiv.org/pdf/2501.04356
Rajakumar, J., & Singh, R. (2025). Measuring DevOps success with DORA metrics.
https://ijcrt.org/papers/IJCRT2505957.pdf
SAFe. (2025). Measure and Grow framework.
Salleh, N., Mendes, E., & Petersen, K. (2023). Value-based software engineering: A
systematic mapping study.
https://www.diva-portal.org/smash/get/diva2:1785864/FULLTEXT01.pdf
Shokrnezhad, M., Taleb, T., Chen, Y., & Guo, Q. (2025). KPI2KVI: A multi-agent workflow.
http://mosaic-lab.org/uploads/papers/d2f2f368-fb03-4a08-bc9b-c8de4fcfd75a.pdf
Strathern, M. (1997). “Improving ratings”: Audit in the British university system. European
Review, 5(3), 305–321. https://doi.org/10.1002/(SICI)1234-981X(199707)5:3<305::AID-EURO184>3.0.CO;2-4
