Software Development Agreement Template (US)

Updated on October 2, 2026

A software development agreement governs a project in which one party builds software for another: scope, price, timing, acceptance, ownership and what happens when it goes wrong. It is the most-disputed commercial contract in technology, and almost all of the disputes concentrate in two places — whether the thing delivered is what was ordered, and who owns it.

Before anything else, a naming point. "Development agreement" is ambiguous: in real estate and municipal law it means an agreement between a landowner and a public authority about developing land, which is an entirely different instrument. The Jotform template behind this page is titled "Development Agreement", describes itself as being for "real estate and software development", and is in fact a software contract. We have named this family honestly. If you came here looking for a land development agreement, this is not it.

10 of 33 blanks filled

Tap any highlighted blank in the document below and type straight into it.Free — no sign-up, no watermark

Choose your version

Software Development Agreement

This Software Development Agreement is made on between , a of (the "Developer"), and , a of (the "Client").

This agreement concerns the development of software. It is not a land or real estate development agreement.

1. Scope of work

The Developer will design, develop and deliver the following:

Deliverables and delivery dates: . The detailed scope, technical requirements and acceptance criteria are set out in the specification , which forms part of this agreement. Where this agreement and the specification conflict, this agreement prevails on legal terms and the specification prevails on technical requirements.

2. Change control

Either party may request a change to the scope, the deliverables or the timeline. The Developer will assess the request and provide a written impact statement covering cost and schedule. No change takes effect until both parties have signed it. Verbal instructions do not vary this agreement.

3. Fees and payment

The fee is payable against milestones as follows: . A milestone payment becomes due on acceptance of the deliverable to which it relates. The total budget is .

Expenses and third-party costs: . Invoices are payable within days. Overdue amounts may carry a charge of % per month or the maximum permitted by applicable law, whichever is lower. The Developer may suspend work on written notice if undisputed invoices remain unpaid for more than thirty days.

4. Client responsibilities

. Where the Client does not provide access, information, content, decisions or approvals when needed, the affected dates move by at least the length of the delay and the Developer may charge for time that cannot be redeployed.

5. Delivery and acceptance

On delivery of each deliverable the Client has business days to test it against the acceptance criteria:

  • if the deliverable meets the criteria, the Client will confirm acceptance in writing;
  • if it does not, the Client will give written notice within the test period specifying each failure by reference to the criteria;
  • the Developer will correct the failures and re-deliver within business days, and a fresh test period then runs;
  • if the deliverable still fails after correction cycles, the Client may reject it, terminate this agreement in respect of that deliverable and recover the amounts paid for it;
  • the deliverable is deemed accepted if the Client does not give notice within the test period, or if the Client puts it into production use.

6. Intellectual property

With effect from payment in full for the relevant deliverable, the Developer assigns to the Client, by way of present assignment of present and future rights, all copyright and other intellectual property rights throughout the world in the deliverables created specifically for the Client under this agreement. The Developer will promptly sign any further document and do any further act the Client reasonably requires to vest, perfect or record those rights.

The Developer warrants that it has obtained, from every employee, contractor and subcontractor who contributes to the deliverables, a written assignment of all intellectual property rights in their contributions sufficient to allow the Developer to make the assignment above, and will provide evidence on request.

The Developer retains ownership of its pre-existing tools, libraries, frameworks, methodologies and know-how, and of anything it develops independently of this agreement ("Background Materials"). To the extent any Background Material is incorporated into a deliverable, the Developer grants the Client a perpetual, irrevocable, worldwide, non-exclusive, royalty-free, sublicensable licence to use, modify and distribute it as part of the deliverable for any purpose.

Until payment in full is received for a deliverable, no rights in it pass to the Client and the Client may not use it in production.

7. Open source and third-party components

The Developer will maintain, and deliver with each deliverable, a list of all third-party and open-source components incorporated, with their versions and licences. The Developer will not incorporate any component under a licence that imposes obligations to disclose, license or distribute source code of a larger work without the Client’s prior written consent. The Developer warrants that the components used are licensed on terms compatible with the Client’s use of the deliverables as described in this agreement.

