Or, download the standard PDF template.
A development contract is a binding agreement that involves the developer company and the client company. It binds them to adhere to the contract requirement. Ina nutshell, the developer and the client each has a role to play for a successful business contract as stated in the signed agreement. The client engages with the developer, and the developer agrees to the terms laid on the contract. The developer must follow strictly to the development contract details or terms which also include the time specification agreed upon. As for the time frame the developer after handing in the final work, is expected to offer support and answer any question freely to the client after the user testing has been performed on the working App or software developed. Any assistance after that time frame is chargeable and the client is liable to pay for any further assistance.
The client has the powers to terminate the development contract if there is any breach of contract. If the need or issue is raised and the developer fails to solve the issue within a given time frame, the client has the authority to terminate the contract or ask for compensation. The developer is expected to provide the client a time frame to train the client on how the application operates after it’s been delivered.
The software or app developed is expected to work correctly to the client’s specifications.If the software does not work in accordance with the provided specifications, one can write a formal letter informing the developer by which the developer is expected to respond by correcting the mistakes within a given time frame. If he fails to do so, the client has the right to walk out of the contract honoring the breach contract act.
When making the final payment, the client is expected to pay the developer on an hourly basis, and the developer is to provide an invoice that all the money shall be paid in accordance with the total fees agreed upon. Every invoice shall be submitted to the client the moment the work is finished, and he is fully satisfied with the work. When everything is done,and both parties are pleased with the work done, the developer must have it in mind that the client now holds the full rights of the product. The developer must agree that he no longer owns the copyrights to the product. Selling that work to another client is considered an infringement of the copyright law that is highly punishable by the court of laws.
A software development agreement is a contract between a developer and their client, where the developer agrees to produce a software application within a certain budget and timeframe.
Development processes can differ, depending on the scale and complexity of the project. However, no matter the size of the task at hand, the agreement should still cover important information, such as project timelines, key milestones, and payment details.
Here we take a look at this type of agreement from the freelancer’s point of view.
1. Importance of a legally binding and enforceable development contract template
All developers should never work without a valid, legally-binding and enforceable contract. Otherwise, they should expect to lose a lot of the money they work for. Clients, especially the unscrupulous ones, love dealing with developers who never ask for contracts. The beauty of contracts is that they help clarify the different responsibilities between clients and developers. However, they can also be full of legalese that makes them impossible to understand.
Development contracts are necessary when developing:
2. Types of development contracts
Developers often sign two types of contracts, which are:
The two types of developer contracts have their pros and cons. They are different in many aspects. Service agreements are longer and quite complicated. However, the length of the service agreement often depends on the size of the project.Nevertheless, what the two types of contracts have in common is the recognition of your status as an independent contractor or freelancer. Never sign a contract that doesn’t distinguish you in this manner.
A major difference between the two contracts is how they manage intellectual property.
Intellectual property is applicable in:
The copyright or intellectual property always belongs to the creator or developer. However, this changes in “work for hire” contracts where the intellectual property or copyright belongs to the client. In service agreements, the developer has more leeway. For example, the developer is free to determine the exact moment to assign copyright to the new work to a client. The developer is free to determine the “if/when” and “how” of transferring copyright.
Exchange of copyright applies whether you sign a “work for hire” or “service agreement.”
The exchange remains incomplete unless money (or its equivalent) is involved.
Unless money is paid, contractor retains intellectual property or copyright.
It’s important for developers to have an idea of the different kind of contracts they should sign. One tool that can help them achieve this is a developer contract template. With a template, developers get familiar with all the parts that should appear on the contract. Some parts are generic and appear on all contracts. Other parts only appear depending on the type of contract involved or crafted.
Templates are time-savers and cost-effective.
Templates take care of the formulaic or generic parts thus leaving you with more time for concentrating on other more relevant parts. No other person, apart from you, can identify what you intend to build. No one else can clarify how you intend to deliver what you develop, except you. Therefore, use the template to understand the kind of contract you ought to sign well; thus, avoiding costly mistakes.
Here are some of the things you need to capture in your developer contract.
2.1. A development contract clearly define responsibilities
Face it, contracts that don’t clearly outline every party’s responsibilities often ends up in a conflict. If, for example, you’re going into a web development agreement, as a freelancer, your roles in the entire process must be properly articulated. How about the client? What are their responsibilities? If it’s the provision of content, let that be included in the contract. Any client obligation that’s likely to delay or cripple your development progress must be put in written form, including what such a holdup would mean to the project timeline.
2.2. Define the termination of the development contract
When creating a contract, make sure you insert terms of termination. This is important because building a website is a complex process that’s likely to attract some challenges and misunderstandings.
When you talk about the terms of termination, the developer contract must indicate the attached responsibilities of each party in terms of information, payments and the like.
2.3. Development contract template term and warranty
Freelancers often face a contract period conflict with clients, especially where things aren’t clearly defined. Most clients believe that once they hire you, you’re there to provide support and fix bugs for as long as they’ll be using that application. In the developer contract, make it abundantly clear what responsibilities you have from start to finish, also indicating the duration of the contract and whether there is a warranty.
Here is why this is important: technology is dynamic and so what you build now may not be the best in the industry in six months or one year. If you have a warranty for the project, write it clearly in the agreement so that anything that goes wrong after the warranty expires calls for a new contract. It’s also advisable to intimate in the contract that introducing a new technology released after the project has been delivered and approved amounts to a new agreement. It also doesn’t form part of the warranty.
2.4. Agree on jurisdiction using the development agreement
The contract you sign must spell out jurisdiction. This is important because a contract is enforceable only in a single legal territory. The jurisdiction clause is especially important if your client is from a different country or state that has different laws. The two of you should come to an agreement on jurisdiction and write it in the contract. Only sign the developer contract if you fully understand the legal consequences of violating the terms of the contract.
2.5. Fees and terms of payment section of the development contract
Many freelancers only mention the total cost of the project and fail to give further details. “I’ll charge $5,000,” and that’s it. However, it's advisable to break down the amount into project fees, tax obligations, and any other components. The payment schedule must also be clear, more so where it’s not a turnkey contract.
In addition to the above points, also indicate the nature of the project. Is it a new project or a modification of an existing one? Confidentiality, copyrights, contract type, and dispute resolution clauses should also be included in the developer contract.
2.6. Your process
As stated above, software development can differ from project to project. However, there are a few common considerations, such as: agreeing to a specification; handling changes to the specification; development timetable; and client involvement. Your process should be outlined clearly from the get-go.
2.7. Project milestones
For each deliverable, you should have a milestone. That way, your client isn’t kept in the dark until everything is ready, and you have an opportunity to discuss progress and react to any changes to the project spec.
2.8. Key responsibilities
Make it clear as to who is responsible for what in this project. If you need access to existing software from your client, or someone else is responsible for providing the content to populate the application you’re developing, this needs to be immediately clarified to avoid delays.
2.9. Intellectual property
If you’re developing a custom solution, who owns the copyright once the job is completed? Will you grant a license, or assign the rights over to the client?
2.10. Payment terms
It’s common for developers to sign what’s called a turnkey contract. A turnkey contract is a form of developer contract. It differs with normal ones in many aspects.
Under a turnkey contract, the developer is legally required and expected to deliver completed projects or work only. Unlike in other contracts, here the developer never hands in a project in stages. Here, the developer is expected to work from beginning to end without the client’s input. Moreover, the developer willnot take ownership of whatever is developed. The client will take full ownership. In this arrangement, developers are different from owners/operators.
Essentially,what happens here is that the developer finishes the project before turning the key over to a different or new owner. Under this type of contract or arrangement, the developer has full control of the project. The developer makes all the necessary decisions. Furthermore, the developer makes all the appropriate changes without consulting the client. The developer solves all emerging problems.
Nevertheless,turnkey contracts are not ideal for clients who need:
Turnkey contracts give developers a reason for completing the project on time. They own the project (or whatever they are building) until they complete and hand it over to the new owner. For this reason, they often work harder and faster to develop and hand it over as quickly as possible. Apart from this, these types of contracts are popular with clients too because they have more time to seek financing, especially where huge projects are involved.
Turnkey projects are good for inexperienced clients who hate making decisions.
Turnkey contracts, just like any other developer contract, have a few drawbacks.Therefore, take time to study and read the contract in great detail before signing it. The only time you can change anything in a contract is before signing it. Once the parties involved signing the contract, it becomes legally enforceable. Any other change you feel like making to it has to be subject to everybody being on the same page and agreeing that it’s justified or warranted.
It’s good to anticipate anything that could go wrong with the development contract. Signing a contract is a sign of good faith. It demonstrates your willingness to adhere to the terms spelled out in the development contract clearly. It’s also a good way of showing the other party that you’re serious about fulfilling your side of the contract. It’s partly because of these reasons that contracts are for people aged 18 years and above.
4. Features of well crafted development contracts
A good development contract contains specific features.
Before delving into those features, it’s important to understand the purpose that a development contract serves. First, they protect the rights of all the parties that sign the contract. More importantly, the contract guarantees and secures the rights of the professional developer. The contract is a legally binding and enforceable document as stated earlier. Other than that, it provides details of:
Include all the details that ought to appear in such a type of contract. For example, the names and contact addresses of all the parties involved in the project should appear in the contract. The contract should also indicate the obligations of each party that signed it. Other than that, the contract also displays or lists all the terms of the agreement. It lists about all the legal aspects that relate to the contract.
Also, the development contract should list arbitration procedures and policies.
Arbitration is crucial in any contract signed between two or more people. It’s important because of the role it plays in conflict resolution. The fact there is a contract in place doesn’t mean conflicts will not occur. Arbitration often involves a third party. It often indicates that the two parties that signed the contract are unable to solve the emerging issues between themselves amicably. Arbitration only works when it’s in the contract.
The decision that the arbitrators make is legally binding. All parties have to respect that decision. Since arbitration is adversarial, it’s no wonder that many people try avoiding it as much as possible. It’s just as adversarial as any other form of court-based adjudication. All presentations are made with the aim of proving that one of the parties is right while the other is wrong; hence, the reason both parties seem to be against each other instead of cooperating.
Arbitration is quite effective in resolving:
Including arbitration has several benefits to the developer company. First, it’s a more flexible way of resolving conflicts compared to adjudication. The parties disputing with each other are free to choose an arbitrator of their liking.Furthermore, the arbitrator chosen is often an expert in the issue that caused the conflict. Arbitration is quicker thus guaranteeing the disputing parties a quick resolution to the issue affecting their relationship.
Contract disputes are quite normal. Disputes involving any contract signed between a developer company and clients are not too complicated. Unresolved disputes can affect a project massively. Unresolved conflicts prevent the developer from finishing the project on time as earlier envisaged. Any developer who feels that some huge misunderstandings might arise and cause prolonged disputes should insist on notarizing contracts.
5. Importance of notarizing development contracts
Notarized contracts have several advantages. Notarized contracts contain legal and binding signatures. Such contracts indicate that the parties involved are who they say they are.This saves you a lot of time and money when the court cases begin. It ensures that the courts have more time to resolve the main issues in contention quickly. This has the effect of ensuring a quick resolution of the issues thereby allowing you to return to the core business you run.
Also,arbitration is private thus ideal for people who abhor any form of negative publicity.
Development contracts talk about intellectual property a lot. It has several provisions regarding intellectual property. Developers have to learn as much as they can about intellectual property. Failure to do so would mean opening themselves up for abuse, hefty penalties, damaged reputations, and possible lawsuits. The provisions are in various categories or clauses. Some of these include:
Apart from dealing with issues revolving around Intellectual Property, a well-crafted development contract also talks about fees. The fees should be spelled out clearly to avoid confusion. Displaying the amounts involved helps to maintain the integrity of the contract. The two parties must keep their word. They must be impeccable with every word they say and every promise made.
Contact a notary public when you want the development contract notarized.
It is worth stating that the notary public doesn’t notarize documents per se. They only notarize the signatures appearing on the contract. In times past, all legal documents had to be notarized. Today, notarization is only required or considered mandatory for a few types of documents. The benefits accruing from notarizing the contracts make it worthwhile. Apart from contracts, other documents worth notarizing too include:
In law, notary publics are considered reliable witnesses. Notarized signatures are legally authentic. Consequently, federal courts (including some state courts) have no problem accepting and believing in the authenticity of documents bearing notarized signatures. In essence, notary publics notarize documents as a way of stating that they witness when the claimant signed the contract or any similar document.
Notary services are obtainable from various sources including post offices and banks.
6. What the development contract template says about timing and acceptance
A development contract must also include a clause on timing and acceptance. In terms of timing, the contract should be clear on the issue of deliverables. The developers shall state the time or period within which they will deliver the work to clients. For their part, clients will agree to review the work within the timeframe set aside for such work. Afterward, the contract expects the clients to do either of the following:
In matters of acceptance, the development contract also delves into specific issues. If the clients feel that the developer has done the work as accepted and met all requirements, they will issue a written notification within specified dates. If clients are not satisfied, they also have to let the developers know within a reasonable timeframe as stipulated in the contract. Contract stands as it is and considers work done satisfactorily if clients don’t write their:
7. What the development contract says about client responsibilities
A development contract that doesn’t highlight client responsibilities is often considered incomplete. The client has specific responsibilities that are separate from what the developer is expected to do. The contract defines these responsibilities clearly to avoid confusion. Similarly, it should indicate the responsibilities of each developer as well. Contracts clarify matters and remove the loopholes that could make one or both parties abdicate their responsibilities.
Therefore,do not take development contract lightly. Use it to reinforce the relationship and transactions taking place with your clients. Let it highlight everything that you and the client have to do. Ensure that the contract is not only legally binding, but also enforceable. Let the contract specify what the two parties will do in case of conflicts, especially the conflict resolution mechanisms that are open to both of you.
8. Why do you need a development agreement?
A written agreement is vital to the success of any freelance project. But it’s especially important for software projects, as it can also act as a roadmap. And when drafted correctly, it can help avoid bumps and detours along the way.
If your client has an issue with the direction of the project, or if you believe your client is failing to hold up their end of the bargain, you can both refer to the agreement with a view to resolving the disagreement. This will ensure the project remains on course.
9. Our top tips for writing a winning development contract
If you're ready to put together a professional development agreement, check out below three easy steps to certain success:
9.1. Don’t skimp on the details in your development contract template
Developing a new piece of software for a client can be exciting, but it’s not without its challenges. That’s why you need to ensure both you and your client are on the same page from day one of the project. You can’t leave anything to chance, as even the smallest misunderstanding could set the project back, costing you time and money.
When drawing up your agreement, be painstakingly clear throughout. If you need software access or information by a certain date to progress the project on time, highlight this. If you need client feedback before moving onto the next stage, put a timeframe to it (e.g. 48 hours after the version was shared).
Avoid ambiguity and aim for precision; just as you would when writing the code! Speaking of which…
9.2. Clarify what happens to the source code
We touched on Intellectual Property (IP) above, and it’s vital that you and your client come to an agreement over who owns what when the project concludes. But there’s also the question of what happens to the source code.
To answer that, you need to make it clear how and where the code will be securely stored, how it will be backed up, who is for responsible for backups, and who can access it. This is especially important if you choose to grant a license to use the code, as opposed to assigning the rights to the client.
9.3. Don’t offer support & maintenance as an afterthought
You might be tempted to roll support and maintenance into your development agreement, but there’s an argument for keeping it to a separate contract.
Software development is evolving at a rapid pace. If you add support and maintenance to your contract as an afterthought, you could be contractually on the hook every time your custom software needs an update in order to continue working.
With this in mind, it’s better to offer an entirely separate agreement; one that’s highly detailed around the services and obligations related to support and maintenance. This will allow you to set boundaries and expectations surrounding these tasks, without turning your initial contract into an unwieldy, text-heavy document.
After all, the last thing you want is to be left responsible for maintaining software long after the project is concluded — especially if the working relationship becomes strained.
Follow these tips and make sure your next software development agreement helps you deliver your project on time, on budget and hassle-free.
Development Contract Template
This Contract is between Sample Client (the "Client") and John Doe (the "Developer").
The Contract is dated [the date both parties sign].
1. WORK AND PAYMENT.
1.1 Project. The Client is hiring the Developer to do the following: Perform development services for the Client.
1.2 Schedule. The Developer will begin work on April 17, 2020 and the work is ongoing. This Contract can be ended by either Client or Developer at any time, pursuant to the terms of Section 6, Term and Termination.
1.3 Payment. The Client will pay the Developer a rate of $170.00 (USD) per hour.
1.4 Expenses. The Client will reimburse the Developer's expenses. Expenses do not need to be pre-approved by the Client.
1.5 Invoices. The Developer will invoice the Client weekly. The Client agrees to pay the amount owed within 15 days of receiving the invoice. Payment after that date will incur a late fee of 1.0% per month on the outstanding amount.
1.6 Support. The Developer will not provide support for any deliverable once the Client accepts it, unless otherwise agreed in writing.
2. OWNERSHIP AND LICENSES.
2.1 Client Owns All Work Product. As part of this job, the Developer is creating “work product” for the Client. To avoid confusion, work product is the finished product, as well as drafts, notes, materials, mockups, hardware, designs, inventions, patents, code, and anything else that the Developer works on—that is, conceives, creates, designs, develops, invents, works on, or reduces to practice—as part of this project, whether before the date of this Contract or after. The Developer hereby gives the Client this work product once the Client pays for it in full. This means the Developer is giving the Client all of its rights, titles, and interests in and to the work product (including intellectual property rights), and the Client will be the sole owner of it. The Client can use the work product however it wants or it can decide not to use the work product at all. The Client, for example, can modify, destroy, or sell it, as it sees fit.
2.2 Developer’s Use Of Work Product. Once the Developer gives the work product to the Client, the Developer does not have any rights to it, except those that the Client explicitly gives the Developer here. The Client gives the Developer permission to use the work product as part of the Developer's portfolio and websites, in galleries, and in other media, so long as it is to showcase the Developer's work and not for any other purpose. The Developer is not allowed to sell or otherwise use the work product to make money or for any other commercial use. The Client is not allowed to take back this license, even after the Contract ends.
2.3 Developer’s Help Securing Ownership. In the future, the Client may need the Developer’s help to show that the Client owns the work product or to complete the transfer. The Developer agrees to help with that. For example, the Developer may have to sign a patent application. The Client will pay any required expenses for this. If the Client can’t find the Developer, the Developer agrees that the Client can act on the Developer’s behalf to accomplish the same thing. The following language gives the Client that right: if the Client can’t find the Developer after spending reasonable effort trying to do so, the Developer hereby irrevocably designates and appoints the Client as the Developer’s agent and attorney-in-fact, which appointment is coupled with an interest, to act for the Developer and on the Developer’s behalf to execute, verify, and file the required documents and to take any other legal action to accomplish the purposes of paragraph 2.1 (Client Owns All Work Product).
2.4 Developer’s IP That Is Not Work Product. During the course of this project, the Developer might use intellectual property that the Developer owns or has licensed from a third party, but that does not qualify as “work product.” This is called “background IP.” Possible examples of background IP are pre-existing code, type fonts, properly-licensed stock photos, and web application tools. The Developer is not giving the Client this background IP. But, as part of the Contract, the Developer is giving the Client a right to use and license (with the right to sublicense) the background IP to develop, market, sell, and support the Client’s products and services. The Client may use this background IP worldwide and free of charge, but it cannot transfer its rights to the background IP (except as allowed in Section 11.1 (Assignment)). The Client cannot sell or license the background IP separately from its products or services. The Developer cannot take back this grant, and this grant does not end when the Contract is over.
2.5 Developer’s Right To Use Client IP. The Developer may need to use the Client’s intellectual property to do its job. For example, if the Client is hiring the Developer to build a website, the Developer may have to use the Client’s logo. The Client agrees to let the Developer use the Client’s intellectual property and other intellectual property that the Client controls to the extent reasonably necessary to do the Developer’s job. Beyond that, the Client is not giving the Developer any intellectual property rights, unless specifically stated otherwise in this Contract.
3. COMPETITIVE ENGAGEMENTS. The Developer won’t work for a competitor of the Client until this Contract ends. To avoid confusion, a competitor is any third party that develops, manufactures, promotes, sells, licenses, distributes, or provides products or services that are substantially similar to the Client’s products or services. A competitor is also a third party that plans to do any of those things. The one exception to this restriction is if the Developer asks for permission beforehand and the Client agrees to it in writing. If the Developer uses employees or subcontractors, the Developer must make sure they follow the obligations in this paragraph, as well.
4. NON-SOLICITATION. Until this Contract ends, the Developer won’t: (a) encourage Client employees or service providers to stop working for the Client; (b) encourage Client customers or clients to stop doing business with the Client; or (c) hire anyone who worked for the Client over the 12-month period before the Contract ended. The one exception is if the Developer puts out a general ad and someone who happened to work for the Client responds. In that case, the Developer may hire that candidate. The Developer promises that it won’t do anything in this paragraph on behalf of itself or a third party.
5.1 Overview. This section contains important promises between the parties.
5.2 Authority To Sign. Each party promises to the other party that it has the authority to enter into this Contract and to perform all of its obligations under this Contract.
5.3 Developer Has Right To Give Client Work Product. The Developer promises that it owns the work product, that the Developer is able to give the work product to the Client, and that no other party will claim that it owns the work product. If the Developer uses employees or subcontractors, the Developer also promises that these employees and subcontractors have signed contracts with the Developer giving the Developer any rights that the employees or subcontractors have related to the Developer’s background IP and work product.
5.4 Developer Will Comply With Laws. The Developer promises that the manner it does this job, its work product, and any background IP it uses comply with applicable U.S. and foreign laws and regulations.
5.5 Work Product Does Not Infringe. The Developer promises that its work product does not and will not infringe on someone else’s intellectual property rights, that the Developer has the right to let the Client use the background IP, and that this Contract does not and will not violate any contract that the Developer has entered into or will enter into with someone else.
5.6 Client Will Review Work. The Client promises to review the work product, to be reasonably available to the Developer if the Developer has questions regarding this project, and to provide timely feedback and decisions.
5.7 Client-Supplied Material Does Not Infringe. If the Client provides the Developer with material to incorporate into the work product, the Client promises that this material does not infringe on someone else’s intellectual property rights.
6. TERM AND TERMINATION. This Contract is ongoing, until ended by the Client or the Developer. Either party may end this Contract for any reason by sending an email or letter to the other party, informing the recipient that the sender is ending the Contract and that the Contract will end in 7 days. The Contract officially ends once that time has passed. The party that is ending the Contract must provide notice by taking the steps explained in Section 11.4. The Developer must immediately stop working as soon as it receives this notice, unless the notice says otherwise. The Client will pay the Developer for the work done up until when the Contract ends and will reimburse the Developer for any agreed-upon, non-cancellable expenses. The following sections don’t end even after the Contract ends: 2 (Ownership and Licenses); 3 (Competitive Engagements); 4 (Non-Solicitation); 5 (Representations); 8 (Confidential Information); 9 (Limitation of Liability); 10 (Indemnity); and 11 (General).
7. INDEPENDENT CONTRACTOR. The Client is hiring the Developer as an independent contractor. The following statements accurately reflect their relationship:
- The Developer will use its own equipment, tools, and material to do the work.- The Client will not control how the job is performed on a day-to-day basis. Rather, the Developer is responsible for determining when, where, and how it will carry out the work.- The Client will not provide the Developer with any training.- The Client and the Developer do not have a partnership or employer-employee relationship.- The Developer cannot enter into contracts, make promises, or act on behalf of the Client.- The Developer is not entitled to the Client’s benefits (e.g., group insurance, retirement benefits, retirement plans, vacation days).- The Developer is responsible for its own taxes.- The Client will not withhold social security and Medicare taxes or make payments for disability insurance, unemployment insurance, or workers compensation for the Developer or any of the Developer’s employees or subcontractors.
8. CONFIDENTIAL INFORMATION.
8.1 Overview. This Contract imposes special restrictions on how the Client and the Developer must handle confidential information. These obligations are explained in this section.
8.2 The Client’s Confidential Information. While working for the Client, the Developer may come across, or be given, Client information that is confidential. This is information like customer lists, business strategies, research & development notes, statistics about a website, and other information that is private. The Developer promises to treat this information as if it is the Developer’s own confidential information. The Developer may use this information to do its job under this Contract, but not for anything else. For example, if the Client lets the Developer use a customer list to send out a newsletter, the Developer cannot use those email addresses for any other purpose. The one exception to this is if the Client gives the Developer written permission to use the information for another purpose, the Developer may use the information for that purpose, as well. When this Contract ends, the Developer must give back or destroy all confidential information, and confirm that it has done so. The Developer promises that it will not share confidential information with a third party, unless the Client gives the Developer written permission first. The Developer must continue to follow these obligations, even after the Contract ends. The Developer’s responsibilities only stop if the Developer can show any of the following: (i) that the information was already public when the Developer came across it; (ii) the information became public after the Developer came across it, but not because of anything the Developer did or didn’t do; (iii) the Developer already knew the information when the Developer came across it and the Developer didn’t have any obligation to keep it secret; (iv) a third party provided the Developer with the information without requiring that the Developer keep it a secret; or (v) the Developer created the information on its own, without using anything belonging to the Client.
8.3 Third-Party Confidential Information. It’s possible the Client and the Developer each have access to confidential information that belongs to third parties. The Client and the Developer each promise that it will not share with the other party confidential information that belongs to third parties, unless it is allowed to do so. If the Client or the Developer is allowed to share confidential information with the other party and does so, the sharing party promises to tell the other party in writing of any special restrictions regarding that information.
9. LIMITATION OF LIABILITY. Neither party is liable for breach-of-contract damages that the breaching party could not reasonably have foreseen when it entered this Contract.
10.1 Overview. This section transfers certain risks between the parties if a third party sues or goes after the Client or the Developer or both. For example, if the Client gets sued for something that the Developer did, then the Developer may promise to come to the Client’s defense or to reimburse the Client for any losses.
10.2 Client Indemnity. In this Contract, the Developer agrees to indemnify the Client (and its affiliates and its and their directors, officers, employees, and agents) from and against all liabilities, losses, damages, and expenses (including reasonable attorneys’ fees) related to a third-party claim or proceeding arising out of: (i) the work the Developer has done under this Contract; (ii) a breach by the Developer of its obligations under this Contract; or (iii) a breach by the Developer of the promises it is making in Section 5 (Representations).
10.3 Developer Indemnity. In this Contract, the Client agrees to indemnify the Developer (and its affiliates and its and their directors, officers, employees, and agents) from and against liabilities, losses, damages, and expenses (including reasonable attorneys’ fees) related to a third-party claim or proceeding arising out of a breach by the Client of its obligations under this Contract.
11.1 Assignment. This Contract applies only to the Client and the Developer. The Developer cannot assign its rights or delegate its obligations under this Contract to a third-party (other than by will or intestate), without first receiving the Client’s written permission. In contrast, the Client may assign its rights and delegate its obligations under this Contract without the Developer’s permission. This is necessary in case, for example, another Client buys out the Client or if the Client decides to sell the work product that results from this Contract.
11.2 Arbitration. As the exclusive means of initiating adversarial proceedings to resolve any dispute arising under this Contract, a party may demand that the dispute be resolved by arbitration administered by the American Arbitration Association in accordance with its commercial arbitration rules.
11.3 Modification; Waiver. To change anything in this Contract, the Client and the Developer must agree to that change in writing and sign a document showing their contract. Neither party can waive its rights under this Contract or release the other party from its obligations under this Contract, unless the waiving party acknowledges it is doing so in writing and signs a document that says so.
(a) Over the course of this Contract, one party may need to send a notice to the other party. For the notice to be valid, it must be in writing and delivered in one of the following ways: personal delivery, email, or certified or registered mail (postage prepaid, return receipt requested). The notice must be delivered to the party’s address listed at the end of this Contract or to another address that the party has provided in writing as an appropriate address to receive notice.
(b) The timing of when a notice is received can be very important. To avoid confusion, a valid notice is considered received as follows: (i) if delivered personally, it is considered received immediately; (ii) if delivered by email, it is considered received upon acknowledgement of receipt; (iii) if delivered by registered or certified mail (postage prepaid, return receipt requested), it is considered received upon receipt as indicated by the date on the signed receipt. If a party refuses to accept notice or if notice cannot be delivered because of a change in address for which no notice was given, then it is considered received when the notice is rejected or unable to be delivered. If the notice is received after 5:00pm on a business day at the location specified in the address for that party, or on a day that is not a business day, then the notice is considered received at 9:00am on the next business day.
11.5 Severability. This section deals with what happens if a portion of the Contract is found to be unenforceable. If that’s the case, the unenforceable portion will be changed to the minimum extent necessary to make it enforceable, unless that change is not permitted by law, in which case the portion will be disregarded. If any portion of the Contract is changed or disregarded because it is unenforceable, the rest of the Contract is still enforceable.
11.6 Signatures. The Client and the Developer must sign this document using Bonsai’s e-signing system. These electronic signatures count as originals for all purposes.
11.7 Governing Law. The laws of the state of California govern the rights and obligations of the Client and the Developer under this Contract, without regard to conflict of law principles of that state.
11.8 Entire Contract. This Contract represents the parties’ final and complete understanding of this job and the subject matter discussed in this Contract. This Contract supersedes all other contracts (both written and oral) between the parties.
All our templates are legally vetted, and can be signed electronically.
Or, download the non-editable PDF version.
1. Follow our step by step editing process to add your own terms to this template
2. Review & sign the contract, then send it out to be electronically signed.
3. Sit back and enjoy the time & money you just saved