Contracts · Nov 3, 2026 · 15 min read

Software development contract template that covers life after launch.

The free-fix window, the outside accounts and the open-source code are what a software contract is still deciding a year after launch, and this one puts the client's name on every account, a license beside every library and a monthly price on support.

A software development contract template should set out what gets built and against which written specification, the fee and when each part is paid, how the client tests the work, how a change gets priced and approved, who owns the code, which outside services and open-source parts the app relies on, what gets fixed free after launch and for how long, and how the agreement ends. The parts most versions leave thin are the last few, and they're the ones that last longest, because a custom app keeps running on accounts and code the agency didn't write long after the final invoice is paid. The template below is a complete agreement filled in for Tallgrass Pet Resorts, which runs three dog boarding and daycare locations in Omaha, Nebraska, and commissioned a $48,000 booking app, and you can copy it or download it as a Word file or PDF.

What should a software development contract include?

It has to tie what's being built to a document both sides signed, then answer the questions that only come up once the app exists: who pays for the services it runs on, who owns which code, and who fixes it, at what price, after launch. The specification itself belongs in a schedule or a separate scope, and if you haven't written one yet, the software development scope of work template goes through acceptance criteria and the line between a bug and a new feature in detail. The contract is the agreement that scope sits inside, and it's the document people pull out a year later.

The free versions we read are solid on the build and quiet on what follows it. Bonsai's software development agreement is filled in for a sample $38,000 project, takes a 25% deposit, wants invoices paid within 15 days and offers 30 days of reasonable support after the client accepts the work, but it doesn't say who pays for hosting or any other outside service. PandaDoc's template, last modified on October 30, 2026, leaves the warranty period as a blank, says nothing about open-source code, and lets the developer alone decide whether a requested change adds cost or delay. Index.dev's sample from May 2025 is written for a company hiring developers, splits payment 30/40/30, and lists post-launch support with no length, scope or price.

The version below keeps the usual parts and gives its most room to four sections: section 6, which puts every outside service in the client's name and lists it in Schedule B, section 7, which lists every open-source part with its license, and sections 9 and 10, which say what's fixed free for 60 days after acceptance and what support costs once that window closes.

The software development contract
SOFTWARE DEVELOPMENT AGREEMENT
Between: [your agency], [address], [email] ("the agency")
And: Tallgrass Pet Resorts, which runs three dog boarding and daycare locations in Omaha, Nebraska ("the client")
Approver for the client: Joanna Lindqvist, operations manager, [email]
Signed: Monday, February 1, 2027

1. THE WORK
1.1 The agency designs and builds a web app for booking stays and daycare, taking deposits, collecting vaccination records and checking dogs in at the front desk, as described in Schedule A.
1.2 Schedule A is the specification. Anything it describes is part of the fee in section 2, and anything it doesn't describe is a change under section 5.
1.3 The target launch date is Monday, July 12, 2027, subject to 3.2.

2. FEE AND PAYMENT
2.1 The fixed fee is $48,000 for the work in Schedule A, built from 320 hours at $150 an hour in four stages: discovery and specification, 30 hours, $4,500; design, 50 hours, $7,500; build, 180 hours, $27,000; testing and launch, 60 hours, $9,000.
2.2 The fee is paid in four payments of $12,000: on signing, when the approver accepts the designs, when the build is delivered to the test version under 4.1, and on acceptance under 4.4.
2.3 Invoices are due within 15 days. Changes accepted under section 5 are invoiced with the next payment in 2.2.

3. WHAT THE CLIENT PROVIDES
3.1 The approver answers questions and reviews work within three business days, and provides the sample bookings, price lists and vaccination rules the build needs by the dates in Schedule A.
3.2 If anything in 3.1 arrives late, the launch date moves by the same number of business days.

4. TESTING AND ACCEPTANCE
4.1 The agency delivers the finished build to a test version, with a list of what to test that follows Schedule A line by line.
4.2 The approver has 10 business days to test it and report issues in the shared issue list.
4.3 Within two business days of each report, the agency labels it a defect, meaning the app doesn't do something Schedule A describes, or a change, meaning it asks for something Schedule A doesn't describe. Defects are fixed at no charge. Changes are quoted under section 5.
4.4 The approver accepts the app in writing once every defect reported under 4.2 is fixed. If 10 business days pass with no open defect reported, or the client starts taking real bookings on the app, the app is accepted on that day.

