Freelance Developer Contract Template: Clauses and Plain English
By Mark Fulton · · 11 min read
Last verified:

A freelance developer contract needs twelve things: who the parties are, what you are building, what you are not building, how and when you get paid, how changes are priced, who owns the code and when, what you warrant and for how long, what stays confidential, how either side leaves, your status as a contractor, a cap on your liability, and signatures. Most of it fits on two or three pages in plain English. The skeleton below is written from the developer's side, one numbered section at a time, with a link to the deeper post on every section that has one.
This is general information, not legal advice. Contract law varies by state and country, so have a lawyer review the final version once, then reuse it.
What does a developer contract need beyond a handshake?
A handshake covers the happy path. A contract covers the three conversations you have not had yet: the client wants something you did not quote, the client is slow to pay, or the project stops halfway.
Almost every dispute a freelance developer ends up in is one of those three. The scope was vague, the payment trigger was vague, or nobody wrote down what happens on exit. The contract is where you make each of those boring in advance.
It also has a second job that people forget. If you are a US contractor, the IRS looks at the whole relationship to decide whether a worker is an independent contractor or an employee. Its guidance groups the evidence into behavioral control, financial control and the type of relationship, and lists written contracts as one of the facts in that last group. The IRS also says no single factor decides it and there is no magic number of factors. A contract does not settle your status by itself, but one that says you choose your methods, your hours and your tools is consistent with how you actually work, and that is the point.
Should you use the client's contract or yours?
Start from yours. The party who writes the first draft sets what "normal" looks like, and every change after that is a negotiation against your wording instead of theirs.
Larger clients will often insist on their own paper. That is fine. Read it against the twelve sections below and mark the ones it is missing or has turned around: usually payment terms that run longer than you quoted, IP that transfers on signing instead of on payment, unlimited revisions hidden inside "acceptance", and indemnity with no cap. You do not have to win all of them. You do have to know which ones you lost.
Many developers split the paperwork into two documents. A short master agreement carries the legal terms and stays the same for every project. A statement of work carries scope, price and dates and changes every time. If you do repeat work for one client, that split saves you from renegotiating the legal sections each time, and the statement of work guide shows a full example.
What are the 12 sections of a freelance developer contract?
Copy this structure. Each section is two or three plain sentences. Where a deeper post exists, the link goes to it.
- Parties and effective date. Legal names, addresses, the date. If you work through an LLC, use the LLC's name and sign as an officer.
- Scope and deliverables. A numbered list of what will exist at the end, plus a numbered list of what will not. Covered in how to write a statement of work.
- Timeline and client dependencies. Dates, and what the client must supply (content, credentials, feedback) for those dates to hold.
- Fees and payment terms. Amounts, triggers, due date, late fee. Covered in freelance contract payment terms.
- Changes to scope. How extra work is requested, priced and approved before you start it. Covered in scope creep and change orders.
- Ownership and licence. When the code transfers, and which of your pre-existing tools stay yours. Covered in who owns code written by a freelancer.
- Warranty. How long you fix defects for free, and what is not a defect. Covered in web development warranty periods.
- Confidentiality. What each side keeps private, and for how long.
- Termination and kill fee. How either side ends the work and what the client owes. Covered in kill fees for freelance developers.
- Independent contractor status. You control your methods, schedule and tools. No benefits, no tax withholding.
- Limitation of liability. Your total liability is capped, usually at the fees paid under the contract. No consequential damages.
- General terms and signatures. Governing law, entire agreement, amendments in writing, both signatures, both dates.
The next sections go through the ones that decide who wins a dispute, with wording you can adapt.
How do you write scope and deliverables?
Scope is the section that does the most work and gets the least attention. The test is simple: could a stranger tick each deliverable off without asking either of you a question? "Build the website" fails. "Five templated pages (home, pricing, about, blog index, contact) built in Next.js, deployed to the client's Vercel account" passes.
Pair it with an exclusions list. Anything you are not doing goes there in writing, because the first change request nearly always lands on something both sides assumed was covered somewhere else.
2. Scope. Developer will deliver the items listed in Schedule A ("Deliverables"). Anything not listed in Schedule A is outside this Agreement. Client will provide content, credentials and written feedback within 3 business days of a request. If Client is late, the dates in Schedule A move by the same number of days.
2.1 Acceptance. Client will review each Deliverable within 5 business days. If Client does not respond in that time, the Deliverable is accepted. Two rounds of revisions per Deliverable are included. Further rounds are billed under Section 5.
The silent-acceptance sentence is the one clients push back on and the one that saves you from a project that never finishes because nobody replies. If they will not accept it, a shorter window still beats none.
If you cannot fill in Schedule A because you cannot estimate the work yet, quote a paid discovery phase first and write the contract for the build afterwards. The paid discovery post covers how.
Which payment clauses protect you?
Four sentences cover most of it: when invoices go out, when they are due, what happens if they are late, and what you may do about it.
4. Fees. Client will pay the fees in Schedule A. Developer will invoice 33% on signing, 33% on delivery of the staging build, and 34% on production launch. Invoices are due within 15 days of the invoice date.
4.1 Late payment. Overdue amounts accrue a late fee of 1.5% per month, or the maximum allowed by law if lower. Developer may pause work while any invoice is more than 7 days overdue, and delivery dates move accordingly.
Two choices here carry most of the weight. First, tie the right to use the work to payment, which is the ownership clause below. Second, state the due date as a number of days from the invoice date, not from "approval", because approval is a date only the client controls. The trade-offs between short and long terms are in net 15 versus net 30, deposits are in how much deposit to charge, and splitting the payments is in milestone billing for developers.
Late-fee percentages vary in what local rules will enforce, so treat 1.5% as a placeholder to check with whoever reviews your contract.
Changes belong in the same family of clauses. A change order clause only works if it says the work does not start until the client approves the price in writing:
5. Changes. Either party may request a change to the Deliverables. Developer will reply with the effect on price and dates. No changed work begins until Client approves the change in writing, and email counts as writing.
How should IP, warranty and confidentiality read?
These three sections are where a client's lawyer will spend their time, so they are where a short, clear draft helps most.
Ownership. The most developer-friendly structure transfers the code on final payment, not on signing, and carves out your own pre-existing tools. In the US, a copyright transfer is not valid unless it is in writing and signed by the owner of the rights, as 17 U.S.C. section 204 on Copyright.gov puts it, so an assignment clause with a signature is not a formality. It is the mechanism.
6. Ownership. On Client's payment in full, Developer assigns to Client all rights in the Deliverables created specifically for Client under this Agreement. Developer keeps ownership of Developer's pre-existing code, libraries and tools ("Developer Tools") and grants Client a perpetual, non-exclusive licence to use them as part of the Deliverables. Until payment in full, Client has a limited licence to use the Deliverables only for testing and review.
The longer reasoning, including why "work for hire" rarely does what clients assume for freelance code, is in who owns code written by a freelancer.
Warranty. A warranty without an end date is a retainer you are not being paid for. Fix a length, define what counts, and say what happens after it.
7. Warranty. For 30 days after launch, Developer will fix defects that cause the Deliverables to differ from Schedule A, at no charge. Warranty does not cover new features, changes to third-party services, hosting or content changes, or modifications made by anyone other than Developer. Work after the warranty period is billed at Developer's hourly rate.
Thirty days is a placeholder. The post on warranty periods covers how to pick a length and how to tell a bug from a change request.
Confidentiality. Keep it mutual and time-limited. Each side protects the other's non-public information for a fixed period after the contract ends, excluding anything already public or already known to the receiving side. Add a sentence saying you may describe the work you did in general terms in your portfolio, unless the client asks in writing to keep it private. Without that sentence, a strict reading can stop you from showing any of it.
How does the contract end, and what does the client owe then?
Contracts get ended more often than they get finished. Write down both exits: the clean one (the project is done) and the abrupt one (somebody stops).
9. Termination. Either party may end this Agreement with 14 days' written notice. If Client ends it for any reason other than Developer's uncured material breach, Client pays for all work completed to the termination date, plus a cancellation fee of 25% of the unpaid balance of the project fee. Developer delivers work completed to that date on receipt of payment.
The cancellation fee compensates you for the calendar space you held and the other work you turned away to protect it. The 25% above is an illustration, not a standard. How to size the percentage for your project and how to invoice it afterwards are in kill fees for freelance developers.
Two more sentences belong in the closing sections.
11. Limit of liability. Developer's total liability under this Agreement is limited to the fees Client has paid in the 12 months before the claim. Developer is not liable for lost profits, lost data or indirect or consequential damages.
12. General. This Agreement is the entire agreement between the parties. Changes must be in writing and signed by both parties. This Agreement is governed by the laws of [State or Country].
The liability cap is the sentence that stops one bad bug on a $5,000 project from becoming a six-figure claim. Some clients will push for a higher cap or insurance requirements. That is a negotiation, and a number you should agree on purpose instead of by accident.
What happens after you sign?
The contract sets the terms. The invoice is how you enforce them. Reference the contract section in each invoice, name the milestone in the line item, and put the due date and late-fee wording on the invoice itself. Billable's free invoice generator does this in the browser with no account, and the invoice line items guide shows wording that survives a finance team's review.
Keep one signed PDF per project, store the email where the client said yes, and put the effective date in your calendar next to the warranty end date.
FAQ
Do I need a lawyer to review my contract?
You should have one lawyer in your jurisdiction review your master template once, especially the ownership, liability and governing law sections. After that, you are reusing reviewed text and only changing the scope, price and dates. A template you found online is a starting structure, not a reviewed document.
Is an email thread a contract?
It can be, depending on where you are. An agreement can be formed by an exchange of messages if both sides clearly accepted specific terms. But a thread scatters the terms across a dozen messages, and nobody can easily tell which version won. A short signed document is cheaper than finding out. If a client really will not sign anything, at least send a summary email of the key terms and ask them to reply "agreed".
Should I use the client's contract or mine?
Offer yours first. If the client requires theirs, read it against the twelve sections above and negotiate the ones that move cost onto you: payment timing, IP on signing, unlimited revisions and uncapped liability. Many clients will accept an addendum with your payment and ownership terms attached.
How long should a freelance contract be?
As long as it takes to cover the twelve sections and no longer. For a typical small project that is two or three pages of plain English plus a one-page schedule of deliverables and fees. A contract so long that the client does not read it protects you less than a short one they did read.
The contract sets the terms and the invoice enforces them. Generate yours free at billable.dev.