A freelance contract isn't a legal document so much as a prenuptial agreement. Both parties want to believe they won't need it. Then a payment goes late, a scope shifts, an IP question comes up, a clearly-finished project keeps generating revision requests four weeks later, and the contract is the only thing standing between “a misunderstanding” and “an expensive lawyer.”
This isn't legal advice; it's the practical list of clauses that, after writing or reviewing a few hundred freelance contracts, I've seen prevent the most pain. If you're starting from scratch, copy this list. If you already have a template, run it against this list and patch the gaps.
1. The parties
Full legal names of both parties, with addresses. If you're an LLC, the LLC is the party — not you personally. If your client is a company, name the company, not the contact. This sounds obvious but is the most common amateur mistake: signing a contract as “Jane Smith, Freelancer” when you should be signing as “Smith Consulting LLC.”
Including addresses matters because it's what makes the contract enforceable in a specific jurisdiction. Without an address, “governed by California law” can become a fight about whether California law actually applies.
2. The scope, by reference
Don't restate the scope in the contract. Reference the proposal: “Services shall be provided as described in the Statement of Work dated [date], attached as Exhibit A.” This way, when the proposal changes (and it will), you update one document instead of two.
The proposal already names what's in scope, what's out of scope, deliverables, and milestones. The contract is the legal wrapper around that commercial agreement.
3. Fees, payment schedule, and late penalties
Three pieces:
- Total fee and structure. “Fixed fee of $15,000” or “Hourly at $200/hour with a hard cap of $13,000.” If retainer: “Monthly retainer of $4,000.”
- Payment schedule. “50% on contract sign; 50% on delivery” or whatever your milestone structure is. Tied to deliverables, not dates — a late deliverable shouldn't delay your payment if the deliverable was late because the client was slow to respond.
- Late penalty. “Invoices not paid within 30 days incur a 1.5% monthly late fee.” This isn't really about collecting the late fee — it's about giving the client's accounts-payable team a reason to push your invoice up the queue.
4. IP ownership transfer (with conditions)
Most contracts say “upon final payment, all IP transfers to the client.” The conditional part matters. Without it, the client owns the work the moment you deliver it, which means they can cancel mid-project and walk away with what you've already built.
With it, the client gets a license to USE the work during the engagement (so they can review it), but ownership only transfers when the last invoice clears. If the client stops paying, the work stops being theirs.
Two carve-outs to consider:
- Your tools and frameworks. If you bring a proprietary tool, framework, library, or template into the engagement, it stays yours. The client gets a license to use it within the deliverable; they don't own it.
- Generic work product. Open-source contributions you make during the engagement (e.g., a bug fix to a library you used) typically stay yours. State this explicitly so the client doesn't claim them.
5. Confidentiality (mutual)
Standard NDA-style language: each party agrees not to disclose confidential information of the other for some defined period (typically 2-5 years). The mutual part matters; many client- provided contracts only protect the client. Make it bidirectional — your business processes, pricing, and methodologies are also worth protecting.
Specific exclusions: information already public, information the receiving party already had, information independently developed, information disclosed by a third party not under NDA. These carve-outs are standard and protect both parties from accidentally violating the NDA by, e.g., reading the news.
6. Limitation of liability
Cap your total liability at the total fees paid under the contract. Without this clause, a $10K engagement that causes a $200K bug for the client could turn into a $200K judgment against you. With it, your downside is capped at $10K.
Standard form: “In no event shall either party's liability under this agreement exceed the total fees paid to Service Provider under this agreement. Neither party shall be liable for indirect, incidental, consequential, or punitive damages.”
Some clients will push back on this. Hold your ground. A freelancer accepting unlimited liability on a $10K project is accepting risk no insurer would underwrite.
7. Termination, with notice and payment for work to date
Either party can terminate with 14 days' written notice. Upon termination, the client owes you for work completed up to the termination date, plus a reasonable wind-down. This protects both of you from the worst-case outcome (the client wants to bail; you're mid-sprint).
Some contracts include termination-for-cause language: immediate termination without notice for material breach, gross misconduct, bankruptcy, etc. Useful but rarely invoked; the with-notice clause covers 99% of real-world cases.
8. Independent contractor language
A short paragraph stating that the freelancer is an independent contractor, not an employee or partner. No benefits, no tax withholding, no implied employment relationship. This protects the client from misclassification claims (e.g., the IRS deciding the freelancer was actually a W-2 employee) and protects the freelancer from being claimed as a partner.
9. Non-solicitation (not non-compete)
Non-compete clauses are increasingly unenforceable in many jurisdictions (and outright banned in California). Non- solicitation is different and usually enforceable: for a defined period (typically 12 months) after the engagement ends, neither party will solicit the other's employees or contractors. Protects both sides from the “you stole my developer” conversation.
10. Governing law and dispute resolution
Name the state whose law governs (typically your state, since you're the one writing the contract). For dispute resolution, two clauses worth including:
- Mandatory mediation before litigation. Disputes go to mediation first. This filters out 80% of would- be lawsuits and keeps your relationships intact.
- Venue. If mediation fails, the case is heard in [your county] courts. Prevents the client from forcing you to fly across the country to defend a small claim.
11. E-signature acceptance + audit trail
Most freelance contracts are signed via e-signature today. Add a clause acknowledging that e-signatures are legally binding under the E-SIGN Act (US) or eIDAS (EU), and that the platform capturing the signature (DocuSign, Scopivo, etc.) records IP + timestamp + email of the signer.
If you're using a tool like Scopivo that bundles contracts with the rest of the client engagement, the audit trail is captured automatically. We cover what an honest audit trail looks like in our comparison with HoneyBook and comparison with Dubsado: signer name, email, IP, timestamp, user-agent — preserved in the signed PDF.
The shortcut: a templated contract per engagement type
You don't need a different contract for every project. Most freelancers run with 2-3 standard contract templates: one for fixed-fee projects, one for hourly engagements, one for monthly retainers. Customize the parties, fees, scope reference, and signature blocks for each engagement; everything else stays the same.
If you're building from scratch, hire a contract lawyer for an hour ($300-$500 in most markets) to review your templates once. After that, you reuse them for every engagement. The amortized cost is trivial; the protection is real.
What to skip
Things that pad freelance contracts without helping anyone:
- Force majeure boilerplate. Yes, technically you want it. No, you don't need three paragraphs of it. One sentence: “Neither party is liable for delays caused by events outside reasonable control (natural disasters, war, pandemic, government action).”
- Assignment clauses. Unless you actually contemplate assigning the contract to a third party, the standard “neither party may assign without consent” covers it.
- Entire-agreement and amendment clauses. Standard. Include if you want; the absence rarely causes problems.
- Severability. Already implied by law in most jurisdictions. Useful but unremarkable.
Bottom line
A freelance contract works when both parties never need to read it. It exists for the rare case when one party does. Build it for that rare case; keep it short enough that the client actually reads through it before signing.
Bonus: most clients will respect a freelancer with a real contract more than one with a hand-shake. Sending a clean, professional contract is itself a signal that you take the engagement seriously. That signal converts.