What to Include in a Freelance Contract (Checklist)

1) Parties & project overview (prevent wrong expectations)

Start with the basics, but make them specific.

• Legal names (or business names) of both parties
• Your role/title (e.g., freelance designer, developer, writer)
• Project summary in plain language
• Where the work is delivered (online, email, files, etc.)
• Client responsibilities (access, materials, approvals, brand assets, subject matter)

Common mistake it prevents: Assumptions. If the client thinks you’re doing one thing and you’re doing another, you lose time and goodwill.

2) Scope of work + deliverables (stop scope creep)

If you only fix one area, fix the scope.

Include:

• In-scope vs. out-of-scope bullets
• Deliverables list (what you will produce)
• Format and size details (file types, word count ranges, specs)
• Resources you need (design files, credentials, data, access)
• Dependencies (approvals, third-party tools, content provided by the client)

A simple way to reduce disputes:

Write deliverables like a receipt. “1 logo in SVG/PNG,” “2 website sections (no homepage redesign),” “12 blog posts (1,000–1,200 words each).”

Common mistake it prevents: Scope creep. Extra tasks sneak in because the contract didn’t define what “done” includes.

3) Timeline/milestones + what happens for delays (avoid burnout and ambiguity)

Deadlines should be clear, but so should what happens when things slip.

Include:

• Start date and target delivery dates
• Milestones (and what must be true to move to the next milestone)
• Client review/approval windows (e.g., “Client provides feedback within 5 business days”)
• Delay rules (how timelines change when the client is late or blocked)
• Force majeure (events outside your control)
• What counts as “delivered” (send date + method)

Common mistake it prevents: Burnout. “We’ll review next week” turns into weeks of stalled work without consequences.

4) Payment terms tied to milestones (reduce disputes—only as needed)

Payment terms should match your deliverables and schedule.

Include:

• Total project price and/or hourly rate (whichever applies)
• Deposit (optional, but common) and when it’s due
• Milestone payments tied to deliverables
• Late payment terms (e.g., net terms and what happens after)
• How you’ll invoice (timing and method)
• Expenses policy (what you charge, how you get approval, receipts if needed)

Tie payment to milestones where it matters. This reduces “You didn’t finish yet, so why do you want payment?” conflicts.

Common mistake it prevents: Paying for uncertainty. If the contract doesn’t link money to outputs, disputes escalate fast.

5) Revisions/changes policy (how many rounds, change requests, fees)

A good revisions section stops endless “just one more tweak.”

Include:

• How many revision rounds are included per deliverable (and what “a round” means)
• What counts as a revision vs. a change request
• Process for requesting changes (written feedback, consolidated list)
• Timeline impact for revisions (reviews can pause your schedule)
• Fees or hourly rate for extra changes
• Limits on reworking based on major scope shifts

Common mistake it prevents: Infinite revisions. Clients keep revising because the contract never sets a boundary.

6) Acceptance criteria (“done” means something)

Define what “accepted” means—so nobody argues about quality after delivery.

Include:

• Acceptance timeframe (e.g., “Client has 5 business days to review”)
• How acceptance happens (written approval or no response by the deadline)
• Objective criteria (based on the deliverable specs you listed)
• Bug vs. non-bug handling (if applicable)
• What happens if revisions are needed (tie back to your revisions policy)

Common mistake it prevents: Delayed acceptance. The work is shipped, but approval never arrives—so you can’t invoice or move forward.

7) Ownership/IP and licensing (avoid publishing/usage conflicts)

This is where freelancers most often get burned.

Depending on your work, you’ll choose one of these common paths:

• Work-for-hire/assignment (client owns once fully paid)
• License to use (you keep ownership, client gets a license)
• Hybrid approach (client owns client-provided materials or final deliverables; you retain reusable tools/templates)

Include:

• What exactly transfers (final files, source files, assets)
• When transfer happens (usually after full payment)
• Rights for drafts/prototypes
• Your retained rights for non-client-specific materials (templates, tooling, generic components)
• Restrictions (e.g., client can’t sell deliverables as-is without permission)

