Software Development Contract Checklist: 12 Key Clauses
By Nemanja Vukmirović, Lizzard Solutions. Last updated 16 November 2026.
Most software disputes between a small business and a development company are not about bad code. They are about a contract that never said who owns the code, what "done" means, or what happens when the project stops.
This software development contract checklist covers the 12 clauses to check before you sign, with what a good clause looks like, the red flags to reject and a worked example of an acceptance clause. Use it whether you hire a freelancer, a local agency or an outsourcing partner.
TL;DR
- A software development contract should define scope, acceptance, payment, code ownership, warranty, data protection and exit terms in writing.
- The most expensive gaps are unclear ownership of the source code and no objective definition of when work is accepted.
- Read the contract with this 12-clause checklist, mark each clause green, yellow or red, and negotiate every red one before signing.
What is a software development contract?
A software development contract is a written agreement between a client and a developer or agency that defines what software will be built, how and when it will be delivered and accepted, how much it costs, who owns the result, and what happens if something goes wrong or either side wants to end the cooperation.
It is usually a main agreement plus a statement of work (SOW) or specification for each project. The main agreement holds the legal terms, and the SOW holds the features, deadlines and price. If you have not written the specification yet, start with our software project brief template, because a contract can only protect what is clearly described.
Action for today: ask your developer whether the offer is one document or a main agreement plus a SOW, and get both.
The software development contract checklist: 12 clauses
Go through the table with the draft contract open. For each row, write green (clear and fair), yellow (unclear) or red (missing or one-sided).
| # | Clause | What good looks like | Red flag |
|---|---|---|---|
| 1 | Scope and specification | Features listed in a SOW or attached specification | "Development of the application as agreed" |
| 2 | Deliverables | Source code, documentation, credentials, deployment | Only "a working application" is delivered |
| 3 | Timeline and milestones | Dated milestones tied to deliverables | One final deadline, no checkpoints |
| 4 | Pricing model and payment | Fixed price per milestone or capped hourly rate | Large upfront payment, no link to delivery |
| 5 | Change requests | Written change process with price and time impact | Changes "billed as needed" with no approval |
| 6 | Acceptance criteria | Test period, objective criteria, bug severity levels | Acceptance "at the developer's discretion" |
| 7 | Ownership of code (IP) | Rights to custom code pass to you after payment | Developer keeps rights, you get a licence only |
| 8 | Open source and third-party code | List of libraries and licences, no copyleft surprises | No mention of third-party components |
| 9 | Warranty and support | Free bug fixes for a set period, then a support plan | "Software is delivered as is" |
| 10 | Confidentiality and data protection | NDA terms and a data processing clause if personal data is involved | No rules on your customers' data |
| 11 | Liability and dispute resolution | Reasonable liability cap, governing law, court or mediation | Developer excludes all liability |
| 12 | Termination and exit | Notice period, payment for work done, full handover | No exit, or code withheld until extra payment |
Key takeaway
Clauses 6, 7 and 12 cause the most painful disputes. If you only have time to negotiate three things, negotiate acceptance, ownership and exit.
Action for today: copy the table into a document and score your current or next contract.
Scope, timeline and payment: clauses 1 to 5
Scope is where most cost overruns start. A contract that says "a booking app like the one we discussed" lets both sides remember different things. Attach the specification and say it is part of the contract.
- Milestones: split the project into stages, each with a deliverable you can see, such as clickable design, first working version and launch.
- Payment: tie each payment to an accepted milestone, not to calendar dates alone.
- Changes: require a short written change request with the extra cost and new deadline before any new work starts.
Which pricing model fits depends on how stable your scope is. Our guide to fixed price vs time and materials contracts explains the trade-off, and what drives custom software cost helps you judge whether the quote is realistic.
Action for today: check that every payment in your contract is linked to a named deliverable.
Acceptance criteria: how to define "done"
Acceptance is the moment you confirm the work meets the agreement, and usually the moment the next payment is due. Without criteria, it becomes an argument.
Worked example: an acceptance clause
This is example wording for illustration, not legal text for your project.
Example clause
After each milestone delivery, the Client has 10 working days to test the software against the specification in Annex 1. Critical bugs (the feature cannot be used) and major bugs (the feature works incorrectly) must be fixed before acceptance. Minor bugs (cosmetic issues) are listed and fixed within the warranty period. If the Client reports no critical or major bugs within 10 working days, the milestone is accepted.
This wording gives you a fixed test window, separates serious bugs from cosmetic ones and stops a project from being blocked forever by small issues. Both sides know exactly when payment is due.
Action for today: make sure your contract names a test period and at least two bug severity levels.
Who owns the code? Clauses 7 and 8
Many owners assume that paying for software means owning it. That is not automatic. Who holds the rights in commissioned code depends largely on what the contract says, so it should state the transfer explicitly. In Serbia, the Law on Copyright and Related Rights governs how rights in software are transferred, and other countries have their own rules.
- The contract should say that rights to the custom code written for you pass to you, usually once you have paid.
- The developer may keep rights to their own reusable tools, but you should get a permanent licence to use them in your product.
- Ask for a list of open-source libraries and their licences. Most are permissive, but some copyleft licences can require you to publish your own code if you distribute the software. The Open Source Initiative licence list explains the main types.
Ownership on paper is not enough. You also need the actual code repository, hosting accounts and admin passwords. Our website handover checklist lists what to collect.
Not legal advice
This checklist explains common contract terms. It is not legal advice. For a large project, or if the contract is governed by another country's law, have a lawyer review it before you sign.
Action for today: find the sentence in your contract that transfers code ownership. If you cannot find it, ask for one.
Warranty, data and exit: clauses 9 to 12
These clauses decide how the relationship ends, which is exactly when you need them most.
- Warranty: a set period after launch during which bugs against the specification are fixed free of charge, followed by an optional maintenance plan with response times.
- Data protection: if the developer will access personal data of your customers or staff, add data processing terms. Under the EU GDPR, Article 28 lists what a processor contract must contain, and Serbia's data protection law has similar rules.
- Liability: a cap, often linked to the contract value, is normal. Excluding all liability is not.
- Exit: either side can end the contract with notice, you pay for accepted work, and the developer hands over code, documentation and access within a set number of days.
Unclear exit terms are also how projects collect technical debt: the next team inherits code nobody documented.
Action for today: check that your contract has a handover obligation that applies even if the cooperation ends early.
Frequently asked questions
What should a software development contract include?
At minimum: scope and specification, deliverables, milestones, pricing and payment terms, a change request process, acceptance criteria, ownership of the code, open-source rules, warranty, confidentiality and data protection, liability limits, and termination with a full handover. Missing any of these leaves room for costly disagreement later.
Who owns the source code, the client or the developer?
It depends on the contract and the applicable law. Do not rely on assumptions. The safest approach is a clause that transfers rights to the custom code to you after payment, plus a permanent licence for any reusable components the developer keeps.
Is a statement of work the same as a contract?
No. The main contract holds the legal terms that apply to the whole cooperation. A statement of work describes one specific project: features, deliverables, timeline and price. Many companies sign one main agreement and then add a new SOW for each project or phase.
How long should a software warranty period be?
There is no single standard. It is a negotiated term, often measured in months after launch. What matters more is that the contract defines what the warranty covers, such as bugs against the specification, and how fast critical issues will be fixed.
Planning a software project?
Tell us what you want to build. We will send a clear proposal with milestones, acceptance criteria and full code ownership for you.
Request a free consultation