The Independent Contractor Agreement Template That Actually Holds Up

An independent contractor agreement is the written contract that sets the terms between a business and someone doing work for it who isn't an employee: what gets delivered, how much it pays, who owns the output, and what happens if either side wants out. No agreement means no paper trail if a payment gets disputed or a deliverable never shows up. That's the whole reason this document exists, and it's worth getting right the first time instead of Frankensteining one together from a template you found in 2019.

Here's the thing about contractor agreements: most free templates floating around the internet get the boilerplate right and the two clauses that actually matter wrong. Work-for-hire language that doesn't apply to contractors. A classification section written by someone who's never heard of the IRS common-law test. This guide fixes both, with real sample wording you can adapt, not vague placeholder text.

Roughly 7% of the US workforce works as independent contractors, per the US Chamber of Commerce. That's a lot of businesses relying on a document they probably haven't looked at closely since they copy-pasted it.

A verbal agreement works fine until it doesn't. Then it's your word against theirs, and neither of you has anything to point to.

For the business, a written agreement locks in scope so "just one more revision" doesn't turn into a rewrite. It protects IP ownership (more on why that's trickier than most people assume), sets payment terms that prevent invoice disputes, and creates the paper trail regulators want if your contractor classification ever gets questioned.

For the contractor, the same document cuts the other way: guaranteed payment terms, a defined scope that stops scope creep, and clarity about what happens if the client cancels the project halfway through. A good independent contractor agreement isn't a "gotcha" weighted toward one side. It's genuinely useful to both, probably why it survives so many rounds of negotiation intact.

Managing this as a business owner? Chaindoc's contract templates library includes a ready independent contractor agreement plus dozens more, so you're not starting from a blank page every time you hire someone new. Drafting from the freelancer's side instead? Our freelancers page covers the tools that make sending, signing, and getting paid on one contract painless instead of a five-app juggling act.

Skip any of these and you're not saving time, you're just moving the argument to later, when it's more expensive to resolve. Here's what each one needs to say, with actual sample language instead of a placeholder.

1. Parties and scope of services. Name both parties using their full legal names (not "the freelancer" and "the company"), and push the actual deliverables into a separate exhibit rather than burying them in the main body.

That last sentence does more work than it looks like. It's the line that stops "quick favor" requests from quietly becoming unpaid extra scope.

2. Payment terms. Spell out the structure (hourly, milestone-based, or a flat fee), what triggers an invoice, and how fast payment actually happens once one lands.

That last line matters more than it seems. It reinforces contractor status (see clause 6) and heads off a "wait, why didn't you withhold taxes" conversation eight months later.

3. Term and termination. State the start date, the expected end (or that it runs until the deliverable is complete), and how either side exits early.

Fourteen days is a common default, but there's no universal right number. Match it to how disruptive a sudden stop would actually be for the type of work involved.

4. IP assignment (not just "work for hire"). This is where the most expensive mistakes hide. Under US copyright law, "work made for hire" only automatically applies to independent contractors for nine narrow statutory categories (things like contributions to a collective work or a translation), and most software, design, or writing work doesn't qualify. If your entire IP clause leans on work-for-hire language and the work doesn't fall into one of those categories, ownership may legally stay with the contractor no matter what the contract implies.

The fix is a present-tense assignment clause that works regardless of category:

That belt-and-suspenders phrasing covers you whether or not the work happens to fall into one of the statutory work-for-hire categories. If you're building software specifically, our deeper walkthrough on the IP assignment agreement for developers goes further into edge cases like pre-existing code and open-source dependencies.

5. Confidentiality. Define what counts as confidential, what the contractor's allowed to do with it, what's explicitly excluded (public information, stuff the contractor already knew), and how long the obligation survives after the contract ends.

Working with contractors who touch source code or sensitive product plans? A standalone NDA alongside the main agreement is often worth the extra document. Our guide to contractor NDAs for software companies covers when a separate NDA earns its keep versus when a confidentiality clause in the main agreement is enough.

6. Contractor status clause. This is the clause that actually matters for classification, and it's the one most templates get lazy about. State plainly that the contractor controls the manner and means of the work, isn't an employee, covers their own taxes and benefits, and is free to take on other clients.