5. CHANGES
5.1 A change is requested in writing. The agency replies within three business days with a quote in hours at $150 an hour and its effect on the launch date.
5.2 Work on a change starts only after the approver accepts the quote in writing.

6. OUTSIDE SERVICES
6.1 Every outside service the app depends on is opened in the client's name and paid by the client directly. Schedule B lists each one, whose name it's in, who pays and what access the agency has.
6.2 The agency works in each account as a user. It doesn't pay any of these bills or add a markup to them.
6.3 A service is added to Schedule B only when the approver accepts it in writing, with its expected monthly cost where one is known.
6.4 An outage or a price change by an outside service isn't a defect under section 9. The agency helps with it at the rate in section 10.

7. OPEN-SOURCE AND OTHER COMPONENTS
7.1 At handover the agency gives the client a list of every open-source library and third-party component in the app, with the license each one is under.
7.2 The agency doesn't use a component whose license would require the client to publish its own code, unless the approver agrees to it in writing first.

8. OWNERSHIP
8.1 Code, designs and documents delivered before each payment in 2.2 belong to the client once that payment is made.
8.2 The code is kept in a repository in the client's account from the first day of the build, and the agency works in it as a user.
8.3 The agency keeps the starter code, scripts and tools it brought to the project or uses on other projects. The client gets a permanent license to use them inside this app at no extra charge.
8.4 The agency can show the app in its portfolio once it's live, unless the client says no in writing.

9. WARRANTY
9.1 For 60 days from acceptance, the agency fixes any defect at no charge, meaning anything the app does differently from Schedule A.
9.2 On a defect that stops customers booking or paying, work starts within one business day of the report. On any other defect, work starts within five business days.
9.3 The warranty doesn't cover changes made by anyone other than the agency, or problems caused by an outside service under 6.4.

10. SUPPORT AFTER THE WARRANTY
10.1 The client can take a support plan at $950 a month for up to six hours of fixes and small changes, with work starting within one business day on a fault of the kind in 9.2. Unused hours don't carry into the next month.
10.2 Without a plan, the agency fixes faults at $150 an hour, quoted in hours before it starts.
10.3 Either side can end the plan with 30 days' written notice.

11. CONFIDENTIALITY AND DATA
11.1 Each side keeps the other's business information confidential, during this agreement and after it ends.
11.2 The client's customer records stay in the client's accounts. The agency uses made-up test records wherever it can, and deletes any copy of real records when the work ends.

12. ENDING THE AGREEMENT
12.1 Either side can end this agreement with 15 business days' written notice.
12.2 The client pays every payment already due under 2.2, plus the hours worked on the stage in progress at $150 an hour, up to that stage's price in 2.1.
12.3 On the end date the agency removes its own access to the repository and to every account in Schedule B, and sends the list in 7.1 and a list of every account with where its login is kept. Up to six hours of handover with whoever takes over are included in the fee.

13. GENERAL
13.1 The agency's total liability under this agreement is limited to the fees paid under it in the 12 months before the claim.
13.2 Changes to this agreement are made in writing and accepted by both sides.
13.3 This template is not legal advice. Have a lawyer in your state review it before you rely on it.

SCHEDULE A: SPECIFICATION
[Attach the signed specification or statement of work, with one numbered line per feature and how each one will be tested.]

SCHEDULE B: OUTSIDE SERVICES
B-1 Cloud hosting: client's account, client pays, agency has developer access.
B-2 Payment processing for deposits: client's account, client pays the processing fees, agency has developer access.
B-3 Confirmation emails: client's account, client pays, agency has developer access.
B-4 Error monitoring: client's account, client pays, agency has team access.
B-5 Code repository: client's account, client pays, agency has developer access.
B-6 Text-message reminders, added Monday, April 19, 2027 by change CO-1: client's account, client pays for usage, agency has developer access.

Signed for the agency: ____________________ Date: __________
Signed for the client: ____________________ Date: __________

