Used well, subcontractors give a small agency the capability of a much larger one — without the overhead. Used badly, they create a parallel workforce with no visibility, variable quality, and a billing model that eats into your margin silently. Most agencies land somewhere in the middle: a loose network of contractors they trust personally but manage through a tangle of WhatsApp messages, shared Dropbox folders, and gut feel. Here’s how to do it properly.
Why Subcontracting Makes Strategic Sense — With Caveats
For a 5–12 person digital agency, the economics of subcontracting are genuinely compelling. You can take on a £40,000 build that requires a specialist iOS developer without hiring one full-time. You can pitch for a client in a vertical you don’t normally serve by bringing in a subject matter expert for the discovery phase. You can absorb a seasonal spike in demand without committing to a salary that becomes a liability when the pipeline thins out.
The typical margin on subcontracted work — once you account for your management overhead, client relationship, and the risk you’re holding — should be somewhere between 25% and 40% above what you’re paying the contractor. If you’re billing a client £850 per day for a developer and paying the subcontractor £650, that’s a 30% margin on that resource. That’s not exceptional, but it’s reasonable provided the management overhead doesn’t quietly eat it.
The caveats are real though. Every subcontractor you bring in introduces a node of uncertainty: their availability may shift, their quality may vary across project types, and your client doesn’t know they exist. You are the party responsible for the output. A subcontractor who delivers late, goes quiet, or submits work that needs significant rework doesn’t just cause a project problem — it becomes your client relationship problem. The closer your systems are to zero, the more likely you are to find this out at the worst possible moment.
Get the Commercial and Legal Foundations Right First
Before anything else, every subcontractor relationship needs a written agreement. This is non-negotiable and yet a surprising number of agencies skip it for contractors they’ve worked with before, or for short engagements they consider low-risk. The agreement doesn’t need to be 20 pages — a well-written one-page document covers what you actually need: scope of work, rate and payment terms, IP assignment, confidentiality, and the right for you to request revisions.
The IP clause is the one most agencies get wrong. By default in the UK, a freelancer who creates something for you owns the intellectual property in it unless there is a written agreement to the contrary. If your subcontractor writes the code, designs the interface, or authors the copy, and there’s no IP assignment clause, you may not own the work you’ve delivered to your client. Check your existing subcontractor agreements now if you haven’t recently — this is a genuinely common exposure.
Your subcontractor agreement should also include a non-solicitation clause preventing them from approaching your client directly for a defined period after the engagement ends. This isn’t about distrust — it’s about protecting a relationship you built and maintaining the value of your position as the agency managing it. Keep the period reasonable (12–24 months is standard) and mutual if the contractor insists.
On payment terms: pay subcontractors within 14–30 days of their invoice. You will get better contractors and better responsiveness when people know you pay reliably. If your own clients are on 30-day terms, budget accordingly — carrying short-term subcontractor costs is part of the service you’re providing.
Onboarding: Treat Them Like Team Members, Not Vendors
The agencies that get the best work out of subcontractors are the ones that invest in onboarding them properly. That sounds obvious until you compare it to what actually happens in most agencies, which is: send them the brief, add them to a Slack channel, and assume they’ll figure the rest out.
A proper subcontractor onboarding for a project engagement should take 30–60 minutes and cover four things. First, client context: who the client is, what matters to them, what the agency relationship looks like, and any sensitivities to be aware of. A good contractor can adjust their communication style and assumptions based on this; a contractor working blind can’t. Second, the project brief in detail — not the version you sent the client, but the internal working version with clarifications and known risks already annotated. Third, your standards: how you expect work to be delivered (file naming conventions, code standards, delivery format), and what your QA process looks like. Fourth, communication expectations: who they report to, how often you want updates, and what constitutes something that needs escalating rather than just solving.
That last point matters more than most agencies realise. A subcontractor who quietly solves a problem by making a significant technical decision — say, choosing a third-party API that introduces a dependency your team now has to maintain — hasn’t done you a favour. Define the decision boundary clearly at the start: here’s what you have full autonomy on, here’s what you flag before doing.
Keeping Subcontractor Work Visible in Your Projects
The most common operational failure mode with subcontractors is the visibility gap. The work is happening, but you can only see it when the contractor sends you an update. That’s not project management — it’s passive monitoring. When the deadline arrives, you have no idea whether they’re 80% done or 30% done until you ask.
The fix is integrating subcontractor work into your existing project management setup rather than running it in a separate channel. Assign tasks to subcontractors in your project tool. Have them log time against the project (even if you’re paying them a day rate rather than hourly, logged time is useful for your own utilisation data and future estimating). Give them milestone check-ins with defined deliverables, not just a final deadline.
Marque CRM’s projects module lets you assign tasks to team members — and you can include subcontractors as additional users on projects without giving them access to your full client or billing data. That separation matters. A subcontractor working on one project doesn’t need to see your pipeline, your other clients’ support tickets, or your financial reports. Task-level visibility, contained to their project, is exactly what’s needed.
Set weekly check-in touchpoints for any engagement longer than two weeks. These don’t have to be calls — a brief async update against a template (“work completed this week / planned next week / any blockers”) takes five minutes and surfaces problems before they become crises. A subcontractor who’s stuck on something will often sit with the blocker rather than surface it unprompted, particularly on early engagements where they’re still building confidence in the relationship.
Time Tracking, Billing, and Protecting Your Margin
Subcontractor cost management is where agencies most frequently lose money without realising it. The failure mode isn’t usually paying too much — it’s that subcontractor costs aren’t tracked against project budgets in real time, so overruns aren’t caught until the invoice arrives and the project has already been delivered.
If you’re using a day-rate model, track days consumed against days budgeted the same way you’d track hours. If a project budgeted 8 days of development has consumed 6.5 with significant scope still remaining, that’s a conversation that needs to happen now — either a scope reduction, a client change request, or a renegotiation with the contractor. Not after delivery.
For time-and-materials subcontractors, the discipline is stricter. Require weekly timesheets, not end-of-project invoices. Review logged hours against task completion: if a contractor has logged 20 hours on a task estimated at 12, you need to understand why before those hours reach an invoice. This isn’t about distrusting the contractor — it’s about having the information you need to manage the project profitably. A good contractor will expect and respect this rigour.
Your blended project margin — the difference between what you’ve charged the client and what the project has cost including subcontractor fees, your team’s time, and overhead — should be visible at the project level throughout delivery. If you’re only calculating this at close, you’re flying blind for most of the engagement. Marque CRM’s time tracking and project tools let you see actual cost versus budget in real time, which is particularly useful when you have a mix of internal and external resource on the same project.
Managing Quality Without Micromanaging
The tension in subcontractor management is between oversight and autonomy. Subcontractors — especially experienced ones — will deliver better work when they have genuine ownership of their domain. But without any review structure, the first time you see the output is when you’re about to send it to a client, which is the worst possible moment to discover it doesn’t meet your standard.
The answer is structured checkpoints, not constant check-ins. For a two-week development sprint, that might be: a brief scope alignment at day one, a mid-point review of work-in-progress at day seven, and a formal handoff review on day fourteen before it goes anywhere near the client. At each checkpoint you’re reviewing against the brief, not re-briefing. The difference matters — re-briefing mid-project is a failure of the initial onboarding; reviewing against the brief is normal quality management.
Define your acceptance criteria in writing at the start. “The homepage should load in under 2.5 seconds on a 4G connection, pass WCAG 2.1 AA standards, and be tested against Chrome, Safari, Firefox, and Edge” is a standard the contractor can work to and you can review against. “Make it look professional” is not. The more precise the spec, the less subjective the QA review, and the less room for disagreement about whether revisions are included in scope or constitute additional work.
Keep a brief record of each subcontractor’s performance per project: what was delivered on time, what needed revisions, what the communication was like. Over time, this becomes genuinely valuable data for deciding which contractors to use for which type of work. The developer who’s exceptional for complex CMS builds but consistently slow on e-commerce integrations is useful to know about before you’ve committed them to a Shopify project with a tight deadline.
Building a Reliable Bench, Not Just a Contact List
Most agencies accumulate contractors reactively — someone recommends a designer, a developer reaches out after seeing your work, a previous employee goes freelance. The result is a list of contacts with no real structure: some people you’d bring in tomorrow, some you’ve used once and aren’t sure about, some you’ve only heard of secondhand.
A functioning contractor bench is actively maintained. Aim for at least two qualified options in each discipline you regularly subcontract — so you have cover when your first choice is unavailable. Nurture the relationship between projects: share relevant work, give referrals where you can, drop a message when you think of them for an upcoming pitch. Contractors who feel like part of the extended team are far more responsive when you need them quickly than ones who only hear from you when you have work to offer.
When you bring a new contractor in for the first time, give them a well-defined, lower-stakes first project if you can. Something where a problem can be caught and corrected without blowing a major client relationship. It’s a reasonable way to verify the working relationship before you’re relying on them on a £60,000 retainer client. Most experienced subcontractors will understand this logic — they’re doing their own evaluation of you too.
Your contractor bench is an asset. Treat it like one. The agency that can say “we have four great developers we can call on” is fundamentally more capable than the one scrambling on LinkedIn every time a project requires one.
Systems That Make This Manageable at Scale
The overhead of managing subcontractors well is real, but it’s largely a systems problem. Agencies that do this badly tend to rely on ad hoc communication and manual tracking; agencies that do it well have made the right behaviour the easy behaviour through their tooling.
What you actually need in your stack:
- A project tool where subcontractors can be assigned tasks and log time — with project-level visibility for you and limited access for them. Not a separate tool, not a shared spreadsheet; integrated into the same system your team uses.
- A contracts library with a standard subcontractor agreement template you can tailor per engagement and get signed quickly. Marque CRM’s contracts module includes e-sign, so there’s no friction in getting a new contractor signed up before work starts.
- Expense and cost tracking at the project level — so subcontractor invoices are logged against the project budget and your margin is visible throughout, not just at billing time.
- A lightweight internal record per contractor — availability notes, rate history, skills, project history, performance notes. This doesn’t need to be complex; a contact record with good notes is enough. What it shouldn’t be is in your head.
The administrative overhead of managing even a small contractor network — agreements, briefs, check-ins, timesheets, invoices, QA — adds up to several hours per week if you’re doing it manually across multiple tools. The agencies that scale this well are the ones who’ve centralised it. When everything is in one platform, the management overhead per contractor drops significantly, and you can handle a larger network without it becoming a full-time job.
If you’re currently managing subcontractors across a combination of email, Slack, Google Drive, and a spreadsheet, the hidden cost of that fragmentation is worth examining. Context gets lost between tools. Decisions made in a WhatsApp thread don’t make it into the project record. An invoice arrives and no-one can remember exactly what was agreed. These aren’t catastrophic individually, but they accumulate into a management tax that slows everything down.
The Bottom Line
Subcontractors are one of the most effective levers a small agency has for growing capability without growing headcount. But the flexibility they offer only translates into business advantage if the management layer is solid. A contractor who delivers great work invisibly — no updates, no logged time, no integration into your project — creates almost as many problems as one who delivers late. Visibility is what lets you catch issues early, protect your margin, and keep your client relationship intact.
Get the commercial foundations right: written agreements, IP assignment, clear payment terms. Invest in proper onboarding rather than throwing a brief over the fence. Integrate their work into your project tool so it’s visible alongside your internal team’s. Track costs in real time rather than at invoice. Review quality against defined criteria, not vibes.
Done well, subcontracting is how a ten-person agency competes with a thirty-person one. Done badly, it’s a slow drain on margin and quality that’s hard to diagnose until the damage is already done. The difference is almost entirely down to systems — and systems are something you can fix.