Where the deliverables depend on a third-party service or application programming interface, the Developer will identify it. The Client is responsible for its own contract with that provider, and neither party is responsible for changes the provider makes to its terms, pricing or availability.

OptionalInclude generative AI tool disclosure

8. Generative AI tools

The Developer will disclose in writing any material use of generative artificial intelligence tools in producing the deliverables, including the tools used and the parts of the work affected. Use of such tools does not reduce the Developer’s warranties, and in particular the Developer warrants that the deliverables do not infringe the intellectual property rights of any third party however they were produced.

9. Handover

On acceptance of each deliverable, and in any event on completion or termination, the Developer will deliver: . Delivery is in a form that allows a competent developer to build, deploy and maintain the software without further assistance.

OptionalInclude source code escrowUse where the client depends on software whose source it does not receive.

10. Warranty

The Developer warrants that the deliverables will conform in all material respects to the specification for days after acceptance, and that the services will be performed with the reasonable skill and care of a competent professional developer. During the warranty period the Developer will correct any non-conformity at no charge.

The warranty does not cover defects caused by the Client’s own modifications, by use outside the specification, by third-party software or infrastructure the Developer does not control, or by the Client’s failure to apply a correction the Developer has supplied. Apart from the warranties expressly given, and to the extent permitted by applicable law, no other warranty is given; any disclaimer of implied warranties operates only so far as it is enforceable, and the remaining provisions are unaffected.

11. Intellectual property indemnity

The Developer will defend and indemnify the Client against any third-party claim that the deliverables, as delivered, infringe that third party’s intellectual property rights, and will pay the damages and costs finally awarded or agreed in settlement. The Client will notify the Developer promptly, give the Developer control of the defence and settlement, and co-operate at the Developer’s expense. The Developer will not settle on terms that admit liability on the Client’s part without consent.

If use of a deliverable is or is likely to be enjoined, the Developer will at its option procure the right for the Client to continue using it, modify it so that it is non-infringing while remaining materially conformant, or refund the fees paid for it. This indemnity does not apply to claims arising from the Client’s own materials, from modifications made by anyone other than the Developer, or from combination with anything the Developer did not specify.

12. Confidentiality

Each party will keep the other’s confidential information confidential, use it only for this agreement, protect it with reasonable safeguards, and disclose it only to personnel and advisers who need it and are bound by equivalent obligations. These obligations continue for years after this agreement ends, and for as long as the information remains a trade secret. Disclosure required by law or a court is permitted, with prompt notice where lawful.

13. Data protection and security

  • process personal data belonging to the Client only on the Client’s documented instructions and only as needed for this project;
  • apply appropriate technical and organisational security measures, including access control, encryption in transit and at rest where appropriate, and logging;
  • not use real personal data in development or test environments; test data will be synthetic or anonymised unless the Client authorises otherwise in writing;
  • process and store data only in the following locations: , and not transfer it elsewhere without the Client’s prior written consent;
  • notify the Client of any actual or suspected security incident affecting the Client’s data within hours of becoming aware of it, and co-operate with the Client’s response;
  • return or securely delete the Client’s data on completion or termination, except where retention is required by law.
OptionalRequire a separate data processing agreement
OptionalRequire insurance with stated limits

14. Insurance

The Developer will maintain professional liability insurance of not less than and cyber liability insurance of not less than throughout this agreement and for two years afterwards, and will provide certificates on request.

15. Limitation of liability

Neither party is liable to the other for indirect, incidental, special, punitive or consequential damages, including loss of profit, loss of revenue, loss of anticipated savings, loss of business opportunity or loss of data, however arising.

Subject to the next paragraph, each party’s total aggregate liability arising out of or in connection with this agreement is limited to .

Nothing in this agreement limits or excludes liability for fraud or fraudulent misrepresentation, wilful misconduct, death or personal injury caused by negligence, breach of the confidentiality obligations, infringement of the other party’s intellectual property rights, the Developer’s obligations under the intellectual property indemnity, or any other liability that cannot lawfully be limited or excluded.