Who pays for the outside services a custom app runs on?

The client should, from accounts in the client's own name, because those bills keep arriving every month after the agency has moved on. A booking app like Tallgrass's runs on cloud hosting, a payment processor, a service that sends confirmation emails, an error-monitoring tool and a code repository, and each one is a monthly or per-use charge with somebody's card attached to it. When the agency signs up for them during the build to save time, it ends up holding the client's customer data and paying a bill it has to pass on indefinitely, and a client who later wants a different agency finds out that its own deposits run through somebody else's account.

Schedule B turns that into a table the client signs with the rest of the contract. Each row names the service, whose name the account is in, who pays and what access the agency has, and section 6.3 says a service is added only when the approver accepts it in writing. Tallgrass's register gained a sixth row on Monday, April 19, 2027, when Joanna Lindqvist, the operations manager named as approver, accepted a $3,300 change for text reminders sent the day before each stay. The quote covered 22 hours of the agency's time at $150 an hour, and the text-message service was opened in Tallgrass's own account, so the usage bills from launch onward went straight to Tallgrass instead of turning up as a line on the agency's invoice. The web design contract template answers the same question for the theme, plugins and hosting behind a marketing site.

Who owns the code, and when does it change hands?

The client owns the code once the matching payment is made, and the code lives in a repository in the client's own account from the first day, so ownership never depends on a handover nobody gets around to. Section 8.1 passes everything delivered before each of the four $12,000 payments to the client when that payment lands, which meant Tallgrass owned the specification and the designs after its second payment on Friday, March 19, 2027, with the build still months from finished.

The agency keeps what it brought with it. Most agencies reuse their own starter code, deployment scripts and internal tools from one project to the next, and a contract that hands all of that over with the app either gets quietly ignored or forces the agency to rebuild its toolkit for every client. Section 8.3 gives the client a permanent license to use those parts inside this app at no extra charge, while the agency keeps using them elsewhere, which is the same split the master service agreement template makes for an agency's methods across several projects.

What happens to the open-source code inside the app?

It gets listed with its license in the handover file, because a custom app is usually built on a long list of free libraries the agency didn't write and the client can't see. Many of those licenses ask for little more than keeping a copyright notice, but some ask a business that distributes software built with them to share its own source code on the same terms, and that's a decision the client should make knowingly rather than discover when someone else reads the code.

Section 7.2 has the agency avoid any component whose license would require the client to publish its own code, unless the approver agrees to it in writing first, and 7.1 has the agency hand over the full list with each license named. Producing the list takes an afternoon at the end of a build, since the tools that install those libraries can usually print it, and it's exactly the kind of document a buyer's or an investor's technical reviewer asks for if Tallgrass ever sells the business.

What should happen when the free fixes run out?

The contract should give the date the free-fix window closes, what replaces it and the price, so the first fault after that date becomes a routine invoice instead of an argument about goodwill. In the agreement above, section 9 fixes defects at no charge for 60 days from acceptance, with work starting within one business day on a fault that stops customers booking or paying and within five business days on anything else. Section 10 then offers a support plan at $950 a month for up to six hours, or $150 an hour, quoted first, for a client who'd rather not have one.

Tallgrass accepted the app on Friday, July 9, 2027, went live the following Monday, and found its first real fault on Monday, August 16, when customers who edited a booking were charged the deposit twice. That was a defect against Schedule A inside the window, so it was fixed the next day at no charge. The window closed on Tuesday, September 7, Tallgrass started the support plan the day after, and when the check-in screen stopped loading on the staff tablets on Monday, October 18, the fix used three of that month's six hours and went out on Tuesday morning.

Sixty days is longer than Bonsai's 30 for a reason specific to this client, since a July launch for a boarding business only meets its heaviest weeks around Labor Day, and a warranty that ended in August would have covered the quiet stretch alone. Pick a length that reaches the client's first real peak, and settle on 30 days if the business doesn't have one. If you already sell monthly plans for websites, the structure will look familiar, and the website care plan post shows how to count the hours inside one so it doesn't slowly turn into unlimited support.

How does the contract handle a change in the middle of the build?

