Software has
become critical for most large enterprises. They should adopt a reliable output
metric that is integrated with the process for gathering application
requirements.
Most large
companies invest heavily in application development, and they do so for a
compelling reason: Yet in our
experience, few organizations have a viable means of measuring the output of
their application-development projects. Instead, they rely on input-based
metrics, such as the hourly cost of developers, variance to budget, or percent
of delivery dates achieved. Although these metrics are useful because they
indicate the level of effort that goes into web application development, these
metrics do not truly answer the question: how much software functionality did a
team deliver in a given time period? Or, put another way, how productive was
the application-development group?
Flying blind
With big
money and possibly the company’s competitiveness at stake, why does much software-development company fly blind without a metric in place to measure
productivity?
First, with
every metric comes some level of overhead to calculate and track that metric.
With some metrics, the overhead has proved larger than the benefits afforded by
them. The second reason is that in many application-development organizations
there is a lack of standardized practices for calculating metrics. For example,
it is difficult to deploy output measurements if application teams are
following different approaches to capturing functional and technical
requirements for their projects. Finally, and perhaps most important, there is
often a certain amount of resistance from application developers themselves.
Highly skilled IT professionals do not necessarily enjoy being measured or held
accountable to productivity metric, especially if they feel that the metric
does not equitably take into account relevant differences among development projects.
As a result, many organizations believe there is no viable productivity metric
that can address all of these objections.
Use cases
In addition
to lacking a viable methodology for measuring productivity, organizations often
don’t have a robust way to gather and organize functional and technical
requirements for application-development projects. Instead, they list
requirements in what often amounts to little more than a loosely structured
laundry list. Organizations may have used this laundry-list approach over a
long period of time, and it thus may be deeply entrenched.
As a result,
these organizations find it difficult to fully and accurately capture
requirements and align them with the needs of their internal or external
business clients. Their application-development projects tend to suffer the
inefficiencies of shifting priorities, last-minute change requests, and
dissatisfied business users. We believe use cases provide a logical and
structured way to organize the functional requirements of an application-development
project. Each use case is a description of a scenario under which the user of
an application interacts with that application.
By focusing
first on business objectives and the functional requirements of applications
rather than on the technical requirements, both business leaders and web
Development Company find easy to understand. This structure expedites the
requirements-gathering phase of the software-development life cycle. It also
lowers the risk of failing to incorporate the functionality required by the
business and thereby reduces the amount of costly change requests and rework
during the subsequent design and build phases.