OptionalInclude a narrow non-solicitation clause
OptionalInclude support and maintenance after the warranty period

16. Term, termination and transition

This agreement starts on the agreement date and continues until the deliverables have been accepted and paid for, unless terminated earlier. Either party may terminate for convenience on days’ written notice, or immediately if the other materially breaches and fails to remedy the breach within days of written notice, or becomes insolvent.

On termination the Client pays for all work properly performed to the termination date, the Developer delivers all completed and partially completed work together with the handover items for anything paid for, and the Developer provides reasonable transition assistance for up to thirty days at its standard rates. The clauses on intellectual property, confidentiality, data protection, indemnity, limitation of liability and governing law survive.

17. General

  • Independent contractor: the Developer is an independent contractor and nothing creates a partnership, joint venture, agency or employment relationship.
  • Force majeure: neither party is liable for delay caused by events beyond its reasonable control, with prompt notice and reasonable efforts to resume.
  • Amendment: only by a written document signed by both parties.
  • Assignment: neither party may assign without the other’s written consent, except to a successor in a merger or sale of substantially all assets that assumes these obligations.
  • Entire agreement: this agreement, the specification and any signed change orders are the whole agreement on their subject matter.
  • Severability: if any provision is invalid or unenforceable the rest continues, and the provision is read down to the minimum extent needed to make it enforceable.
  • Counterparts and electronic signature: this agreement may be signed in counterparts and electronically.

18. Governing law and disputes

This agreement is governed by the laws of the State of . The parties will first attempt to resolve any dispute by discussion between senior representatives, and failing that will submit it to the courts or forum at .

Developer

Date signed:

Client

Date signed:

"The client shall own the deliverables" does not transfer anything

The source document says that on full payment the client "shall own all rights, title and interest in the final deliverables". That sentence is a statement of intention, not a conveyance, and it sits on top of two US copyright rules that work against it.

First, work made for hire. A work is a work made for hire if it is prepared by an employee within the scope of their employment, or if it is specially ordered or commissioned for use as one of nine listed categories and the parties expressly agree in a signed written instrument that it shall be considered a work made for hire. Software is not one of the nine categories. So commissioning a developer to write code does not, by itself, make the client the author.

Second, the writing requirement. A transfer of copyright ownership is not valid unless an instrument of conveyance, or a note or memorandum of the transfer, is in writing and signed by the owner of the rights conveyed. "Shall own" in a contract the developer signed is arguably enough to satisfy that, but it is an argument you do not want to be having. An express present assignment, with a further-assurances obligation and an obligation on the developer to secure the same assignment from its own employees and subcontractors, removes the question.

This template therefore uses an express assignment taking effect on payment in full, backed by a licence-back of the developer’s background materials so the client can actually use what it has bought, and a requirement that every individual who contributes code has assigned their rights to the developer first. That last point is the one that kills acquisitions: a startup discovers at diligence that a contractor who wrote a core module three years ago never signed anything.

Acceptance testing: the clause the source does not have

The source warrants that deliverables "will substantially conform to the agreed specifications for a period of ____ days following delivery" — and then provides no mechanism for establishing whether they conform. There is no test procedure, no acceptance criteria, no period for the client to test, no consequence of silence and no re-delivery process. Every significant software dispute runs through that gap.

This template adds the standard structure: the developer delivers, the client has a stated number of business days to test against the agreed acceptance criteria, the client either accepts or gives written notice of the specific failures, the developer has a stated period to correct and re-deliver, and the cycle repeats a limited number of times before the client can reject the deliverable and recover payments for it. Deemed acceptance applies if the client says nothing within the test period, and — importantly — if the client puts the deliverable into production use.

Write the acceptance criteria into the specification, not into the lawyer’s clause. "Conforms to the specification" is only as good as the specification.

Open source, third-party components and the licence you did not read

Virtually all modern software incorporates open-source components, and some of those licences impose conditions — notice and attribution, and in the case of copyleft licences, obligations that can extend to distributing source code for derivative works. A client who intends to license the software commercially needs to know what is in it.

