What Is a Software Development Contract?
Software development contracts are legally binding agreements between two or more parties that explicitly detail the expectations of both the software developer and the client requesting the development. Such contracts are vitally important in ensuring both parties are protected and all terms and conditions agreed upon are securely stated. Simply put, contracts exist to provide evidence of agreements made .
Though there is no universal template for what constitutes a software development contract, these agreements generally include the following information: As the list above shows, a software development contract is a complicated document that should not be taken lightly. While templates can be used as a starting point, each contract is unique in its specifics and must cover all the important bases to keep each party legally protected.
Crucial Clauses to Look For in a Software Development Contract
The key clauses that should be featured in your Software Development Contract include the following:
Scope of Work
The scope of work clause outlines exactly what it is that your software development company is expected to deliver. It is important to consider all factors that relate to the project such as timeline, milestones, duties and tasks to be completed, team members and others. These will need to be broken down into several different points.
This is essential especially if your project involves different partners or third party vendors. Your specifications for the project also need to be clearly outlined as part of the scope of work, so that the developer knows exactly what is expected of them and what you expect from other vendors or contractors that are hired to assist with the development.
Payment Terms
A written down payment plan is an essential clause in any Software Development Contract. This section identifies when and how much money will be paid to the development team while creating a schedule for future payments. A lot of development contracts will involve a flat fee payment plan or a stage payment plan that works in conjunction with the agreed scope of work. If there have been any items that remain unpaid from the development stage, these will also be documented in this part of the agreement.
Confidentiality Agreement
Whenever you are developing software or applications, there is always a dispute over ownership of source code. Even though you probably have ownership of your project, there may be aspects of the process that you would prefer competitors not be privy to. A confidentiality agreement can also be referred to as a non-disclosure agreement or an NDA and states that the software development team must keep your ideas a secret. It can include stipulations for what information constitutes a breach of contract, penalties for breaches and other factors that will impact the confidentiality rights of the project.
Intellectual Property Rights
The issue of Intellectual Property is especially relevant to those involved is the software and technology industry. Essentially, IP agreements will identify who will own the copyright and other rights to any software or applications that are created. In some cases, this can be the developer, with limited rights on the part of the client. It can be a tricky issue that is often disputed, so you will want to ensure that this section is clearly drafted and legally sound.
Other Clauses
There are various additional clauses that you may wish to include in your Software Development Contract, which should cover the following:
Arranging these clauses in such a way that logically flows with the different stages of development is essential to ensuring that the contract is accurate and effective.
Scope of Work and Deliverables
The heart of any software development contract is the scope of work and its associated deliverables. It’s the terms in the scope of work and description of deliverables, that spell out, in detail, what the developer is agreeing to do and the customer is expecting to receive.
For most projects, the scope of work and deliverables will include both a description of the project and a timeline. For example, the description could state that the objective is to develop an iPhone application that allows users to track their daily exercise habits. If the deliverables are based on meeting certain milestones, then the scope of work will further state that milestone 1 will be completed by December 1st and will include all coding necessary ensure that the application interfaces properly with the App Store, or state that Milestone 2 will be completed by January 15th, and the deliverables will include a fully functional and deployable application.
It’s important to define the scope of work and deliverables as clearly as possible, especially since the developer will usually base his/her compensation on the deliverables. If the work product is a tangible product, like an application, then the deliverables will usually be the application, or each individual release of the application.
If the work product is intangible, then the deliverables could include a tangible product like computer code or written documentation, or it could be based on meeting certain milestones. Following are some examples of frequently used deliverables for projects that involve software customization, integration, and development:
Deliverables based on completing milestones or phases of the project: Be sure to confirm all deliverables in the scope of work are part of the contract (and not separately attached documents). Otherwise, there is a risk the court will find the contract unenforceable for not including the terms upon which the parties had originally agreed.
Be sure to confirm the deliverables include all components, features, unreleased versions, and localizations (if applicable), and that the developer will deliver them upon completion of testing. If the contract is silent about agreeing to provide the most up to date version, there’s a risk the developer may not take the necessary steps to do so (such as keeping the source code current). If the contract is silent about providing localizations, and the customer later requests it, there’s a risk the developer may request additional compensation.
At the same time, clearly define deliverables that are outside the scope of work, especially if they are directly tied to the project. For example, be clear whether the contract includes a provision for localized versions. If it does not, then the developer would not be obligated to provide any localized versions. However, this is often a highly requested feature only after the customer starts using the product (which usually also happens quickly after the full release of the final product).
Terms of Payment and Milestones
In any business transaction, clear payment terms help ensure financial transparency between the parties. In the software world, where the deliverable usually consists of coded software itself, clients are rightly concerned to ensure they receive what they are paying for. But developers also should be given security that they will be paid on time, meaning that the payment terms in a software development contract should be constructed in such a way as to motivate both sides to perform. One of the most popular arrangements is to divide the project into stages or ‘milestones’, with the client paying for each completed stage of work upon delivery of the agreed output and acceptance by the client. This typically works best for short-term projects and can help keep a project on track when both sides commit to a formal timetable. Stretching the timetable out over a number of months increases the likelihood that things will get derailed, so for longer-term projects, deliverables can be set at intervals longer than the monthly deadline above, which lets you set your own schedule while incentivising the client to stick to his. With this sort of project, completion of milestones can be used as a catalyst to maximise efficiency, as if deadlines are missed by the client bonuses to the developer can be withheld until the next milestone is hit. For example, if coding a mobile application will take 6 months, you might break the work into monthly tasks with milestone payments of £1000, but also include the right to withhold payment of a 10% bonus until the app is completed on time. So if the project over-runs, the client can keep hold of the 10% until delivery, which might encourage him to ensure that resources are put behind the project to stick to the agreed timetable. Schedule, after all, tends to slip when you take your foot off the pedal and sheds light on the old saying: that money talks — it just isn’t always saying what you want it to say!
Intellectual Property Protection and Confidentiality
The developer retains ownership over all components of any pre-existing software utilized in the development of the new software. The client owns all rights, title, and interest in the new software developed for the client and any associated documentation. The developer is able to use any knowledge or experience gained during the development of the software for the client provided that such does not violate the confidentiality obligations put forth in the agreement with the client (and any other confidentiality agreements entered into by the developer).
As an alternative to the above clauses, both the developer and the client can agree to license the software from the owner and further obtain the right to modify, change, or create derivative mobile software from such. The client retains the right to use the licensed software according to the licensed terms, but does not gain any ownership over any of the mobile software or the associated documentation, unless otherwise agreed in the contract. It is important to keep in mind that if the client terminates the license agreement prior to any expiration date, then the client must destroy, or return to the owner, any copies of the software, or any related documentation.
Confidential Information, Confidentiality Obligations and Non-Circumvention Agreements
As with almost every contract, when creating a software development contract it is important to include provisions regarding the protection of confidential information. Confidential information can include many things among them are trade secrets, information developed by the developer for the client, information created specifically for the client, and information regarding the client, its website and/or its products or services. The client needs to protect its information from unauthorized use and disclosure. At the same time, the developer must protect proprietary information regarding its own software, algorithm(s), business, etc. As discussed above, for the client to be able to utilize the new software, the developer must use its pre-existing software, etc.
Protecting Proprietary Information and Confidential Information – Work Product. The contract should include provisions detailing the nature of the proprietary and confidential information concerning the client and the proprietary and confidential information concerning the developer. In addition, these clauses should disallow improper use or disclosure, and require appropriate action, e.g. the return of or proper destruction of software and associated documentation, should either party terminate the agreement, or the license agreement has expired.
Employees and Contractors. The contract should require both the client and developer to protect the proprietary information of the other, including any improvements, modifications, etc. made to the client’s software or to the developer’s software because of the development of the software for the client. This can be in the form of a prohibition on the developer (and its employees), and a prohibition on the client providing the developer’s proprietary information to any others. The client will also want to protect its own proprietary information by requiring the developer to insert appropriate clauses into its contracts with its employees and independent contractors, and to prohibit use or disclosure of any proprietary information obtained from the client because of the work performed.
Intellectual Property Provisions in Reseller Agreements. Adding to the complexity of customizing the contract can be the need to include provisions regarding other products sold by the client and/or the developer (e.g., a reseller agreement). Among the things to consider are the ownership and licensing of pre-existing software, possible changes to the payment schedules, strict adherence to the responsibilities, e.g., the developer will perform certain services for its other clients only during certain times/days of the week.
Keeping current with new developments (e.g., products, etc.) and/or improvements to programs, can build additional layers of complexity. This should be dealt with in the contract. There are many more things to consider when creating the contract.
Software Development Contract Example
Software Development Agreement
This Software Development Agreement is entered into as of [Enter Date] between [Enter Name of Developer] ("Developer") and [Enter Customer Name] ("Customer").
Developer and Customer are collectively referred to as the "Parties".
1. Introduction
Developer has developed certain software systems and desires to market those computer programs as part of a licensing system to be developed by the Developer. Customer wishes to license said systems from Developer.
2. Definitions
(a) License. The Developer desires to enter into a license agreement with the Customer which will provide for the reuse or redistribution of software purchased by the Customers of the Customer, and will provide for a controlling interest in the developments completed by the customer to be retained by the Developer.
(b) System. This definition refers to all the components of a business establishment such as files , records, and information systems assembled and made available to the customers of the Developer.
(c) Computer Program. Refers to a collection of ordered instructions that can be executed to perform a specific task on a computer system (i.e., a computer system is an example of a computer program).
3. Commitment and Terms
(a) The Developer will provide Customer with copies of its computer programs, copies of all documents, manuals and content, and components of the program that are useful in the development of the System by the Customer.
(b) In addition to the above mentioned commitments, the Developer will also make available a glossary containing the specifications of all the computer programs.
(c) Customer agrees to make inquiries regarding its computer programs in a professional manner, and will not engage in objections, requests for refund, or adjustments.
Pitfalls to Watch Out For
Dangers lurk in the form of boilerplate – words and phrases used repeatedly with an assumption that all is well. It isn’t. It pays to avoid these pitfalls and have a contract that serves as a premier software development contract for developers and clients alike. Generic contract language is not as dependable as a carefully crafted document. Other common pitfalls include: Forgoing the use of a written agreement. Allowing for unilateral modification. Omitting questions and/or required responses. Overlooking multiple patent and copyright provisions.
These are several commonly found pitfalls that affect an effective software development contract. Addressing these and finding negotiated solutions to common issues not only helps avoid costly post-signature disputes but also makes the dream of a working relationship with a software developer into a reality.
Strategies for Contract Negotiation
Negotiation is a critical step in the software development contract process, and clients should give careful consideration to their priorities in the negotiation. Companies with internal or outside developers may not need as detailed an agreement as a more complex project that will require outside input. When negotiating the scope of work, it is usually easier to focus on broadly defined requirements and adjust the details later, rather than risk eliminating an important capability by trying to address every detail up front. Make it clear that you expect to be updated regularly throughout the process. If an agreement for periodic updates over that time is not reached, those updates using imperfect prototypes are often overlooked by both parties. These updates help to make sure that each party has a chance to provide feedback before it’s too late. Be aware of the cost of "custom" requirements. Clients often request custom or exclusive features in order to differentiate their apps from the competition. While everyone wants something unique, remember that those features almost always come with a higher price tag and extended timelines. Make sure that you really know the market well and understand the competitive advantages of those custom features before signing the contract, so that you don’t pay too much extra. The contract negotiation process can take longer than anticipated, so make sure that the development company’s timeline syncs up with your intended launch date. It’s important to be open and honest about your budget, resources and schedule from the outset so that you and the development company can make sure the project is a good fit. Don’t forget about the updates. Technology changes fast and even the most successful apps need to be updated to work with new operating system releases and hardware. After the launch, it is typically in both parties’ interest to maintain the relationship and continue to work together on a more flexible basis for maintenance and updates. If this type of relationship is desired, make sure to address your expectations up front because an initial agreement often replaces the maintenance relationship that you will both need soon after launch.
Legal Considerations, Additions or Changes
Legally speaking, software development contracts can be straightforward, but also problematic if you are not careful and cover all areas of the contract in the scope of your agreement. For example, say a client tells one of your developers that they would like X change to be made to the original scope of the project. Even if the developer writes up an amendment to include the changes, the contract often does not allow them the authority to alter the terms. As such, it is always a good idea to write into your agreement a catchall clause that requires any amendments to the project or the terms of the contract to be put in writing and signed by both parties.
Depending on the project, there may be many different amendments made throughout the duration of the contract. When these changes don’t get documented, things can quickly spiral out of control. Cost overruns often occur, and so does frustration from the client, as you scramble to try to determine who is responsible for whose additional costs. So, while your contractor may get fried for going out of the agreed upon scope (or at least to your disadvantage), it’s not a great place to find yourself as the contracting company either.
There is also the issue of scope creeps , where work is done on the assumption that it will or should be part of the overall project. A clear explanation of how payment will be handled for scope creep should be included in the contract. For instance, it could be agreed that any additions to the project would be incorporated at specific times (typically quarterly), and then after that the project will be classified as a new one. This way, there will be no confusion, and you will have a reference point for how things should pan out when a change occurs. In some cases, you may even decide that it’s better to allow minor changes to the project itself without getting into the nitty gritty of amending every time something shifts, but you should still outline what this minor change will look like (materials, timelines, pricing, etc.).
These are just some of the legal considerations that must be examined and determined when drafting a software development contract. While the terms and conditions need to be one of the main focuses of the contract, it is also a good idea to spend some time developing concise processes for how the contract itself will be amended throughout the duration of the contract.