Fair warning, and this one's important: writing this clause doesn't make it true. If the actual working relationship looks like employment (set hours, exclusive availability, close day-to-day supervision), calling it a contractor agreement doesn't change how the IRS or Department of Labor sees it. More on that in the classification section below.

7. Indemnification. Cover who's on the hook if a third party sues over the contractor's work: a breach of contract, negligence, or IP infringement claim.

8. Governing law and venue. Pick which state's law applies and where a dispute would get filed if it comes to that.

Here's how the eight clauses above stack into an actual document. Follow this order and you've got a working first draft, not just a checklist.

1. 1
   Preamble: agreement date, full legal names of both parties, one-sentence purpose.
2. 2
   Scope of services: reference to Exhibit A for the detailed deliverables.
3. 3
   Payment terms: rate structure, invoicing schedule, payment deadline, tax responsibility.
4. 4
   Term and termination, with start date, end condition, and a notice period for early exit.
5. 5
   Intellectual property assignment: present-tense assignment clause (see clause 4 above), not work-for-hire alone.
6. 6
   Confidentiality: definition, permitted use, exclusions, survival period.
7. 7
   Independent contractor status, the classification-defense clause covered in clause 6 above.
8. 8
   Indemnification: who covers what if a third-party claim shows up.
9. 9
   Governing law: state and venue.
10. 10
    Signatures from both parties, dated, ideally e-signed (more on that below).
11. 11
    Exhibit A: scope of services, attached separately, with itemized deliverables, milestones, or an hourly estimate.

That's not padding, every one of those eleven sections is either doing legal work or preventing a future argument.

Here's the part that surprises people: calling someone a "contractor" in the agreement's title doesn't make them one in the eyes of the IRS or the Department of Labor. Classification depends on the actual facts of the working relationship, not the label on page one.

Two federal tests matter here, and they don't perfectly overlap. The IRS uses a common-law test built around three categories: behavioral control (does the business direct how the work gets done, not just what gets delivered), financial control (who covers expenses, who can profit or lose on the arrangement), and type of relationship (a written contract, benefits, an expectation the relationship continues indefinitely). The Department of Labor applies an economic-reality test under the Fair Labor Standards Act, asking whether the worker is economically dependent on the employer or genuinely running an independent business.

Misclassification isn't a paperwork technicality. It carries real cost: back taxes, unpaid overtime, penalties if a state agency or the DOL disagrees with how you've classified someone. Our companion piece on independent contractor vs. employee status breaks down the state-level variations layered on top of the federal tests, since a handful of states apply an even stricter "ABC test."

Paying a contractor for the first time? You'll also need a completed W-9 before the first payment goes out, not after. The IRS wants that on file before money changes hands, not once tax season hits and someone's scrambling for a tax ID number.

Most of these show up in templates that look complete but skip the part that actually gets tested in a dispute.

Beyond those three: missing payment mechanics (no clear invoicing trigger or deadline invites disputes over "when was this actually due"), a confidentiality clause with no survival period (so it evaporates right when it matters most), no wind-down terms for a mid-project cancellation, and a skipped governing law clause, which turns any dispute into an argument over jurisdiction before you even reach the actual disagreement.

Once the agreement's drafted, getting it signed shouldn't be the bottleneck. In the US, electronic signatures on a contractor agreement are legally valid under the federal ESIGN Act and state-level UETA, which nearly every state has adopted in some form. Notarization isn't required for this kind of agreement to hold up; a properly executed e-signature carries the same legal weight as ink on paper.

Chaindoc's document signing handles multi-party signing (handy if your agreement needs sign-off from more than one person on the client side), tracks a blockchain-verified audit trail automatically, and works whether your contractor is down the street or on another continent. No printing, scanning, or the "did you get my emailed PDF" back-and-forth that eats half a day for a two-page document.

A solid template covers the standard case well. It stops covering you the moment your situation gets specific: a contractor working across state or national borders where local labor law might apply differently, a deal structure involving equity or profit-sharing instead of straight payment, a non-compete clause (which several states restrict or ban outright for independent contractors), or any agreement above a dollar amount where getting it wrong would actually hurt.

None of this is legal advice specific to your situation. Treat this guide as a strong starting point for the clauses and structure a contractor agreement needs, then have a lawyer review the final draft if the stakes or complexity go beyond a standard one-off engagement. Cheaper to ask before signing than to litigate after.