Alex is a co-founder of Sprintlaw. Alex previously worked at a top-tier firm as a lawyer specialising in technology and media contracts, and founded a digital agency which he sold in 2015.
Are you about to start a fixed-fee software build and wondering what needs to go into the agreement? The reassuring answer is that it doesn't have to be complicated, but it does need to be specific.
Fixed-price projects can work really well when both sides know what's included, what's not included, and how changes will be handled. The problems usually start when the brief says something broad like "build a booking app" but doesn't spell out the features, acceptance criteria, third-party tools, or who owns the source code at the end.
A good software development agreement in New Zealand gives your project a clear path from kickoff to launch. It also helps you avoid awkward conversations later about extra costs, missed deadlines, or whether the client can take the code to another developer.
Do I Need A Software Development Agreement For A Fixed Fee Build?
Yes, you should use a written software development agreement for a fixed-fee build because the price only makes sense if the scope is clear. If the scope is vague, the developer may end up doing unpaid work, and the client may feel they haven't received what they paid for.
A fixed-fee software contract is different from an hourly or time-and-materials arrangement. In a fixed-fee project, the developer agrees to deliver a defined outcome for a set price. That means the agreement needs to answer questions like:
- What exactly is being built?
- What is excluded from the fixed fee?
- When does each stage need to be delivered?
- How will the client test and accept the work?
- Who is responsible for delays caused by missing feedback, late content, or third-party platforms?
- Who owns the finished product, source code, designs, documentation, and underlying tools?
New Zealand contract law generally gives businesses freedom to agree their own commercial terms. But if your agreement is unclear, you may struggle to prove what was promised. The Fair Trading Act 1986 can also matter if either side makes misleading claims about the software, pricing, capability, delivery timeframes, or ongoing support.
If personal information will be handled as part of the build, the Privacy Act 2020 should also be on your radar. For example, a customer booking app that collects names, contact details, payments, health notes, or location data should be designed with privacy and security in mind from the start.
What Should Be In The Scope?
The scope should describe the product in enough detail that someone outside the project could understand what is included in the fixed price. A one-page idea or a few emails usually isn't enough for a fixed-fee software development contract.
Think of the scope as the commercial deal in plain English. It should cover features, platforms, user roles, integrations, content, design assumptions, technical requirements, and exclusions.
Example: A Fixed-Fee App Build
Say Kauri Kids, a small after-school care provider in Wellington, hires a developer to build a booking app for $28,000 plus GST. The brief says the app will let parents book sessions, pay online, and receive notifications.
That sounds clear at first, but it leaves a lot open. Does "pay online" mean Stripe, Windcave, bank transfer, stored cards, refunds, invoices, or all of the above? Do notifications mean email, SMS, push notifications, or in-app alerts? Does the app include an admin dashboard, parent profiles, child profiles, attendance reporting, and staff permissions?
A stronger scope would say:
- The app will be built for iOS and Android using a named framework.
- Parents can create accounts, add up to 4 child profiles, book available sessions, and pay using Stripe.
- Staff can view daily attendance lists through a web admin dashboard.
- The fixed fee includes 6 screens based on approved wireframes.
- The fixed fee excludes SMS notifications, accounting software integration, custom reporting, and ongoing hosting fees.
- The client must provide logo files, privacy wording, booking rules, and final pricing by a set date.
That level of detail may feel a little more formal, but it saves everyone time. It also makes it much easier to work out whether something is a defect, a change request, or a new feature.
How Should Milestones, Acceptance And Payment Work?
Milestones should be tied to practical deliverables, not just calendar dates. That way, the client can see what they're paying for, and the developer isn't left waiting until the end to be paid.
For a fixed-fee software developer contract in New Zealand, payment is often linked to stages such as discovery, design approval, prototype delivery, beta release, user acceptance testing, and launch. The exact structure depends on the size and risk of the project.
A Simple Milestone Structure
For the $28,000 plus GST Kauri Kids app, the agreement might say:
- Milestone 1: $5,600 on signing, covering kickoff, technical setup, and project planning.
- Milestone 2: $7,000 on approval of wireframes and design direction.
- Milestone 3: $8,400 on delivery of the beta version with core booking and payment features.
- Milestone 4: $4,200 after user acceptance testing of agreed features.
- Milestone 5: $2,800 on launch or handover, whichever happens first if launch is delayed by the client.
Acceptance criteria are just as important as payment milestones. They tell you when a feature is finished. For example, "payment feature complete" might mean a parent can successfully pay for a booking using the agreed payment gateway in the test environment, the booking status updates automatically, and the admin dashboard shows the payment as received.
Your agreement should also set a timeframe for review. For example, the client might have 5 business days to test a milestone and either accept it or give a written list of issues that don't match the agreed scope. If the client doesn't respond, the milestone can be deemed accepted. This helps avoid projects sitting in limbo for weeks.
Who Owns The Source Code And IP?
It depends on what the agreement says, so you should spell out ownership very clearly. Under New Zealand copyright law, software code can be protected by copyright, but ownership and rights to use it can become messy if the contract is silent.
In a fixed-fee app development agreement, there are usually several different types of intellectual property to think about:
- Client materials: logos, brand names, images, content, customer lists, business rules, and confidential information provided by the client.
- Project deliverables: the custom screens, code, configuration, documentation, and designs created for the project.
- Developer background IP: reusable code libraries, templates, tools, frameworks, know-how, and internal processes the developer already had.
- Third-party IP: open-source software, stock assets, APIs, plugins, payment gateways, hosting services, analytics tools, and API agreement requirements.
Clients often assume they will own everything once they pay the final invoice. Developers often assume they can reuse their general tools and code snippets on future projects. Both positions can be reasonable, but they need to be written down.
A common approach is that the client owns the custom project deliverables after full payment, while the developer keeps ownership of background IP and grants the client a licence to use whatever background IP is embedded in the product. The agreement should also say whether the client receives editable source code, build files, credentials, deployment instructions, technical documentation, or source code escrow protections.
If trade marks are involved, remember that registering a company name with the Companies Office or having an NZBN doesn't automatically protect your brand. Trade marks are dealt with through IPONZ, and you may need separate advice if the software name, app logo, or product brand is commercially important.
What Happens If Requirements Change Or The Project Is Delayed?
Your agreement should include a change process because fixed-fee projects almost always change in some way. The key is to separate genuine defects from extra features or changed requirements.
A defect is where the work doesn't meet the agreed scope or acceptance criteria. A change request is where the client wants something different or additional. For example, if the agreed scope says "email notifications" and the client later asks for SMS reminders, that's usually a change request, not a defect.
A Practical Change Request Process
Your agreement can keep this simple. It might say:
- The client sends a written request describing the change.
- The developer confirms the impact on price, timing, and any existing milestones.
- No work starts on the change until both sides approve it in writing.
- The original timeline is extended if the change affects the agreed delivery schedule.
- Urgent fixes, support and maintenance tasks, and agreed variations are recorded in the project management tool or by email.
Delays also need clear rules. Some delays are caused by the developer, such as underestimating a technical task. Others are caused by the client, such as late feedback, missing content, unapproved designs, or delayed access to hosting accounts. Third-party delays can also happen if a payment provider, app store, API, or hosting platform changes its requirements or has an outage.
Your contract should say what happens in each case. For example, if the client misses a feedback deadline by 10 business days, the project timeline may extend by at least 10 business days and the next payment may still fall due if the developer has completed the relevant milestone.
Without this kind of clause, a fixed-price project can quietly turn into unlimited work for the same fee. That's stressful for the developer and usually frustrating for the client too.
What Should I Check Before Signing?
You should check that the agreement matches the commercial deal, the technical plan, and how the project will actually run day to day. Templates can be a helpful starting point, but software builds are rarely one-size-fits-all, especially when fixed pricing is involved.
Before you sign a software development agreement NZ businesses can rely on, work through this checklist:
- Scope: Are the included features, excluded features, platforms, integrations, and assumptions clearly listed?
- Deliverables: Do you know what files, code, credentials, documentation, and designs will be handed over?
- Milestones: Are payments linked to deliverables and sensible acceptance steps?
- Acceptance: Is there a testing process, review period, and rule for deemed acceptance if the client doesn't respond?
- Changes: Is there a written variation process for extra features, design changes, and new integrations?
- IP: Does the agreement separate client materials, custom deliverables, developer background IP, and third-party tools?
- Third-party services: Who pays for hosting, domains, plugins, APIs, app store accounts, licences, SMS credits, and payment processing fees?
- Privacy and data: If personal information is collected, does the project account for the Privacy Act 2020, security responsibilities, access controls, and data handling terms?
- Support: Is there a warranty or bug-fix period, and what happens after that period ends?
- Termination: What happens if the project stops before launch, including payment for completed work and access to work-in-progress?
Fill-In Outline For A Fixed-Fee Software Agreement
A lawyer should tailor your agreement before you use it, but this outline can help you organise the deal before you get advice:
- Parties: Write the legal names, NZBNs if applicable, and contact details of the client and developer.
- Project Description: Summarise what is being built and the business outcome it's meant to support.
- Scope And Exclusions: List included features, excluded features, platforms, integrations, assumptions, and dependencies.
- Milestones And Fees: Set out the fixed fee, GST treatment, payment dates, and deliverables for each milestone.
- Acceptance Testing: Explain how testing works, how long the client has to review, and what counts as acceptance.
- Change Requests: Describe how changes are requested, quoted, approved, and added to the timeline.
- IP And Source Code: State who owns each type of IP and what licences or handover materials are included.
- Third-Party Tools: Identify plugins, APIs, hosting, open-source components, software licence terms, and who is responsible for their costs and terms.
- Privacy And Confidentiality: Cover personal information, security expectations, and confidential business material.
- Support And Maintenance: Clarify what support is included after launch and what requires a separate agreement.
If you're engaging an individual contractor, also check the working relationship carefully. The Employment Relations Act 2000 and the Employment Relations Amendment Act 2026 contractor gateway test can be relevant where the relationship looks more like employment than an independent contracting arrangement. This is usually more of a risk where you control when, where, and how the person works over time, rather than simply buying a defined project outcome.
Key Takeaways
- A fixed-fee software project needs a clear written scope, otherwise the price and deliverables can become hard to enforce.
- Acceptance criteria help separate defects from new feature requests, which is where many project arguments begin.
- IP clauses should deal with custom code, source code handover, developer background tools, third-party software, and client materials.
- Third-party services like hosting, APIs, app stores, plugins, and payment gateways should be listed with cost and responsibility clearly allocated.
- A simple change request process protects both sides when the project naturally evolves.
- Privacy, confidentiality, and contractor status can all matter depending on how the software is built and what data it handles.
If you'd like help with your fixed-fee software agreement, scope and milestone clauses, IP and source code ownership terms, or privacy and contractor risks, you can reach us at 0800 002 184 or team@sprintlaw.co.nz for a free, no-obligations chat.
Protect your brand
What intellectual property should you protect?
If a name, logo, design or other creative work matters to the business, check who owns it, what permissions you need and whether clearance or registration is appropriate.







