Software development agreement
- John Deane
- Updated: Sat, 17th Dec 2016
Our client provides on-line learning tools. They hired a software development company (“CompA”) to design bespoke software to manipulate data from various databases. The intention was that the software would act as a bridge to our client’s existing software providing a new functionality on-line.
Key concerns for our client we solved
- Our client had never entered into such a large project before and was nervous about how to negotiate terms. We provided the steer based on experience with similar situations.
- The developer wanted to use the concepts for other projects which our client feared an impact on the competitive edge. We dealt with that by suggesting a revenue sharing agreement strictly monitored by our client.
- Once the project got off the ground, the developer was late in delivery. We stepped in to sort out a method for resolution.
Core negotiation for the software development agreement
We look to matters that go to the commercial substance behind a project. Our aim is to avoid becoming embroiled in points under a commercial contract that are not likely to matter in the real world. In this case, the following matters were of importance:
Start off with heads of terms
We find the drafting runs more smoothly if heads of terms are agreed before pen is lifted to paper. We took our client through this process and agreed the obligations for CompA:
- Write the required new computer program to an agreed specification;
- Provide ongoing support to develop and maintain the new computer program;
- Agree to an implementation plan with our client for the new computer program;
- Complete each stage of development by the agreed dates as specified in the implementation plan; and
- Deliver the new computer program by the deadline set under the development agreement.
Decision making powers under the software development agreement
In this case, many project managers would be involved – all making decisions. We knew this could be problematic. Hence, our software development agreement outlined:
- The composition of the project team,
- The project management hierarchy,
- Deadlines for regular reports and instructions.
The decision making powers we included within the software development agreement enabled the project to run smoothly. The provisions meant that different people making different decisions should not cause delays. There was also provision for additional enhancements of the project, outside the original development specification. In such circumstances, the parties agreed to negotiate in good faith to further the development.
Rates of pay for the service provided
CompA wanted to be paid a daily rate. We pointed out that this was not as sensible as it would be to pay only for work delivered, i.e. payment on deliverables. The amount software developers charge is always contentious. In this case we agreed that:
- Our client would make payments to CompA on a stage by stage basis as agreed under the implementation plan in the agreement.
- At the end of each stage, Comp A would submit progress reports and an invoice which would be paid by our client but only following sign off at the approved board level. If testing were required, then the payment date would be extended to cover for that.
Rights to use the software
Our client knew that the infrastructure ideas were novel and potentially valuable. Our client was keen to restrict use within its markets. However, our client was less concerned about use in markets which did not compete. Permitting use by CompA was a way to reduce the development costs. Our client took that opportunity and agreed that CompA could use the software in other applications. The proviso was that our client signed off that the use was not being given to a competitor. We ensured that our client retained control.
Our agreement cemented beyond doubt that the IP involved such as copyright in the software and design rights over the style of screen presentation was securely owned by our client. Any derivative of the product or specification beyond that outlined in the development agreement would also be owned by our client.
Ability to terminate the software agreement
Our client was on a strict timescale. They needed CompA to finalise the software development within 12 months from signing. Therefore the agreement expressly stated that our client could terminate the agreement and claim losses should CompA fail to delivery on time.
Enforcing the software agreement
There were delays in the delivery of the software. 8 months after the deadline, our client was still waiting for the software to become operational. CompA then informed our client that they would not be able to integrate the new computer program with our client’s software for another 6 months. Based on this delay, our client agreed to vary the timing on the delivery of the new computer program with CompA.
In the meantime, CompA issued our client invoices for development stages that had been completed. Our client refused to pay the invoice as they were dissatisfied with the progress on the development and missed delivery deadlines.
CompA claimed that our client was not co-operating with them. The effect was that the scope of the work had increased but the price had not – the scope had increased through delay. CompA insisted that the original software development agreement should be renegotiated to reflect the higher levels of work. Our client refused to do this which resulted in CompA suspending the work.
Finding a solution
Our client initiated the dispute resolution procedure as prescribed in the development agreement. The move was made to try and avoid the costs of a court case. However, the parties could not reach an agreement. After all avenues were exhausted, our client brought a claim against CompA for repudiatory breach of contract.
CompA counterclaimed that it was in fact our client that had breached the contract by failing to pay invoices that were issued to them.
Benefit of without prejudice discussions
We continued to progress without prejudice discussions to encourage settlement. Eventually, and shortly before a crunch point, CompA agreed to settle. The crunch point was the stage of case management that required the exchange of witness statements and evidence – costly.
We prepared a settlement agreement which set out the path for completion of the project. CompA agreed to deploy more resources to finish the project for which they accepted there was no charge.
John Deane is a partner in our commercial group who regularly advises on software agreements and contracts for the development of apps. John brings the experience of negotiating the terms at the start of a project. He also knows how to negotiate problems which arise during the life of a project.