The source document says nothing at all about this. The template requires the developer to maintain and deliver a list of third-party and open-source components with their licences, to obtain the client’s prior written consent before incorporating anything under a copyleft licence, and to warrant that the components used are licensed in a way compatible with the client’s intended use as described in the agreement. It also covers third-party services and APIs the software depends on, whose terms and pricing are outside both parties’ control.

Data protection and security belong in the contract

A developer building and testing a system almost always touches the client’s data, and frequently real personal data because test environments get seeded from production. The source agreement has a confidentiality clause and nothing else — no data protection terms, no security requirements, no breach notification.

This template adds a proportionate set: the developer processes personal data only on the client’s documented instructions and only for the project, applies agreed security measures, keeps personnel under confidentiality obligations, does not transfer data outside the agreed locations without consent, uses anonymised or synthetic test data unless the client authorises otherwise in writing, notifies the client of any security incident within a stated number of hours, and returns or deletes the data at the end. Where the client is subject to a specific regime — state consumer privacy statutes, sectoral healthcare or financial rules — the template points to a separate data processing agreement rather than pretending a paragraph covers it.

A liability cap that survives contact with a court

The source caps the developer’s total liability at the fees paid, carves out fraud, wilful misconduct and breach of confidentiality, and excludes all implied warranties. Two problems. The carve-out list omits death and personal injury and anything else that cannot lawfully be excluded, which in several jurisdictions puts the whole clause at risk rather than just the offending part. And a blanket exclusion of implied warranties is unenforceable against a consumer and, in business contracts, subject to conspicuousness requirements under the Uniform Commercial Code for transactions in goods, which software deals sometimes are.

The template keeps a cap — commonly the fees paid in the preceding twelve months, or a multiple of the contract value for larger projects — and writes the carve-outs properly: fraud, wilful misconduct, death or personal injury caused by negligence, breach of confidentiality, infringement of the other party’s intellectual property, the IP indemnity, and any liability that cannot lawfully be limited. It also makes the exclusion of consequential loss mutual, which is both fairer and more likely to hold.

The IP indemnity, and who defends the claim

If the software the developer delivers infringes someone else’s patent or copyright, the person who gets sued is usually the client who is using it. An IP indemnity is therefore a core term of any development agreement, and the source has none at all.

This template includes a developer indemnity for third-party IP claims arising from the deliverables, with the usual mechanics: prompt notice, control of the defence, co-operation, no settlement that admits liability without consent, and a remedy ladder if an injunction looks likely — procure the right to continue, modify to avoid infringement, or refund. It excludes claims arising from the client’s own materials, from modifications the client made, and from combinations the developer did not specify.

What happens afterwards

Projects end and software keeps running. The source agreement stops at delivery. The template adds the handover terms that determine whether the client can actually operate what it has bought: delivery of source code and build instructions in a usable form, repository and environment access, credentials, documentation, a defined warranty period with bug fixes at no charge, and an optional support and maintenance arrangement with response targets.

It also adds an optional source-code escrow clause for the case where the client depends on the software but does not receive the source, and a disclosure obligation about generative AI tools used in producing the code — now a standard diligence question, and one worth answering in the contract rather than at an acquisition.

Software development agreement clause guide