It sends every change down one route: a written request, a quote in hours at the contract's rate with its effect on the launch date, and the named approver's written acceptance before any work starts. Section 5 sets that route, and section 4.3 sorts the issues raised during testing with the same rule, so anything Schedule A describes that the app doesn't do is fixed free, and anything Schedule A never describes becomes a quote.

When Joanna tested the build between Friday, June 11 and Friday, June 25, her list held 14 issues. Twelve were defects against Schedule A and were fixed by Thursday, July 1, and two asked for things Schedule A never mentioned, a daily headcount export for the front desk and a check that turns away expired vaccination records. They were quoted at $900 and $1,200, and Joanna parked both until the fall, which kept the launch date where it was. PandaDoc's arrangement, where the developer alone judges whether a change costs anything, is the reason to write the route down rather than trust goodwill on both sides, and the change request form template puts the same route on a single sheet. If those quotes currently live in email threads, Docket for web agencies keeps each one on the project it belongs to, with the date it was accepted.

What happens if the client stops the project halfway?

The client pays the payments already due plus the hours worked on the stage in progress, capped at that stage's price, and gets the code, the register and the open-source list in the handover. Section 12 asks for 15 business days' written notice from either side, which on a build this size is long enough to finish the piece in hand and short enough that nobody feels trapped, and the cap means a client who stops in week two of the build stage never pays more than the $27,000 that stage was priced at.

Because the repository already sits in the client's account under 8.2, the handover is mostly subtraction: the agency removes its own access, sends the list of every account in Schedule B with where each login is kept, sends the open-source list, and spends up to six included hours walking the next developer through the code. The kill fee post covers the different case of a client who cancels before the work begins, when the loss is the calendar the agency held rather than hours already worked.

Schedule B is the page that outlives the build

A year after launch, hardly anyone rereads the specification, and everyone needs to know whose card the hosting is on. The line that decides it is section 6.1: every outside service the app depends on is opened in the client's name, paid by the client directly, and listed in Schedule B with the agency's access beside it, which on Tallgrass's app meant six services in Tallgrass's own accounts and nothing left on the agency's card when the work ended.

Swap the business, the stages and the prices for your own, keep sections 6, 9 and 10 close to this wording, and settle the fixed price or time and materials question before you fill in section 2. The ownership, warranty and liability sections are where a lawyer earns their fee, so have one in your state read them before the first client signs, because the template records what both sides agreed and can't tell you how your state treats any of it.

Frequently asked questions

What is a software development contract template?

A software development contract template is a reusable agreement an agency or developer sends a client before building custom software, covering the specification, the fee and payment stages, testing and acceptance, changes, code ownership, outside services, open-source parts, the warranty, support after launch and how the agreement ends. The version on this page is filled in for a $48,000 booking app.

Is this software development contract template free to use?

Yes, with no sign-up and no email address asked for. The whole agreement is printed on this page, and the buttons under it copy the text or download it as a Word file or a PDF. Replace the business, the stages and the prices with your own, and keep the register of outside services in Schedule B, since it's the part most versions leave out.

What's the difference between a software development agreement and a software development contract?

Nothing, for an agency building software for a client, since both names describe the same document. Some agencies use the agreement as a master contract and attach a statement of work for each project, and the template here works either way, with Schedule A standing in for the statement of work.

Who should own the source code in a software development contract?

The client should own the code written for its project once the matching payment is made, and that code should sit in a repository in the client's own account from the first day. The agency keeps its own reusable starter code and tools and licenses them to the client for use inside the app, which is how section 8 of the agreement above splits it.

How long should the warranty in a software development contract last?

Long enough to reach the client's first busy stretch, because a quiet month tests very little. Bonsai's sample offers 30 days of support after acceptance, and the agreement above uses 60 days so that a July launch is covered past Labor Day weekend, the end of a boarding business's summer rush, with a support plan at a printed monthly price once the window closes.

Do you need a lawyer to use a software development contract template?

For anything that matters, yes, so have a lawyer in your state read it before the first client signs, especially the ownership, warranty and liability sections. The template gives that lawyer a complete draft with real numbers and plain clauses to work from, which tends to make the review quicker than starting from a blank page.