A handshake deal feels perfectly fine right up until a client cancels halfway through, asks for unlimited revisions, or disappears for three weeks and then demands the source files. At that point, "we talked about it on a call" is not a document anyone can point to, and you're stuck relying on memory and goodwill instead of something you both agreed to in writing.
Scope: the clause that prevents most other disputes
A contract without a clearly defined scope is really just a price with a vague promise attached to it. Spell out exactly what you're delivering: how many pages, how many design concepts, what's included and what's explicitly not included. "Website redesign" is not scope. "5-page responsive website, 2 homepage design concepts, content migration from the existing site, does not include copywriting or stock photo licensing" is scope. If you only write one clause carefully, write this one, because almost every other dispute on this list traces back to a scope that was too vague to settle the argument.
Payment terms: deposit, schedule, and what happens if payment stalls
State the deposit amount, the full payment schedule, the due dates, and what happens if a payment is late. A simple version: "50% deposit due before work begins, remaining 50% due on delivery, net 14 days. Work will pause if payment is more than 7 days overdue." Without this in writing, you're negotiating payment terms after the fact, which is a much weaker position than having agreed terms to simply point back to.
Kill fee and cancellation: what happens if the project stops early
This is the clause most freelancers skip, and it's the one that causes the ugliest disputes. Projects get cancelled for reasons that have nothing to do with your work: budget cuts, a change in business direction, a new hire taking the project in-house. Without a cancellation clause, you have no clean way to bill for work already done.
A workable version: "If the client cancels the project before completion, the client agrees to pay for all work completed up to the cancellation date, calculated at the agreed rate, plus a kill fee of 20% of the remaining contract value." The kill fee compensates you for the lost opportunity cost of turning down other work to make room for this project, not just the hours already logged.
IP and ownership transfer: define exactly when it happens
This is the second most-skipped clause, and it causes real disputes. Most freelancers assume ownership transfers automatically once a project is "done," but "done" is not a legal moment, full payment is. Without a clause saying so explicitly, both sides can walk away with a different understanding of who owns the files.
Here's a realistic example of what that looks like when it goes wrong. A freelance designer delivers a full brand identity package (logo, color system, font files) to a startup. The startup pays the 50% deposit, reviews the work, and then goes quiet for six weeks before emailing to say they're "pausing the project indefinitely" and asking for the final source files anyway, since they "already have the designs." The designer never agreed to hand over ownership before final payment, but there's nothing in writing that says so either. What should have been a five-minute email exchange turns into a month of back-and-forth, because neither side has anything to point to.
The fix is one sentence: "Final files and full ownership rights transfer to the client upon receipt of final payment. Working files and ownership remain with the freelancer until that point." Put it in writing before the project starts, and this exact dispute simply doesn't happen, because there's no ambiguity left to argue about.
Revision limits: a number, not a feeling
"A few rounds of revisions" means something different to you than it does to your client. Define it as a specific number: "Two rounds of revisions are included. Additional rounds are billed at $75/round." This protects you from unlimited tweaking disguised as "just one more small change," and it gives the client a clear, fair reference point instead of a guess about where the line is.
Confidentiality: protect both sides, not just the client
Clients often expect an NDA-style clause protecting their business information, and that's reasonable to include. But confidentiality should also protect you: a simple line stating that you're allowed to list the client and project in your portfolio unless they specifically request otherwise in writing. Without this, some clients will quietly assume your work for them is automatically confidential by default, which can cost you the case studies and portfolio pieces that win your next client.
A short contract that covers the essentials
You don't need a dense legal document to capture the clauses above. A workable freelance contract can be a single page that states, in plain language: who the parties are, what's being delivered (point to your scope of work document for the details), the price and payment schedule, the cancellation and kill fee terms, when ownership transfers, the revision limit, and the confidentiality terms. Both sides sign it, both sides keep a copy, and it becomes the thing you point to the one time in twenty projects when a disagreement actually needs settling.
What to do when a client sends their own contract
Sooner or later, a client (usually a company with its own legal team) will ask you to sign their contract instead of yours. This isn't automatically a red flag, larger companies often have a standard vendor agreement they use for everyone, but it does mean the clauses above were written with their interests in mind first, not yours, and you should actually read it rather than skimming to the signature line.
Pay particular attention to a few things that company-drafted contracts sometimes get wrong from a freelancer's perspective: an ownership transfer clause that assigns rights immediately upon creation rather than upon payment (meaning they'd own your work even if they never paid for it), a non-compete clause that's broader than the actual project warrants (restricting you from working with their competitors for a year, when you only did one small project), or payment terms that are unusually long (net 60 or net 90 is common in corporate contracts but can be genuinely difficult for a freelancer relying on that income).
None of these are necessarily dealbreakers, but they're all negotiable. A simple, professional ask covers most of it: "Thanks for sending this over. A couple of small adjustments I'd like to request: could we change the ownership transfer to occur upon receipt of final payment rather than upon delivery, and shorten the payment terms to net 30? Happy to sign once those are updated." Companies that genuinely want to work with you will usually accommodate reasonable requests like these without much friction, since the clauses in question are rarely load-bearing for them, they were just defaults nobody had reason to question before you asked.
Keep signed contracts somewhere you can actually find them later
A contract you can't locate six months later when a dispute comes up is barely better than no contract at all. Keep signed copies (PDF is fine) in one consistent place, named consistently (client name plus project name plus date works well), separate from the general email thread where it might get buried. The five minutes this takes when you sign a contract is nothing compared to the time it costs to dig through old email searching for an attachment when you actually need to reference a specific clause under pressure.
When you actually need a lawyer versus when a template is enough
For most small projects (a few hundred to a few thousand dollars, a clearly defined deliverable, a domestic client), a clear, reusable one-page or two-page template covering the clauses above is genuinely enough. You don't need custom legal drafting to state your payment terms plainly and have both sides sign it.
You should involve a lawyer when the stakes or complexity go up meaningfully: large contracts (high five figures and above), anything involving equity or revenue share instead of a flat fee, international contracts where enforcement could become genuinely complicated, or any clause you don't fully understand yourself. A lawyer is also worth the cost the first time a client's own contract lands in your inbox wanting you to sign their version, since those are often written entirely in their interest and may quietly waive protections you'd otherwise have.
The realistic middle ground most working freelancers land on: a solid reusable template for the vast majority of projects, and a one-time consultation with a lawyer to review (not draft from scratch) that template once, so you know it actually holds up. Once you have a contract that captures scope clearly, a scope of work document attached to it does most of the heavy lifting, since most of the disputes above only happen when nobody wrote down, in plain language, what "done" actually means.