Subcontracting Checklist for Freelancers (No Surprises)

Introduction

Outsourcing is supposed to buy you time. In reality, it often buys you risk: missed deadlines, messy handoffs, surprise costs, and awkward client conversations.

Most freelancers don’t fail at outsourcing because they hire “bad” people. They fail because they subcontract without a process—no clear scope, no quality gate, no change control, and no plan for client approvals.

This checklist is built for real client work. Use it before you bring in a subcontractor, during delivery, and at handoff—so you protect margin, timeline, and trust.

If you want to outsource and still run a tight ship, this is the playbook.

---

Before You Outsource: Qualify the Work and the Risk

Outsourcing works best when you’re delegating execution, not ambiguity.

If the project is still “we’ll know it when we see it,” subcontracting will magnify the uncertainty and turn you into a middle-manager doing damage control. This section prevents that.

Checklist: Is this work ready to subcontract?

• Outcome is defined in one sentence.
  • Example: “Ship a responsive landing page in Webflow matching Figma, scoring 90+ Lighthouse Performance.”
• Inputs are ready and accessible.
  • Figma file, copy deck, brand assets, API docs, example references.
• The boundaries are explicit.
  • What’s included vs excluded.
  • Example: “Includes Webflow build + basic CMS. Excludes copywriting, SEO strategy, custom JS.”
• There’s a review and acceptance rule.
  • Example: “Two revision rounds. Anything new goes into change request.”
• You can verify quality without guessing.
  • Example: “Must pass: mobile layout, form submits to X, no console errors, cross-browser checks.”

Checklist: Should you outsource this at all?

• Client trust is strong enough that you won’t panic if a deliverable slips by 24 hours.
• The task is modular (design system, pages, dev tickets, research blocks).
• The subcontracted work is not the sales anchor.
  • If your entire positioning is “I personally do X,” don’t outsource X unless you’re ready to be transparent.
• Your margin can handle management time.
  • Rule of thumb: assume 15–25% overhead for coordination/QA the first time with a new subcontractor.

Decide your model: white-label vs transparent

This isn’t a moral debate. It’s a risk decision.

• White-label (client doesn’t meet subcontractor)
  • Pros: consistent client experience, fewer variables.
  • Cons: you own all comms, higher management load.
• Transparent (subcontractor introduced as collaborator)
  • Pros: easier technical alignment, shared context.
  • Cons: client may bypass you later unless you set boundaries.

Why this matters for freelancers: You don’t have a project manager buffer. A small mismatch becomes your weekend. Qualifying the work upfront keeps outsourcing from turning into unpaid supervision.

---

Hire and Contract the Subcontractor (With Real Guardrails)

Most outsourcing failures happen before the first task is assigned—during hiring and contracting. The fix is simple: treat subcontracting like a mini-vendor relationship, not a casual favor.

Checklist: Evaluate the subcontractor fast (but properly)

• Portfolio proof tied to your exact deliverable
  • Ask: “Show me one example like this.” Not their best work—work like this.
• A paid test that mirrors the real job
  • Example: “Build one section from the page + make it responsive.”
  • Keep it small: 2–4 hours of work.
• Availability and timezone confirmed
  • Write it down: “Can deliver by Thursday 5pm ET, with 1-hour overlap daily.”
• Communication style check
  • Ask one scenario question:
    • “If you realize the spec is missing something, what do you do?”
  • You want: clarify early, propose options, document assumptions.

Checklist: Subcontractor agreement essentials

You don’t need a 12-page legal doc to be protected, but you do need the basics in writing.

Include:

• Scope + deliverables
  • Be concrete: “3 pages built in Webflow + CMS collection setup.”
• Timeline + milestones
  • Example: “Milestone 1: homepage by Tue. Milestone 2: remaining pages by Thu.”
• Revision limit
  • Example: “Up to 2 revision passes per milestone.”
• Payment terms
  • Fixed fee or hourly cap.
  • Example: “$900 fixed, 50% upfront, 50% on acceptance.”