Parties and engagement
Legal entities, states of formation, and the independent contractor relationship.
Statement of work and specification
The scope, the deliverables, the technical requirements and the acceptance criteria — attached as a schedule rather than summarised in a clause.
Change control
Written change requests, an impact assessment covering cost and schedule, and no change binding until both sides sign.
Fees, milestones and expenses
Fixed price, time and materials or milestone-based, with what is included and how expenses and third-party costs are handled.
Client responsibilities and dependencies
Access, data, decisions and approvals, with the consequence of delay stated.
Delivery and acceptance testing
Test period, acceptance criteria, written notice of failures, correction and re-delivery, a limited number of cycles, deemed acceptance on silence or production use.
Intellectual property — express assignment
A present assignment of the deliverables on payment in full, further assurances, and assignments secured from employees and subcontractors.
Background IP and licence back
The developer keeps its pre-existing tools and frameworks and licenses them to the client as needed to use the deliverables.
Open source and third-party components
A delivered component list with licences, consent required for copyleft components, and a compatibility warranty.
Source code, documentation and handover
What is delivered, in what form, with build instructions, environment details and credentials.
Source code escrow
Optional. Where the client depends on software whose source it does not receive.
Warranty and warranty period
Conformance to specification for a stated period, with correction at no charge, and the exclusions that properly belong there.
IP indemnity
Developer indemnity for third-party IP claims with defence control, co-operation and a remedy ladder. Absent from the source.
Confidentiality
Mutual, with a defined period, defined carve-outs and personnel bound on equivalent terms.
Data protection and security
Processing only on instructions, agreed security measures, no real personal data in test environments without consent, incident notification within a fixed period, and return or deletion at the end.
Insurance
Professional liability, cyber and general liability with stated limits, where the project warrants it.
Limitation of liability
A cap with properly drafted carve-outs including anything that cannot lawfully be limited, and a mutual exclusion of consequential loss.
Non-solicitation
Optional and narrow — people who worked on the project, for a short period, solicitation rather than a blanket no-hire.
AI tool disclosure
Whether generative AI tools were used in producing the code, and the warranties that attach.
Support and maintenance
Optional. Response targets, fees and what is in scope after the warranty period ends.
Term, termination and transition
Notice, cure, payment for work done, delivery of work in progress, and reasonable transition assistance.

US software development agreement checklist

The copyright points below are federal and decisive; the rest is commercial risk allocation that costs nothing to get right at the start and a great deal to fix later.

  • Do not rely on work-made-for-hire for software

    A specially commissioned work is a work made for hire only if it falls within one of nine listed categories and the parties expressly agree in a signed written instrument. Software is not among the nine. Use an express assignment instead.

    17 U.S.C. § 101 (definition of “work made for hire”)
  • Put the assignment in writing and sign it

    A transfer of copyright ownership is not valid unless an instrument of conveyance, or a note or memorandum of the transfer, is in writing and signed by the owner of the rights conveyed.

    17 U.S.C. § 204(a) (execution of transfers)
  • Secure assignments from everyone who writes code

    The developer’s assignment to the client is worth nothing if the developer never obtained rights from the individual contractor who wrote the module. Require the developer to warrant that it holds assignments from all contributors.

  • Build a real acceptance procedure, not a bare warranty

    Test period, written notice of specific failures, correction and re-delivery, a limited number of cycles, and deemed acceptance on silence or production use. Attach acceptance criteria to the specification.

  • Require an open-source component list before go-live

    Copyleft licences can impose obligations on how the software is distributed. Require a delivered component list with licences and prior consent for anything copyleft, and check it against the client’s intended commercial use.

  • Keep real personal data out of test environments

    Seeding test environments from production is routine and is one of the commonest causes of avoidable breaches. Require anonymised or synthetic data unless the client authorises otherwise in writing.

  • Use a separate data processing agreement where a regime applies

    State consumer privacy statutes and sectoral healthcare and financial rules impose specific contractual terms. A paragraph in a development agreement is not a substitute for the required agreement.

  • Draft the liability carve-outs properly

    Include death or personal injury caused by negligence, fraud, wilful misconduct, breach of confidentiality, IP infringement and anything that cannot lawfully be limited. An incomplete carve-out list can put the whole cap at risk rather than just the offending part.

  • Check conspicuousness if you exclude implied warranties

    Where a transaction is treated as a sale of goods, disclaimers of implied warranties such as merchantability are subject to conspicuousness and wording requirements under the Uniform Commercial Code as adopted in the relevant state.

    UCC § 2-316 (exclusion or modification of warranties)
  • Ask about generative AI use in the code

    Record whether AI coding tools were used, require the developer to warrant that the deliverables do not infringe third-party rights regardless, and treat the answer as diligence material rather than a curiosity.

