In an increasingly hi-tech world, more businesses are seeking a competitive edge through bespoke software. Unlike packaged, ‘off the shelf’, software, a bespoke solution – be it a small stand-alone programme, a multi-tiered application or a large-scale system – can perform in ways that meet the unique needs of your business.
But if the key commercial benefit of bespoke software is self-evident, how to get from here to there is not always so obvious. The key is to know exactly what you want and then to make sure that the contract you sign will ensure that it is delivered. Easier said than done? Certainly. So, to help you get the deal you want, Mondaq looks at the key issues in contracting for commissioned software from a customer perspective.
Made to measure? Suits you, sir.
It may seem obvious to say that first you must know what you want the software to do, but describing this with sufficient clarity for a developer to understand what must be delivered is, in fact, one of the biggest problems the developer/customer relationship must overcome. The developer's fundamental lack of understanding of the customer's expectations is one of the most frequently cited reasons for failure in software development projects. Clarity of thought and expression is, then, essential from the outset.
Even before contract negotiations begin, a detailed analysis is needed to assess your precise functionality requirements. Give this job to the people in your organisation who actually understand the business processes in question. Then, make sure that the requirements they identify are formally documented.
Any sound customer requirements document (or specification) should describe in non-technical language the functionality required from the software and also include any key performance criteria, such as capacity, speed and ability to integrate with existing operating systems. This document will, from the outset, align the developer's understanding of what must be delivered with the customer's expectations. Illustrations of the tasks that are to be performed and how they are to be performed – known as 'use cases' – can be helpful here. Go through the use cases step-by-step and you will know that you have told the developer precisely what it is that you want the solution to do.
A technical specification may also be agreed. Whereas the functional specification describes what performance your business requires from the software, the technical specification describes in more detail how these functional requirements will be achieved (for example, system capacity and inter-operability with other software). It may be that how your requirements are fulfilled technically is not important to you as long as the software delivers the desired functionality. On the other hand, if a highly specified technical solution is the essence of the project, the contract may be based more narrowly on a detailed technical specification alone, without need to include a broader functional specification. Or the contract may combine both approaches: ie, the developer contracts to deliver the software to a technical specification (which, though precise, affords some flexibility in delivery) and which when followed will meet your functional requirements.
In practice it is not always possible to agree full specifications at the outset. With larger, more complex projects, delivery of the ultimate solution may be divided into phases, with the specifications for the earlier deliverables agreed at the outset but the specifications for later deliverables left to be agreed later. This approach risks disruption to the timetable (or even project derailment) if, when the time comes, the later specs cannot be agreed- but what choice is there? Consider that question carefully! Such risks can at least be tempered by including clear milestones for delivery of specifications, by employing effective project management and by including break provisions (ie, 'go/no-go' dates) in the event that specifications cannot be agreed.
Keeping the project on track
Managing the project to an agreed timetable provides one of the greatest challenges in commissioning software. Inadequate project management is a primary cause of failure. So if timing is critical make it absolutely clear to the developer right at the start.
One approach, particularly with large-scale systems integration projects, is to phase the development work by working to interim deliverables at defined break-points or milestones. Each phase is completed when its particular milestone is achieved, and only then does the next phase begin.
Specified remedies (liquidated damages, rights to secure third-party assistance, rights to terminate the contract) may be attached to delays or failures to meet milestones. But, whilst these are useful to incentivise timely performance, remedies like these are unlikely to provide a satisfactory resolution – particularly where the software is business critical and/or required urgently – so do not fall into the trap of thinking of them as any kind of substitute for realistic timetabling and effective project management. Contract remedies of this type usually only help you mop up – not to get the project back on track. A robust project management structure helps all parties to spot timetable slippages early so that they can be sorted out with the least disturbance to the overall time-frame. Detailed provisions should be set out in the contract, and these might include the following considerations:
- Is a dedicated project manager required?
- Have appropriate management roles, with clearly defined functions, been identified within each organisation?
- Will there be an over-arching management board with customer and developer representatives?
- In each organisation who will deal with incidents/disputes and how will these be escalated for resolution?
- What meetings/internal reviews will be held and when?
But remember, it is not the developer alone who has obligations in this respect. You, the customer, should consider your own role in ensuring the project is delivered on time. You may be required to provide software licences (if your existing software is to be used in the overall solution) or access to premises for on-site installation by the developer. What is your role in acceptance process? Are you confident you can perform? In particular, if you need third-party assistance or consents (for software licences, regulatory consents, etc.) can you obtain these on time?
The parameters of your customer obligations must also be clearly set out in the contract. A lack of clarity in this will almost always benefit the developer who will then have been handed the option (at least) to cite your failure to perform some nebulous obligation as the cause of its own failure to deliver. It may even try to charge you for any variation in its delivery obligations that may result.
Consider what might be the effects of any failure on your part to comply. Will the timetable be extended to deal with a delay caused by your default? Any extension agreed for the developer's benefit should be limited to the delay caused by the customer. It should not give carte blanche to the developer to stall in performing its own obligations. Again these factors should be detailed in the contract.
Flexibility and managing change
Once the development project is underway your requirements for the software may change. Experience shows that only in the most basic cases will the software be implemented as initially specified. The contract should set out the process by which variations will be proposed, documented, implemented and priced. Requests for change by either party should be dealt with at the appropriate level of authority, with any disagreements escalated to the appropriate person. The contract should also allow for flexibility in this by including an appropriate change control mechanism to deal with the knock-on effects for other areas of the contract (for example, specifications, milestones, the overall timetable ).
Defining success
A key issue for the customer is knowing when success has been achieved. A formal acceptance process can protect you in this by providing reassurance that the software performs according to specification before you pay. Though the detail of the tests and relevant criteria for successful completion will seldom be known at the outset, at a minimum the acceptance process should be set out formally and should include:
- the elements to be tested;
- a developer obligation to remedy any identified defects and submit for repeat testing;
- a customer right of ultimate sign-off; and
- an end-stop date for acceptance to be given.
Appropriate remedies should also be included in the contract for where the developed software consistently fails to make the grade. These should include the option to accept the faulty software with associated price reductions, to have the defects remedied by a third party at the developer's cost, and to terminate the contract and claim damages.
Whose IP is it anyway?
It is important to consider the rights that you, as the customer, want to gain in the software. As the paying customer and commissioner, you may consider that all rights in the bespoke software development automatically belong to you. Not so; in fact at law the ‘default’ position is that the rights will belong to the developer and so, if appropriate, the contract should deal with an assignment of these rights to you. Given the industry practice of developer's re-using developed code in additional programmes created for other customers, the developer will however frequently resist a wholesale assignment of the software and will prefer to grant you, the customer, only the right to use it. Consider carefully what level of rights you need in the software to achieve your given purpose - outright ownership (in which case you should also obtain the source code) or a licence (whether exclusive or non-exclusive) to use the software?
Outright ownership may be most appropriate where the developed software incorporates your ideas and creative inputs. Similarly, the purpose of commissioning the software may have been to gain a ‘leading edge’ over your competitors, in which case leaving ownership with the developer, and so enabling it to make the software freely available to others, is unlikely to be acceptable. A middle way might be to agree to an assignment from the developer provided you then license the software back to the developer subject to certain conditions (for example, restrictions (subject to competition law) on the developer licensing the software to your specified competitors or provision for the developer to pay you royalty payments). Sometimes, however, the software will be so specific to the customer’s needs that it holds no further commercial value to the developer, who may then be happy to assign all rights to the customer.
You may be satisfied for the developer to retain ownership provided you have the right to use the software for your required purposes under a licence. This is often the cheaper option. If a licence is agreed, consider any conditions attaching to it and assess whether its scope is sufficient in terms of the rights conferred, permitted users and territory. Also, are the licensed rights exclusive to you or can similar rights be given to others? Failure to determine the precise requirements for the licence up-front in the contract can lead to additional costs if you need the developer to expand the licence scope at a later stage.
Most of the conclusions to be drawn from customers’ project experiences seem like common sense; fail to plan, plan to fail; work with the developer not against him; future-proof the contract as much as possible. But time and again these prove the hardest things to achieve in practice.
The content of this article is intended to provide a general guide to the subject matter. Specialist advice should be sought about your specific circumstances.