• IP ownership and transfer
  • “Work product assigned to me upon payment.”
• Confidentiality + client non-solicit
  • Non-solicit matters more than NDA for freelancers.
  • Example clause intent: “No direct work with this client for 12–24 months.”
• Tools + account access rules
  • “No storing client data locally; use provided access only.”
• Exit plan
  • “If terminated, deliver current work-in-progress + source files within 24 hours.”

Checklist: Price it so you still win

Freelancers often outsource at a rate that looks good on paper and collapses in reality.

Build your internal “outsource cost” like this:

• Subcontractor cost
• • your management time (estimate hours × your internal hourly value)
• • QA time
• • buffer (10–20%)
• = minimum viable margin

Example:

• You sell a $5,000 site.
• Subcontractor: $1,600
• Your management/QA: 8 hours × $150 = $1,200
• Buffer: $500
• True cost: $3,300
• Gross margin: $1,700 (34%)

That might be fine. But if your management balloons to 15 hours, you’re now running a low-margin agency without charging like one.

Why this matters for freelancers: Outsourcing is only leverage if it protects profit. A “cheap” subcontractor who needs constant correction is expensive. Guardrails and pricing discipline prevent that slow bleed.

---

Set Up Access, Communication, and a Single Source of Truth

If you want subcontracting to feel “easy,” you need one thing: a predictable operating system.

This section keeps you from chasing updates across email, Slack, Loom, and random Google Docs.

Checklist: Create a subcontractor kickoff packet (copy/paste)

Put this in a single doc (Notion/Google Doc) and reuse it every time.

• Project one-liner
• Client context
  • Who they are, who the end user is, what success looks like.
• Deliverables
  • Bullet list, with acceptance criteria.
• Non-goals
  • Explicitly: what not to do.
• Brand/voice rules
  • Fonts, spacing, tone, constraints.
• Technical constraints
  • Framework versions, naming conventions, hosting environment.
• QA checklist
  • What you’ll check before client sees it.
• Milestones + dates
• Where work lives
  • Repo link, Figma link, folder structure.
• How to ask questions
  • “Post in #project channel with a screenshot + proposed solution.”

Checklist: Access and security (minimum viable)

• Use role-based access whenever possible
  • Invite them to the repo, not your whole org.
• Create separate accounts
  • Don’t share passwords.
• Document exactly what they can touch
  • Example: “Staging environment only. No production deploys.”
• Revoke access on completion
  • Put a calendar reminder for the project end date.

Checklist: Communication cadence

Pick a cadence that matches the risk.

• Daily async update (2–5 lines)
  • “Done / Next / Blocked”
• Twice-weekly 15-min check-in for anything complex
• One escalation rule
  • Example: “If blocked > 2 hours, message me immediately.”

Checklist: Define “done” before work starts

“Done” is not “looks good to me.”

Write acceptance tests.

Examples:

• Design:
  • “Matches Figma within 4px tolerance; uses defined components; exports delivered.”
• Development:
  • “No console errors; passes lint; passes test suite; PR reviewed and merged.”
• Copy:
  • “Meets 6th–8th grade readability; uses brand terms; includes CTA variants.”

Why this matters for freelancers: Your client doesn’t care that a subcontractor was blocked. They care that you missed a deadline. Tight setup reduces your need to babysit and gives you clean evidence when something slips.

---

Delivery Management: Quality Control and Change Requests

This is the core: turning subcontracting into predictable delivery.

The freelancer trap is letting subcontractor work go straight to the client. Don’t. You need a QA gate and a change-control path so scope doesn’t expand silently.

Checklist: Run work through a “client-safe” QA gate

Before the client sees anything, you check:

• Scope match
  • Does it fulfill the exact deliverable list?
• Quality bar
  • Spacing, responsiveness, edge cases, performance, accessibility basics.
• Consistency
  • Naming conventions, component reuse, file structure.
• Risk
  • Anything fragile, hacked together, or hard to maintain?

