How to Commission a Successful Application Development Project

"Over the past twenty four years, EI Technologies has developed proven processes and quality control checks that ensure that we deliver accurate and complete GIS data to our clients on time and on budget."

Building a digital geographic database requires implementing applications that will efficiently utilize the data. The good news is that many firms and agencies recognize this and either purchase off-the-shelf applications or commission an applications development project internally or through a consultant. The bad news is that most people know little about purchasing an application, let alone about commissioning a brand new application. Trusting an internal group or an external consultant to provide advice on what an application should contain and how it should be developed makes sense so long as the client follows some basic guidelines. The purpose of this article is to provide a checklist that will lead to successful applications development for any firm or agency that decides to commission an internal or What are the key components of a custom GIS application?

There are several key activities associated with the commissioning of a custom GIS application:

Recognizing that a custom application is required
Defining why one is needed and what it should accomplish
Determining that an off-the-shelf application does not already exist or that existing applications do not meet some critical criteria
Researching the anticipated costs of commissioning a custom application and budgeting for it
Getting specifications written or an RFP issued
Determining whether internal resources can supply the required application, or selecting a consultant to perform the work
Going through the design, implementation, installation, training, and testing phases of the application development
Using and maintaining the application

A client need not be an expert in software development, or indeed in GIS, to commission a successful custom application. For example, determining that an application is needed requires awareness, education or intuition. But guiding the process and knowing that an application is well written, requires expertise. This article provides this guidance by referring to the activities listed above, with the exception of issues related to RFPs and contracts.

Is an application required?

Determining that an application is required in order to make use of digital spatial data is crucial to actually developing one. Determining what type of application, and what it should provide is a different matter. You can find articles in journals, newspapers, commercial and non-commercial newsletters, the Internet, and conference proceedings describing other organization’s applications. The key to selecting a reasonable application is education. In addition to the resources listed above, consult professional organizations, user groups, and newsgroups. Although a GIS software environment may have already been selected or be in use, inquiring of various GIS vendors may produce a good list of actual applications. It is crucial to do this groundwork in order to gain a realistic view of what can be achieved.

What should the application accomplish?

Determining what an application should accomplish has to do with several factors:

What can off-the-shelf software do out of the box?
How difficult/costly/lengthy is the development?
How much time and money is available for the development?
What are the priorities for development?

Since the novice may not know what existing software application can do and how difficult it will be to be to enhance them, you should develop a prioritized list for the application, a budget, and a schedule for the project. These activities can then be balanced against the advice and estimates given by an in-house development team or a consultant. Following is a list of benefits you should consider for your application, in decreasing order of importance based on many successful projects:

Provide access. The primary purpose of a digital spatial database is to provide access to data.
Provide order. A database without an index is about as useful as a library without a catalog. Therefore, put order into the database and make it searchable by various means.
Provide meaning. A large database without a means for interpreting it is of limited use. Therefore, analytical capabilities that satisfy the needs of the greatest number of users, or those who will use the application the most should be prioritized first, while being sensitive to the needs of those who will make less use of the application
Provide flexibility. While some users’ needs can be satisfied all of the time, all users’ needs can only be satisfied some of the time. Therefore, flexible access to data and easy use of the application should be provided. This might involve giving users the ability to perform less structured analyses, or the ability to draw the data into their own software for local analysis and reporting.
Provide extendibility. A superior application allows users to build upon it so that it meets their changing needs. Therefore, this rather difficult task of making the software user-extendible should be provided.

Can existing software provide the required functionality?

All too often clients are unaware of suitable software packages that are already available on the market. And when the existing capabilities of software do not meet the requirements, there are often add-on modules from the manufacturer or third parties that will. These extensions add to the cost of the base software, but their development costs are shared between many users. In addition, there are often custom applications that have been created for other clients, which can be bought. Since another client has already paid for the development, they and the developer may be willing to sell it for a fraction of its original development cost. However, even in this age of the Internet, data about such software are difficult to gather. Following are methods for locating such software:

Go to the library. Books and articles are not systematically cataloged by search engines on the Web, so proper index searches are necessary. Seek out articles or meeting abstracts that mention a similar application.
Pick up the phone. Call around to vendors, consultants, and users who may have similar needs. You will probably get far more information from five phone calls than from five hours of searching the Internet.
Think like a business person. Consider that whoever has paid for the development of an existing add-on module or a custom application would probably be quite happy to recoup their costs while jump-starting your project.

Apply the same criteria when assessing an existing software package or application as you would when commissioning a custom application: Does it meet your requirements? Is the documentation clear? Does it pass specific performance tests? If it does not meet all criteria, it may require improvements before it can be implemented, but the cost and duration of implementation may still be less than a newly-commissioned application.

How much is this going to cost?

Estimating the cost of developing a custom application can rarely be done accurately by a software user, a manager, or even a programmer. The best person to perform such an estimate is an experienced software development manager. However, since it is often necessary for a rough estimate to be obtained before a request for development is made, the following pointers should establish a ballpark figure:

A simple application written in a macro language (i.e. a language specifically provided for customizing a particular software package) might cost $3,000 – $15,000. Such an application may provide a few additional commands or buttons, and be expected to stand alone. If the application needs to interact with an undetermined number of other applications, and be able to handle a lot of variations in the environment in which it operates, the cost will increase.
A sizeable application, consisting of perhaps a dozen or two buttons, and four to six main functional areas, and which substantially alters the function of the base software, may cost $25,000 – $50,000. Such a system, however, is still based on the commercial package, and merely enhances it.
A large application, with multiple modules and a comprehensive help system, training and production versions, and components written in several development packages or which are based on several software packages, may cost $100,000 – $500,000. If such an application is still based on a commercial GIS package, then that package is probably no longer recognizable. In all likelihood, however, such an application will probably be written from scratch, using a more generic development language.
Factors that affect cost include how failsafe the software needs to be, how much software testing is required, and if the development language is unique or industry standard. That is one of the reasons that critical applications and applications written for the government or the military are often more expensive.

One way to get a reliable estimate of the cost of a project is to divide the project into two phases: a design phase and an implementation phase. One of the outcomes of the design phase can be a professional estimate of the cost of implementation of the application. Although the implementation cost will not be known until the design phase is complete, this is a good way to increase the accuracy of any estimate. Therefore, if money is budgeted and set aside for the design phase to take place later in the year, the estimate for the implementation phase can be incorporated into the budget for the following year. A Needs Assessment, Conceptual Design, and Implementation Plan sequence, which typically constitute the design phase, can be expected to be 15 – 35 percent of the total cost of the project.

Who should write the application?

If the choice exists between utilizing an internal programming resource or hiring a consultant, several issues should be considered:

Does the internal resource have the expertise to perform the work? If not, will the organization benefit from having the internal resource gain the expertise while building the application? Will the application attain the same quality if developed in such a way? Can the project be structured such that the internal resource can benefit from the experience of a consultant?
If the internal resource possesses the expertise, can it meet the required schedule? Can the internal political structure ensure that the resource be dedicated to the project without concern that it be reassigned halfway through the project?
Is using the internal resource economical? It is usually assumed that an internal resource is cheaper than a consultant, but this may not always be true. An experienced consultant may accomplish the project quicker, and may be willing to sign a fixed-fee contract that strictly caps the cost of the project. A consultant may also be able to spread the work among a wider range of staff, and therefore charge lower rates overall, as well as offer specialists not available internally, such as technical writers.

If the choice is between several competing consultants, several additional issues should be considered:

Has the consultant written similar applications before, and if so, how many? Can they be demonstrated?

Whereas consultants may be legitimately restricted from demonstrating applications written for other clients, it should be emphasized that much “creativity” goes into describing prior project experience. Do not be afraid to ask for specific descriptions of prior projects.

A consultant who has not written a similar application before should not necessarily be rejected. Such a consultant will usually bid a lower fee in order to be awarded the contract and to gain experience from the project. This may be advantageous if the consultant demonstrates otherwise excellent qualifications and related experience, and the contract is written in such a way that the client is protected from the consultant’s inexperience.
Who will own the software? Most consultants will request, or demand, that they retain ownership of applications written for a client. Retention of ownership and of the license to use the software are not only bargaining chips in the negotiation of price, but can also play into the quality of the software. For example, an application that a consultant intends to resell will probably be more robust and more generic than one written for a single client. Likewise, a consultant writing an application with commercial potential is more likely to insert existing components that it had previously developed than if ownership and control over the final product is in question.

How to manage the development project?

Ask questions and expect answers. If the answers cannot be comprehended and an internal resource is not available to interpret them, then they should be rewritten. Although the specifics of the application may be beyond the comprehension of a general manager, there is no reason why the structure of the project cannot be clearly explained. For example, the internal documentation in a program may not make much sense to a non-programmer, but the fact that it exists, and the way that it is structured should be comprehensible to most people. Interim reports and application components should be reviewed and finalized promptly. If possible, each component should be easily compared to the project’s scope, and clearly signed off as work progresses. Most importantly, clear and concise communication should be maintained at all times.

There are several additional options for making the implementation of the project a success.

Create a rapid prototype of the application, which looks like it works. All the forms and menus are created, but none of the “guts” behind them really work. This way potential users can navigate through the components of the user interface (the GUI), and determine that it suits their way of working.
Create the user documentation (manual, help file, etc.) ahead of the application. This is an excellent way to see if all the components have been accounted for, and if the application will make sense to the end users.
Implement a pilot project. If the application is tied to data that are being generated at the same time as the application, it may be a good idea to create the application with a representative portion of the data first. This way, if either the data impact the application, or the application impacts the data in some unexpected way, changes can be made midstream.