Short Answer
For a 10-50-person, tech-driven agency, build software only when it powers visible, revenue-raising differentiation and you can fund ongoing maintenance; otherwise buy mature SaaS. Use a 7-question scorecard (client impact, IP need, talent, budget, urgency, data sensitivity, strategic risk) to decide, then follow a 30-60-90-day roadmap: audit, prototype, commit.
The crossroads
Running a tech-enabled agency with forty people feels a bit like steering a speedboat in container-ship waters. Clients expect real-time dashboards, AI-flavoured insights and the polish of a product company—yet your margin depends on keeping head-count light. Sooner or later the question lands on your desk:
Do we build our own tool—or pay another subscription and move on?
For many firms the issue raises an additional question: Should we hire a developer at all, or squeeze more value out of the software aisle?
Let’s unpack the choice in plain language. No jargon. No hollow buzzwords. Just a path you can walk on Monday.
First things first: do you even need an engineer?
Picture tomorrow morning. A full-time developer logs in to Slack. What would you ask her to tackle before lunch? If nothing obvious flies to mind, you may not be ready. Custom software rewards clarity; it punishes boredom.
There are, however, tell-tale signs that a real engineer—not another low-code connector—belongs on payroll:
- Your clients pay for your proprietary process. A bidding algorithm, a forecasting model, a content classifier—anything that makes prospects say “Only they can do this”—deserves to be proprietary, not bolted together from public APIs.
- Repetition is eating billable time. When senior staff download the same CSV every Thursday, the hourly burn sneaks onto your P&L. Automation pays back shockingly fast.
- Compliance has teeth. Healthcare, finance or EU privacy rules often demand workflows that generic platforms bend but never fit.
- Integration walls keep appearing. If you have Zapier flows so tangled they need their own mind-map, you’ve hit the limit of glue code.
If none of that rings true, stick with SaaS for now. Close the dozen browser tabs with job ads and spend a quarter mapping processes instead.
Value chain vs supporting functions—focus your firepower
Custom code is expensive. The way to keep it honest is the value chain vs supporting functions lens.
Value chain work is client-visible and price-sensitive. When it improves, clients notice—and they pay more or stay longer.
Supporting functions are the plumbing. It must run, but nobody picks a supplier because the invoice PDF looks pretty.
Spend one white-board session listing every recurring activity in your firm. For each step ask, Would a client pay extra if this were brilliant? Everything that earns a “yes” is value chain. Everything else belongs to reliable off-the-shelf software.
A surprising amount of friction disappears when leadership agrees on that line. Scope shrinks, budgets smile and developers know exactly why their sprint matters.
The silent cost ledger
Hiring or contracting developers
A mid-level engineer in the US costs $100k–150k, inWestern Europe roughly €70–90 k a year. Add recruitment time, onboarding, cloud infrastructure, observability tools and, most slippery of all, maintenance.
Bugs, version bumps and feature requests account for ten to twenty percent of the original build effort—every single release cycle. Opportunity cost lurks too: your best coder can’t invoice client hours if she’s untangling internal tests.
Staying SaaS-first
Licenses often start at pocket-change levels, then scale with user counts or API calls. Implementation still swallows project-management time, and every new login is another point of failure come audit week.
Yet you inherit mature security, instant uptime and a vendor whose roadmap marches forward without your payroll.
Speed now, pain later?
Speed Now, Pay Later — Prototype vs Production
The temptation is real: spin up a quick Zapier chain, stitch two APIs with Make, drop the result in a Google Sheet, and call it “done.” In the moment it feels like a masterstroke—clients see new functionality within hours, your team high-fives, and the backlog looks lighter.
But speed has a half-life.
Quick-and-dirty automation
- Fragile by design. One changed field or throttled endpoint and the magic breaks—usually on a Friday afternoon.
- Invisible complexity. People forget the five hidden filter steps or that the webhook lives in someone’s personal account.
- No observability. When a zap fails silently, you notice only after a client points out missing data.
These scrappy fixes are perfect for proving value: testing whether clients actually open a dashboard, or validating a new pricing model. Treat them like disposable prototypes. Time-box them, label them clearly in Asana, and schedule a revisit date.
A proper software build—whether in-house or via a trusted vendor—adds the unglamorous plumbing that keeps you out of weekend firefights:
- Version control & peer review. Every change lives in Git, visible and reversible.
- Environment parity. Dev, staging, and production mirrors prevent “works-on-my-machine” surprises.
- Logging, alerts, and tests. When something misbehaves, your team gets a Slack ping instead of a support ticket.
- Documentation & ownership. A lightweight README and an architecture diagram ensure new hires ramp in hours, not weeks.
- Vendor best practices. For SaaS components, insist on a published changelog, sandbox environment, and a roadmap call at least twice a year.
Rule of thumb: sprint fast, but formalise anything that survives beyond a quarter. Prototypes buy insight; production systems earn trust—and trust scales far better than duct tape.
Talent strategy without the headache
Developer scarcity is real, but options exist:
- Fractional leadership. A CTO one day a week can architect a roadmap, vet vendors and mentor juniors without triggering a full-time salary.
- Near-shore sprint pods. Eastern Europe, Latin America, Southeast Asia—all teeming with boutique shops fluent in agile rituals. Contract them for a twelve-week push, not forever.
- Citizen development. Equip operations staff with Make, Zapier or n8n. Senior engineers then focus on the hairy integrations, not the forms.
The golden rule: reserve your rarest talent for Value chain logic; let automation or external partners handle Supporting functions.
Managing risk before it manages you
Lock-in lives on both sides. A niche SaaS may shutter; a home-grown tool may stagnate if its author leaves. Hedge with open APIs, export clauses and quarterly dataset snapshots.
Security & compliance tilt decisions too. If you store health or financial records, buying a SOC-2-certified platform often costs less than building your own audit trail.
For custom apps, earmark at least ten percent of the budget for hardening and penetration tests.
Lastly, watch for hero-developer syndrome. If a single engineer holds the mental model, your business is one resignation away from crisis. Enforce code review. Share diagrams. Celebrate transferred knowledge, not individual genius.
A five-minute litmus test
When time is tight, answer these seven prompts with a simple yes or no:
- Will this feature clearly raise client value or retention?
- Must we own the intellectual property for the next 18 months or more?
- Do we have reliable capacity to maintain it?
- Is the data involved legally sensitive?
- Will the opportunity vanish inside six months if we wait?
- Can we allocate at least €50 k this fiscal year?
- Would failure here threaten our strategic plan?
How did you answer?
Zero to two yes answers? Keep shopping the SaaS aisle.
Three to five? Blend approaches—contract specialist help for the Value chain slice and license proven tools for the rest.
Six or seven? Build, and plan for the staffing to match.
Hybrid blueprints that actually work
Most success stories share a rhythm: buy the spine, build the fingertips. Stable back-office functions come from seasoned vendors. The client-facing flourish—the bit that makes prospects lean forward—gets bespoke love.
Here are some examples:
In Berlin, a twenty-person UX studio chose ClickUp for project management yet hired a two-month React contractor to craft a proposal generator. Quote preparation fell from two hours to twenty minutes.
In Austin, TX, a forty-head managed-IT provider retained their custom monitoring scripts—true differentiation—while migrating ticketing and billing to HaloPSA. Finance week now ends on Wednesday.
In Manila, a fifteen-person content agency resisted the itch to recruit. They replaced creaky Python crons with Make and Zapier and gave their lone developer free time to explore GPT-powered content ideas.
Each firm invested developer effort exactly where clients could feel it and let SaaS shoulder everything invisible.
Your 30-60-90-day runway
If you want to make the build vs. buy decision for your tech-driven agency, here’s a 90 day plan to succeed:
Days 0-30—Audit. Map every tool, licence fee and manual workaround. Run the Value chain-vs-Supporting functions exercise. Score potential projects with the seven-question test.
Days 31-60—Experiment. Prototype one high-impact Value chain feature—either in low-code or via a sprint team. At the same time trial two SaaS contenders. Track real numbers: hours saved, errors avoided, subscription quotes.
Days 61-90—Commit. Sum up your results and have an honest look. Decide on a build-buy-hybrid path, lock the budget and schedule regular reviews. Good governance is what keeps a smart decision from decaying into an expensive relic.
The conclusion
Custom software is leverage when it deepens client value and you can feed it the talent it needs.
Everything else is commodity infrastructure. So build the edge that wins business; buy the plumbing that quietly carries water.
If you’d like another set of eyes before hiring a developer or signing the next contract, book a short Ops-Tech Audit with me. Thirty minutes, zero fluff, clear next steps. Either way you’ll walk away knowing exactly which fork in the road to take.
See you there,
Benjamin
Fractional COO, Asamby Consulting