How to choose between internal team and tech agency for your project?

Internal team or tech agency (ESN)? The real question is not "which is better" but "which matches your engineering capacity need, your horizon and your level of steering". Hiring internally maximises technical ownership and domain knowledge, but costs 6–9 months per role and locks in payroll. A tech agency brings capacity fast, but the classic model — a vendor steering from a distance — often dilutes delivery quality. In between, hybrid models (staff augmentation, dedicated team) combine external speed with internal control. This guide compares the three options with numbers and criteria.

Key takeaways

• Hiring a senior developer in Switzerland takes 6–9 months and costs CHF 25–30k before day one (recruitment, onboarding, mis-hire risk).
• The classic fixed-price agency model fits closed, non-strategic scopes; once the subject touches your product or software architecture, decision distance becomes a risk.
• Hybrid models — staff augmentation and the dedicated team — keep the roadmap, the code and technical ownership on your side.
• The right metric is not the daily rate but the total cost of capacity: recruitment + payroll + turnover internally; rework, re-scoping and debt with the wrong vendor.

What an internal team does better

An internal team is unbeatable on three fronts. Domain knowledge: your engineers understand the context, the history of decisions and the strategic stakes without briefing. Technical ownership: the code, the software architecture and the structural choices are carried by people who will still be there in three years. Capitalisation: every project compounds know-how that stays in the company.

The flip side is cost and latency. In Switzerland a senior developer represents CHF 130–160k in annual employer cost, a multi-month hiring cycle, and a real risk: if the profile doesn't fit, you start over. And when the roadmap dips, the capacity stays. Our analysis of the recruitment trap details this mechanism.

What an agency does better

A tech agency brings what internal hiring cannot produce quickly: senior engineers available now, hard-to-hire expertise (data engineering, AI, complex integrations), and elastic engineering capacity that scales with the roadmap. On a well-scoped perimeter with a firm deadline, an experienced team ships faster than a team still being built.

The limit of the classic model is structural: when the vendor runs its own process at a distance, you buy an outcome without controlling how it is made. While the scope stays closed, it works. Once it drifts toward the core of your product, decision distance is paid in rework, technical debt and eroding delivery quality. Our staff augmentation vs outsourcing comparison dissects exactly that tipping point.

Internal vs agency vs hybrid: the comparison

The real math: total cost of capacity

Comparing a salary with a daily rate is the classic trap. The right calculation includes, internally: 15–20% of package in recruitment costs, 2–3 months of ramp-up, employer charges, and the cost of turnover (one senior departure = six months of lost context). Vendor-side: the rate, plus the cost of rework when delivery quality falls short, plus the technical debt left behind when your software architecture wasn't respected. That full cost — not the sticker rate — is what separates the models. Our guide to custom development costs gives the orders of magnitude.

The hybrid model: external capacity, internal steering

For most tech teams that already steer internally, the best control/speed ratio is hybrid: an internal core that owns product vision and architecture, reinforced by senior external engineers embedded in your rituals — your repositories, your code reviews, your definition of done. You keep technical ownership; you add engineering capacity that ships in the first week.

At PULSE this model comes in two shapes: IT staff augmentation to add one or more precise profiles under your management, and the dedicated team to entrust a durable perimeter to a stable unit that builds context. To choose between them — and to know when neither fits — our tech team augmentation guide compares the models, their usage signals and their governance.

In practice, this is the model behind projects like Life CPM (healthcare business platform, stable long-run unit) and FlySpa (product built then operated with a dedicated team): the client keeps the roadmap, PULSE brings the senior engineers and the continuity.

How to decide in practice

• The need is permanent and core (main product, structural role) → hire internally, bridging the wait with temporary reinforcement if needed.
• The need is a peak, a rare skill or a fluctuating roadmap → embedded senior reinforcement, under your steering.
• The need is a continuous flow on a delegable perimeter → dedicated team with shared governance.
• The scope is closed, non-strategic, with a hard deadline → fixed price (classic agency or a turnkey project with an accountable delivery owner) remains relevant.

The five criteria that should decide

1. Criticality of the subject. The closer the perimeter is to the core of your product, the more steering must stay internal. You can delegate a brochure site; you don't delegate the architecture decisions of your business platform.

2. Horizon of the need. A permanent need justifies a hire; a 6–18 month need, embedded reinforcement; a bounded scope with a dated end, fixed price. The classic drama: treating a 9-month peak as a permanent role, then carrying the payroll once the peak has passed.

3. Your steering capacity. Augmentation assumes an internal tech lead actually steers. If nobody can hold that role, a dedicated team with shared governance — or a turnkey project with an accountable delivery owner — is more honest than augmentation left to itself.

4. Accessible seniority. The Swiss market is in durable shortage of senior profiles. The real alternative is often not "internal vs external" but "senior external available now vs junior internal available in six months". At equal delivery quality, seniority makes the difference, not the contractual status.

5. Reversibility. What happens if the context changes in six months? A healthy model unwinds cleanly: monthly adjustment in augmentation, organised knowledge transfer in a dedicated team. A badly chosen model leaves you a costly termination or a vendor who de facto owns your code.

Classic mistakes (and how to avoid them)

• Comparing a daily rate with a gross salary — compare full annual costs, including charges, recruitment and turnover.
• Choosing an agency on price — a low rate with juniors billed as seniors costs more in supervision and technical debt than the price gap suggests. Our analysis of the real cost of technical debt puts numbers on that mechanism.
• Delegating the core without keeping ownership — require that the code, the repositories and the CI/CD stay yours from day one, whatever the model.
• Stacking externals without a frame — without shared standards and common reviews, the software architecture fragments. Reinforcement must enter your rituals, not create a parallel circuit.

FAQ

Is an agency cheaper than hiring?

Over 12 months at equal seniority, full costs are often close. The difference lies elsewhere: an agency turns a fixed cost into a variable one, removes hiring risk and starts in days rather than months. Internal wins over the very long run, when the role is genuinely permanent.

How do you keep control with externals?

By choosing a model where engineers work in your tools and report to your tech lead — not to an intermediary project manager. That is the difference between embedded augmentation and remotely-steered fixed price: in the former, technical ownership and delivery quality stay measurable on your side.

Doesn't hybrid create a two-speed team?

Not if integration is real: same rituals, same code reviews, same standards for everyone. The risk to watch is not status (internal/external) but seniority: a junior reinforcement creates supervision load, a senior raises the team's level.

When should you avoid the classic agency model?

When the subject touches the core of your product or your software architecture and the need will evolve. A fixed price frozen on a moving scope mechanically produces change orders, rework and debt. On those subjects, keep the steering and bring the capacity in-house.

Still weighing hiring, reinforcing or delegating? Book a first call: 30 minutes to frame your context and leave with a reasoned recommendation.