Sooner or later every company faces the question: who is going to build the website, the app or the internal tool? You can hire developers in-house, find freelancers, hand the project to a web development agency or take on a dedicated team from a vendor. Each option has its own economics, and "cheaper" at the start doesn't always mean "cheaper" a year later.
We are a development agency ourselves, and we often see both sides: companies that came to us after a hiring attempt went wrong, and companies that have reached the point where they should grow their own team. Below is an honest look at how software development outsourcing works, when an in-house team pays off, when a hybrid makes sense, and how to keep control of your code and knowledge in any model.
The models to choose from
"Outsourcing" often lumps together very different setups. Before weighing the benefits, it helps to separate them.
- In-house team. Developers on your payroll: you hire them, assign tasks and own the process.
- Freelancers. Individual specialists for specific tasks. Coordination, quality control and putting the whole project together are on you.
- Agency (project outsourcing). You order a result: a website, an app, a web service. The vendor is responsible for the team, process, deadlines and quality.
- Dedicated team. The vendor's specialists work on your product full time, while you set the tasks and priorities. Hiring, replacements and day-to-day logistics are on the vendor's side.
- Hybrid. A core in-house team plus an outside vendor for specific areas: design, a mobile app, integrations, peak workloads.
IT outsourcing in the broad sense also covers infrastructure management, but this article is specifically about development: websites, apps and web services.
The models side by side
A table won't replace running the numbers for your situation, but it helps you quickly rule out options that don't fit.
| When it fits | Main risk | |
|---|---|---|
| In-house team | The product is core to the business and evolves constantly | Slow hiring, paying the team during downtime |
| Freelancers | Small tasks with a clear brief | Dependence on one person, coordination falls on you |
| Agency | A project with a clear goal: website, app, service | Needs a point person on the client side |
| Dedicated team | Long-term product development without hiring | Needs your own product owner to set tasks |
| Hybrid | A core team exists but lacks some skills | Without shared rules, code drifts in style and quality |
An in-house development team: when it pays off
An in-house team gives you maximum control: developers are immersed in the business, knowledge stays inside, and priorities can change every day if needed. But this model has a cost that's often underestimated.
On top of salaries, you pay for hiring and onboarding, workspace, payroll taxes, vacation and sick leave, tools and training. You need someone who knows how to hire and evaluate developers, and a tech lead to set up the process: code review, testing, deployment. One developer is not a team: they'll still need a designer, an analyst and a QA engineer.
There's also a hidden cost: downtime. After the website launches, the workload drops, but the team stays on payroll. An in-house team pays off when there's always enough work for it, and the product is what the company earns money on every day.
Freelancers: fast, but it all rests on one person
A freelancer is a sensible choice for a landing page, updates to an existing website, or front-end work from a finished design. They start quickly and usually cost less than an agency.
Problems begin when there are several freelancers or the project is large. Someone has to brief them, review the work, and make design, front end, back end and integrations fit together. That role automatically falls to the client, even without the relevant experience. And if a key contributor disappears, the knowledge of how the project works often disappears with them.
An agency: outsourced development for a result
An agency takes on the whole job: from research and design to development, testing, launch and support. You don't have to assemble a team or set up a process; the vendor already has both. That's why outsourcing website, app or web service development to an agency is the usual choice for companies whose core business isn't software.
The main advantage is getting every role you need at once. A sales website needs an analyst, a designer, developers, a QA engineer and a project manager, and hiring all of them for one project doesn't pay. The downside is that the agency doesn't know your business the way you do. That's solved by a discovery phase at the start of the project and a point person on the client side who answers questions and makes decisions quickly.
This is exactly how we work at Sphere: first we get to know the client's business, market and audience, then we plan the product, design it, develop and test it, and after launch we support and grow it. As a digital agency in Paris, we handle end-to-end development, and our website and web service projects show how different tasks fit into this approach.
A dedicated team and the hybrid model
A dedicated team fits when the product needs long-term development, but you don't want to build your own staff yet or don't have time to. The vendor is responsible for the people and their replacement; you are responsible for what the team does. Without your own product manager or project lead, this model stalls: the team needs someone who knows the business priorities.
The hybrid is a common setup for companies that already have a couple of developers. Your people own the core product, while the agency takes on what you lack the skills or hands for internally: UX and design, a mobile app, an ERP integration, a new module on a deadline.
How to keep control of your code and knowledge
The biggest fear with outsourced development is becoming hostage to the vendor. That fear is justified only if you skip a few basics at the start. The same rules also protect you when a key employee leaves your own team.
- The code repository is created under your company's account, and the vendor works in it with access you grant.
- The domain, hosting, cloud services, app store accounts and analytics are registered to the company, not the contractor.
- The contract transfers the intellectual property rights to the code, design and copy upon payment.
- There's documentation: how to deploy the project, how the architecture works, what integrations exist and where settings are stored.
- Passwords and keys are kept in the company's shared password manager, not in chat threads.
- The project uses a widely adopted stack or CMS, not the vendor's proprietary platform.
- Tasks and decisions are tracked in an issue tracker, not just in chats and calls.
With all of this in place, switching vendors or moving to an in-house team becomes a routine process, not a disaster. Code and access should belong to the company, not the contractor, whatever model you work in.
A good vendor doesn't keep clients by holding their access. It keeps them with the quality of its work.
Project knowledge is laid down before development even starts. A detailed specification and process description will serve any team that comes next, in-house or external.
How to choose: a short checklist
- Define the type of work. A project with a clear deliverable, or ongoing product development with no end date.
- Estimate the workload. Will there be enough tasks to keep your own developers fully busy six months after launch?
- Check your internal expertise. Is there someone who can hire developers, brief them and sign off on their work?
- Calculate the full cost. For staff, include hiring, taxes, downtime and management; for a vendor, include post-launch support.
- Start with the lower risk. It often makes sense to launch the product with an agency and build your own team once the volume of ongoing work is clear.
Many companies go through every model in turn: an agency builds the website or service, then supports and grows it, and over time part of the work moves to in-house developers. That's a healthy path, as long as the code, access and documentation stay with the company from day one. You can read how we work at each stage on the About Sphere page.
FAQ
Which is cheaper: outsourcing development or an in-house team?
It depends on the scope and duration of the work. For a project with a clear start and finish, outsourcing is usually more cost-effective: you pay for the result and avoid the costs of hiring, office space and downtime between tasks. If the product evolves every day for years and keeps several developers fully busy, an in-house team can become cheaper over time. Compare the total cost, not a developer's salary against a vendor's invoice.
How is a dedicated team different from a regular agency project?
With a project engagement, the agency is responsible for the result within an agreed scope, timeline and budget. A dedicated team is a group of the vendor's specialists who work on your product full time, while you set the priorities and tasks. The first model fits when the work can be defined up front; the second fits when the product evolves continuously and requirements keep changing.
How do we keep control of our code when working with a vendor?
The repository, domain, hosting, cloud accounts and analytics should be registered to your company, with the vendor given access. Your contract should transfer the intellectual property rights to the code and design upon payment, and the scope should include documentation: how to deploy the project, how the architecture works, what integrations exist. Then any team can pick the project up.
Can we combine an in-house team with an agency?
Yes, it's a common setup that works well. For example, your own product manager and a couple of developers own the core product, while the agency takes on UX, design, a new module or a mobile app. The key is to agree on shared rules: one repository, code review, and conventions for code style and documentation.
Does outsourcing make sense for a small business?
In most cases, yes. A small company rarely needs a permanent development staff: the website or service is built once, and after that it needs maintenance and occasional updates. That workload is easier and cheaper to hand to an agency or a trusted vendor than to keep people on staff who will be idle half the time.