Common mistake it prevents: Confusion over usage. The client assumes they “own everything,” but you meant “license for use after payment.”

8) Confidentiality/data handling (especially for client data)

If you touch client information, treat it carefully.

Include:

• What counts as confidential
• Your obligations (store securely, limit access, use only for the project)
• Data handling rules (transfer methods, encryption if relevant)
• Return/delete policy at project end (and how long you retain backups)
• Subcontractor rules (if you ever use help)
• Exceptions (public info, already known info)

Common mistake it prevents: Accidental disclosure. “It was in my email” is not a security plan.

9) Liability limits and disclaimers (manage risk)

You want to be fair, but also protect yourself.

Consider including:

• Limitation of liability (cap tied to fees paid, common approach)
• Exclusion of indirect damages (like lost profits)
• Warranty disclaimer (you deliver according to specs and use reasonable skill, not guarantees)
• Third-party materials responsibility (stock photos, tools, fonts)

Important: A lawyer can help you word this correctly for your location and work type.

Common mistake it prevents: Unlimited exposure. Without limits, a dispute can become financially threatening.

10) Termination clause (what happens mid-project)

Plans change. Your contract should handle it without chaos.

Include:

• How either party can terminate (notice period)
• Termination for cause (breach, non-payment, missed obligations)
• What happens to work-in-progress
• Payment on termination (pay for work completed + any non-cancelable costs)
• Return of materials and confidentiality obligations continuing
• Time to deliver final items if termination happens

Common mistake it prevents: Stuck projects. One side walks away, and the other can’t get paid or recover files.

11) Communication cadence + decision-making responsibilities

The fastest way to slow a project is unclear communication.

Include:

• Who the decision-maker is on the client side
• Point of contact on both sides
• Communication cadence (weekly check-in, async updates, etc.)
• Response time expectations (and how delays affect deadlines)
• Approval process (how feedback is collected and submitted)
• Meetings rules (optional, but helpful)

Common mistake it prevents: Stalled work. You’re ready, but nobody can approve.

Not sure where your freelance business stands? The Freelance Business Check is a quick way to spot weak spots before they turn into late nights or lost income.

12) Signatures + amendment process (prevent verbal-only changes)

Stop “verbal-only” agreements from rewriting your contract.

Include:

• Signature method (e-signature allowed)
• Entire agreement clause (the written contract is the source of truth)
• Amendment process (changes must be in writing and signed by both parties)
• Order of precedence if you use addendums, SOWs, or proposal documents

Common mistake it prevents: “But we agreed on a call…” Calls should confirm the contract, not replace it.

---

Related reading: How to Manage Freelance Projects (Kickoff to Done) · How to Set Expectations With Clients: Freelance Guide

The contract must-include mini checklist (download-ready)

Copy/paste this into your contract planning doc.

• Parties + project summary (plain language)
• Scope of work (in-scope/out-of-scope)
• Deliverables list + formats/specs
• Client responsibilities + dependencies
• Timeline + milestone dates
• Review windows + delay rules
• Payment terms (price, deposit if any, milestone payments)
• Expense policy (approved vs. not approved)
• Revisions/changes policy (rounds, what counts as a change)
• Acceptance criteria (what “done” means + acceptance window)
• IP ownership/licensing + when rights transfer
• Confidentiality + data handling + return/delete policy
• Liability limits/disclaimers
• Termination clause (notice + payment on termination)
• Communication cadence + decision-makers
• Signatures + amendment process (changes in writing)

---## QA: What’s the minimum to be protected without overcomplicating? If you want the shortest version that still protects you, aim for these minimum sections:

1. Scope + deliverables (including what’s out of scope)
2. Timeline + review/approval windows
3. Payment terms tied to milestones
4. Revisions policy (rounds + change requests)
5. Acceptance criteria (what counts as “done”)
6. IP/licensing + when rights transfer
7. Confidentiality/data handling (if you access client data)
8. Termination + payment on termination

If you cover those, you reduce most real-world freelance mistakes: scope creep, unclear deliverables, payment disputes, and IP/confidentiality problems.