Situations · IP protection
Outsourced development places your source code on an agency’s laptops, repositories and build systems, where it commonly persists after the engagement despite deletion clauses. The stronger model locks the genuinely proprietary modules so external developers build against them without ever holding a readable copy; there is nothing to chase back later.
The contract says the agency works on your codebase. The reality is more distributed than that sentence implies.
It is cloned onto every developer’s laptop, including the contractor they brought in for two months. It is in their CI system and their build cache. It is in a branch on their own Git host, because that is where their workflow lives. It is in the local environment of a developer who left the agency in March.
None of that is a breach. It is what building software looks like.
When the engagement ends, the agreement requires them to delete your code and confirm they have done so.
They will delete the repositories they administer. They cannot meaningfully address laptops belonging to people who have moved on, backups of their build infrastructure, or the personal clone a developer made to debug something at home.
The confirmation arrives, it gets filed, and the situation is exactly as it was before it arrived.
Here is what makes this tractable. The overwhelming majority of any codebase is not sensitive. Routing, forms, validation, logging, the admin screens: an agency holding those forever costs you nothing, because they are much the same everywhere.
What matters is a small, findable portion. The pricing logic. The matching engine. The scoring model. The thing you would genuinely not want to see inside a competitor’s product.
That is usually a few percent of the repository, and protecting only that is the difference between an impractical idea and one that ships.
The proprietary modules stay locked, including during the engagement. External developers call them, build against them, run the full application, and ship releases that include them.
What they never hold is a readable copy. The code they call back behaves exactly as expected, so day-to-day work is unaffected and nobody spends their time fighting the protection.
When the engagement ends there is nothing to chase, because the part worth chasing never left. The deletion clause becomes a formality about code whose loss does not matter.
Most companies that hesitate to use outside engineering are not worried about quality. They are worried about handing a complete copy of the product to a firm that also works for other people in their industry.
Taking that off the table means you can use external capacity where it makes sense and keep the crown jewels regardless of who is in the repository this quarter.
The parts of the codebase that are genuinely yours stay locked, even inside the engagement. The outside team builds against them and ships with them, without ever holding a readable copy. When the engagement ends, there is nothing to chase back, because the crown jewels never left.
access ended
IP protection. Start where the problem actually is.