Lizzard Solutions

Software Development Contract Checklist: 12 Key Clauses

· Lizzard Solutions
Software DevelopmentContractsCustom SoftwareSmall BusinessChecklist

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).

#ClauseWhat good looks likeRed flag
1Scope and specificationFeatures listed in a SOW or attached specification"Development of the application as agreed"
2DeliverablesSource code, documentation, credentials, deploymentOnly "a working application" is delivered
3Timeline and milestonesDated milestones tied to deliverablesOne final deadline, no checkpoints
4Pricing model and paymentFixed price per milestone or capped hourly rateLarge upfront payment, no link to delivery
5Change requestsWritten change process with price and time impactChanges "billed as needed" with no approval
6Acceptance criteriaTest period, objective criteria, bug severity levelsAcceptance "at the developer's discretion"
7Ownership of code (IP)Rights to custom code pass to you after paymentDeveloper keeps rights, you get a licence only
8Open source and third-party codeList of libraries and licences, no copyleft surprisesNo mention of third-party components
9Warranty and supportFree bug fixes for a set period, then a support plan"Software is delivered as is"
10Confidentiality and data protectionNDA terms and a data processing clause if personal data is involvedNo rules on your customers' data
11Liability and dispute resolutionReasonable liability cap, governing law, court or mediationDeveloper excludes all liability
12Termination and exitNotice period, payment for work done, full handoverNo 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