Outsourcing, in-house team or freelancer: what actually differs
All three models aim at the same outcome, working software, but they are built differently. An in-house developer is part of your company: knows the product from the inside, is around every day, and costs money even in weeks with nothing to build. A freelancer takes a defined task and owns it personally; flexible, but all the responsibility and all the capacity sit with one person. An agency or vendor team sells an outcome and runs the work around it: design, development, testing, release.
The choice is not about cheap versus expensive. It is about where your work is ongoing and where it is one-off, and who has to understand the product deeply. We cover picking a specific vendor separately in how to choose a development studio, and how to pay one in development payment models. This article is about choosing the model itself.
When to outsource and when to hire in-house
Outsourcing wins when the work has clear edges: a first version of a product, an integration, a bot, a data migration. Hiring wins when the product lives for years, changes weekly and needs decisions made on the spot.
A simple rule: if you can describe the outcome in one sentence and verify it by hand, it is a job for a vendor. If the outcome is "keep improving the product", that is a team function and sooner or later you will build it in-house.
- Outsource: you need a first version or an MVP and have no developers on staff.
- Outsource: a one-off integration between systems, a bot, a scraper, a data migration.
- Outsource: you need expertise you don't have and won't need full time, such as a specific stack or a tricky integration.
- Hire: the product is your core asset and something in it changes every week.
- Hire: requirements are unclear and decisions get made daily in conversation with the developer.
- Mixed: a vendor builds and launches the first version, then maintenance moves to an in-house person or stays with the vendor under a support agreement.
What to hand to a vendor and what to keep
People err in both directions. Hand over everything, including product decisions, and you get software that is well built but solves the wrong problem. Keep everything, and outsourcing loses its point: the vendor waits for answers while you dig into details you are paying someone else to handle.
The split is simple. The vendor owns the "how": architecture, code, tests, deployment, monitoring. You keep the "what and why": which features come first, what counts as done, and which numbers show the product works. If you are unsure about scope, start by defining the boundaries of the MVP; it makes clear what to order in the first place.
- Hand over: technology choices and architecture, writing and testing code, environments, deployment, backups, monitoring.
- Keep: feature priorities, acceptance of the result, conversations with your users, the budget and the launch decision.
- Keep, technically: the domain, the cloud and payment accounts, the repository and the access to them, not just the finished product.
- Name one person on your side who answers the vendor's questions within a working day. Most time in outsourcing is lost waiting for answers.
Risk 1: the vendor owns your access and infrastructure
The most common problem: the server runs under the vendor's account, the domain is registered to their email, the code sits in their personal repository. While things go well, nobody notices. When the relationship ends, the product works but you can't manage it.
Fix this on day one, not at the end. Create the accounts under your name and add the vendor as a member with the permissions they need. Then any of their access can be revoked in a minute, and you always have full control.
- The domain, DNS and cloud account belong to your company or to you personally.
- The code repository lives in your organization and the vendor works in it by invitation.
- Secrets and keys (payment provider, email, Telegram bot) are created on your accounts and kept in a secrets manager, not in chat messages.
- You have at least one way into the server and the database without the vendor.
- Review the list of people with access every quarter and remove the ones who no longer need it.
Risk 2: who owns the code
Code written by a vendor does not automatically belong to you. Who holds the rights depends on the contract and on the law where you operate, so the point has to be spelled out in writing and reviewed by a lawyer rather than left to a verbal agreement.
What to look at: whether the rights to the result transfer in full after payment, how the contract treats third-party libraries (they have their own licenses and a vendor cannot "hand them over" as their own), and what happens to the vendor's pre-existing components used in your project.
- The contract states exactly what is handed over and when: source code, documentation, access, deployment scripts.
- Third-party libraries carry licenses that allow commercial use, and the vendor can list the dependencies.
- Any pre-existing vendor components are listed, with clear terms for how you may keep using them.
- Termination terms: what you receive at the moment work stops, and how that is paid for.
Risk 3: depending on a single person
Even with the right access and rights you can end up stuck if understanding of the system lives in one person's head. They get sick, go on holiday or change jobs, and you cannot make even a small change.
The protection here is engineering, not paperwork. Another developer should be able to take over in reasonable time: the code is readable, startup is documented, the environment can be reproduced and the main flows are covered by checks. This is cheap if done from the start and expensive if postponed. How technical debt builds up in a first version and how to pay it down is covered in MVP technical debt.
- A short document explains how to run the project locally, how to release a new version and how to roll back.
- Configuration lives outside the code and the environment can be recreated with one command or script.
- The main flows are tested automatically, so a new developer can change things and see whether anything broke.
- The commit history is readable: it is clear what changed and why.
- Every few months, ask the vendor to show that the project builds and starts from scratch.
After launch: support and switching vendors
Launch is not the end of the work. Someone has to watch availability, update dependencies and fix the bugs that only real users find. Decide in advance who does it, how fast they respond and how it is paid for. The minimum worth agreeing on is described in support and monitoring after launch.
If you are unhappy with a vendor, switching is undramatic when access is yours, rights are documented and the project is readable. A new team then needs only the repository and the notes. Without these, switching becomes a rewrite, which is exactly why the safeguards belong at the beginning and not after something goes wrong.
How to start with an outsourced team without losing control
Start with a small, bounded stage rather than a large project in one go. The result of the first stage shows how the vendor communicates, how they write code, how quickly they answer and how comfortable it is to work with them. It is a cheap test before the big spend.
Agree on a rhythm: short regular demos of working software, a shared task tracker and repository access from day one. If a vendor will not show interim results or will not give access to the code, take that as a signal right away.
- The first stage has limited scope and ends with working software you can verify.
- Regular demos on a running version, not slide decks and status reports.
- A shared task tracker that shows what is done and what is next.
- Acceptance against criteria written down in advance, not by feel.
- Communication channel and response times agreed up front.