How to complete the software development agreement

  1. Write the specification before the contract. Scope, deliverables, technical requirements and acceptance criteria belong in a schedule you attach. Everything else in the agreement refers back to it.
  2. Choose the pricing model. Fixed price, time and materials, or milestone-based. Enter the figures, the milestone triggers and what expenses and third-party costs are additional.
  3. Set the acceptance mechanics. The test period in business days, the correction period, the number of correction cycles before rejection, and what counts as deemed acceptance.
  4. Set the IP position and the component rules. Assignment on payment in full is the default. Decide whether copyleft components are permitted at all, and require a component list at delivery.
  5. Complete the data and security terms. Processing locations, the incident notification deadline, and whether a separate data processing agreement is needed for the client’s regime.
  6. Set the cap and turn on the optional clauses. Enter the liability cap, then switch on escrow, support and maintenance, insurance and non-solicitation if the project warrants them.
  7. Deal with handover before you sign. Agree what is delivered at the end — source code, build instructions, repository access, credentials, documentation — so it is a contractual obligation rather than a favour.

Software development agreement — frequently asked questions

Is this the same as a real estate development agreement?

No, and the confusion is the reason this family is named as it is. A land or real estate development agreement is made between a landowner and a public authority about developing a site. This document is for software: one party builds a system for another. The widely copied free template describes itself as covering both, which is not possible — the two have nothing in common beyond the word.

Who owns the code if the contract says nothing?

Generally the developer, which surprises most clients. The author of a work owns the copyright unless it was created by an employee within the scope of employment, or it is one of the nine categories of specially commissioned works covered by a signed work-made-for-hire agreement — and software is not among those nine. Paying for code does not transfer the copyright in it. You need an express written assignment.

Is a clause saying the client "shall own" the deliverables enough?

It is weaker than it should be. A transfer of copyright ownership must be in writing and signed by the owner of the rights, and a present-tense assignment with further-assurances wording leaves no room for argument. The free template this page replaces uses the "shall own" formulation and provides no assignment, no further assurances and no obligation on the developer to obtain rights from its own contributors.

What should acceptance testing look like?

The client gets a defined number of business days to test the delivered item against acceptance criteria that form part of the specification. It then either accepts in writing or gives written notice of the specific failures. The developer corrects and re-delivers within a defined period, and the cycle repeats a limited number of times before the client may reject and recover what it paid for that deliverable. Silence for the test period, or putting the item into production use, counts as acceptance.

Why does open source matter in a development contract?

Because some open-source licences impose conditions on how the resulting software can be distributed, and a client planning to license the product commercially needs to know what obligations came in with the components. Require a delivered list of third-party and open-source components with their licences, and require the developer to get consent before incorporating anything copyleft.

Do I need a separate data processing agreement?

If the developer will handle personal data on your behalf and you are subject to a state consumer privacy statute or a sectoral regime, almost certainly yes — those regimes prescribe contractual terms that a general confidentiality clause does not meet. The development agreement should contain proportionate security and incident terms and point at the separate agreement rather than trying to do its job.

What liability cap is reasonable?

Fees paid in the preceding twelve months is the common default for a services engagement; a multiple of the contract value is more usual on large fixed-price builds. The figure matters less than the carve-outs. Make sure the cap does not purport to limit liability for fraud, wilful misconduct, death or personal injury caused by negligence, breach of confidentiality, IP infringement or the IP indemnity — an incomplete carve-out list can take the whole clause down with it.

Should I ask whether AI tools were used to write the code?

Yes, and record the answer. It is now a standard diligence question on acquisitions and investments. The practical protection is not to ban the tools but to require the developer to warrant that the deliverables do not infringe third-party rights however they were produced, to maintain the component list, and to disclose material use of generative tooling.

Related templates

Disclaimer

This template and guide are general information only, not legal, tax, insurance, employment, consumer-credit, construction, dental or intellectual-property advice. No attorney has reviewed your facts, and nothing here is certified as compliant with any law. Federal, state and local rules differ and change — check the current rules for your situation, and take professional advice before you sign or send.