The twelve principles that underpin the Agile Manifesto include several that link the concept of value to the delivery of working software. The focus on working software stems from one of the four values, “Working software over comprehensive documentation,” which is a reaction to projects and programs that seem to value reports and PowerPoint presentations more than putting software in the hands of users. For a typical IT organization that develops, enhances and maintains the software that the broader organization uses to do their ultimate business, value is only delivered when software can be used in production. Implementing software provides value through the following four mechanisms:
- Validation – In order to get the point where software is written, tested and implemented a number of decisions must be make. Implementing functional software and getting real people to use the software validates not only the ideas that the software represents, but also the assumptions that were made to prioritize the need and build the software.
- Real life feedback – The best feedback is generated when users actually have to use the software to do their job in their day-to-day environment. Reviews and demonstrations are a great tool to generate initial feedback, however those are artificial environments that lack the complexity of most office environments.
- Proof of performance – One of the most salient principles of the Agile Manifesto is that working software is the primary measure of progress. The delivery of valuable working software communicates with the wider organizational community that they are getting something of value for their investment.
- Revenue – In scenarios where the software being delivered, enhanced or maintained is customer facing, until it is in use it can’t generate revenue (whether the implementation is a new software supported product or improvement in the user experience of an existing product).
In most scenarios, software that is both in production and being used creates value for the organization. Software that is either being worked on or sitting in library waiting to be implemented into production might have potential value, but that potential has little real value unless it can be converted. In batteries, the longer we wait to convert potential energy into kinetic energy the less energy that exists because the capacity of the battery decays over time. Information, like the capacity of a battery, decays over time in any reasonably dynamic environment. Software requirements and the ideas encompassed by the physical software also decay over time as the world we live and work in changes. Bottom line: If the software is not in production, we can’t get value from using it, nor can we get feedback that tells us that if the work environment it will someday run in is changing; therefore, all we have is a big ball of uncertainty. And, as we know, uncertainty reduces value.