Software development agreement

  • Posted

Gannons worked to negotiate a working agreement between two companies. This agreement governed the use of unique software developed for a collaborative project between the two companies. When the software development agreement broke down, we stepped in to resolve the dispute.

Our client provides online 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 online functionality.

Our client’s key concerns

Our client had never embarked upon such a large project before and was nervous about how to negotiate terms. We provided assistance based on our experience with similar situations.

The developer wanted to use the concepts for other projects which our client feared would 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:

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.


CompA would write the required new computer program to an agreed specification. They also needed to provide ongoing support to develop and maintain the new computer program. Our client agreed to an implementation plan with them for the new computer program. CompA would complete each stage of development by the agreed dates as specified in the implementation plan. Finally, they would also 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; and 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 of 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. 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.

Additionally, at the end of each stage, Comp A would submit progress reports and an invoice. This 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 they did not compete in. 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.

Client ownership

Our agreement cemented beyond doubt that the IP involved was securely owned by our client. The agreement handed ownership of the copyright in the software, and design rights over the style of screen presentation to our client. Any derivative of the product or specification beyond what was originally 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 deliver 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.

The problem

CompA claimed that our client was not co-operating with them. They claimed that the scope of the work had increased but the price had not, however, 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. They made this move to try and avoid incurring 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 who had breached the contract by failing to pay invoices that CompA 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, which would have been 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.

  • It was a pleasure working with Gannons; we felt in safe hands at every step in the process.