A simple rule: no client review without internal review. Always.

Checklist: Use milestone approvals (and freeze points)

Milestones are how you stop endless revisions.

For each milestone:

• Subcontractor submits deliverable
• You review and request changes (internal)
• You approve and mark it “client-ready”
• You present to client
• Client approves (or requests changes within the revision limit)
• Freeze that milestone

Write it down: “Once Milestone 1 is approved, changes are billed as a change request.”

Checklist: Handle change requests without drama

Change requests happen. The mistake is absorbing them.

Use a three-step response:

1. Name the change
   • “This adds a new pricing page and requires CMS updates.”
2. State the impact
   • “That’s 6–8 hours and moves the timeline by ~2 days.”
3. Offer options
   • “Option A: add $X and keep launch date by removing Y. Option B: keep scope, launch as-is, add this in Phase 2.”

If you’re using Manager List, this is where it shines: you can adjust pricing live on the call, update the scope, and capture the signature immediately—no PDF ping-pong or “I’ll get back to you.”

Checklist: Protect your margin with subcontractor change control

When the client changes scope, your subcontractor scope changes too. Don’t negotiate twice.

• Update your internal task list first
• Confirm new timeline with subcontractor
• Confirm cost impact in writing
• Only then commit to the client

Also: avoid “just one more thing” from the subcontractor side. If they uncover a real issue, ask for:

• Problem summary
• Options
• Best recommendation
• Estimated time

Why this matters for freelancers: Your profit dies in the gaps—between what the client expects and what the subcontractor heard. QA gates and change-control keep you from paying for someone else’s ambiguity.

---

Client Handoff, Invoicing, and Post-Mortem

Outsourcing isn’t done when the work is “finished.” It’s done when:

• the client accepts it,
• you get paid,
• and you can maintain it without fear.

This section makes outsourcing sustainable, not stressful.

Checklist: Client-ready handoff package

Deliverables depend on your niche, but the structure stays consistent:

• What shipped (bullet list)
• How to use it
  • Short Loom + written steps
• Credentials and access
  • Who owns what (client vs you)
• Maintenance notes
  • What’s safe to edit vs not
• Known limitations
  • Be honest and specific
• Next-step recommendations
  • Phase 2, optimizations, backlog

Checklist: Invoicing and payment timing

Don’t wait until “everything is perfect” to invoice.

• Invoice on milestone approval
• Keep final payment tied to acceptance criteria, not vibes
• If the client stalls, set a default acceptance window:
  • “If no feedback within 5 business days, we consider it accepted.”

For subcontractors:

• Pay per milestone, not “whenever”
• Don’t pay final until you have:
  • source files,
  • access transfers,
  • documentation,
  • and any required fixes.

Checklist: Close out access and files

• Remove subcontractor access (repo, Figma, Drive, staging)
• Archive project folder
• Store final sources in a predictable place
• Write a short “runbook” for yourself:
  • “If client asks for X, here’s where Y lives.”

Checklist: Post-mortem (10 minutes, every time)

Answer:

• What went well?
• What caused friction?
• What should be templated?
• Would I hire them again for the same work?

Keep a simple subcontractor scorecard:

• Quality (1–5)
• On-time (1–5)
• Communication (1–5)
• Initiative (1–5)
• Requires supervision (low/med/high)

Why this matters for freelancers: The goal isn’t “get through this project.” The goal is building a repeatable delivery machine. Post-mortems are how you turn a chaotic outsource into a scalable system.

---

Conclusion

Subcontracting can either free you up—or quietly turn you into an underpaid PM.

Use this checklist to make outsourcing predictable: clear scope, clear guardrails, tight QA, and real change control. That’s what protects your timeline, your margin, and your reputation.

Practical next step: on your next discovery call, don’t promise a proposal “later.” Walk the client through scope and options live, then lock it in while you’re both on the call. Manager List is built for that—so the work you outsource starts with a signed agreement, not a shaky maybe.