Source code ownership determines who holds the rights to the code of the software being built, and who can use, modify and copy that code. Paying for software doesn't necessarily mean the rights to its code automatically pass to you, so the transfer of rights and the delivery of the code should be spelled out clearly in writing in the contract. This post isn't legal advice; it covers the key points product owners should know before signing.
Why does source code ownership matter so much?
If the rights to the source code aren't yours, or the code isn't in your hands:
- You may not be able to hand the software over when you want to work with a different team,
- You stay dependent on a single firm to develop or change the software,
- Your rights to the asset at the core of your product can be called into question during a valuation or fundraising,
- If the development firm shuts down, your software may be left without maintenance.
Especially when the software itself is your product, source code ownership is a decision about one of your company's most important assets.
The legal status of software in Turkey
In Turkey, computer programs are protected as works under Law No. 5846 on Intellectual and Artistic Works. Under this framework, the author's economic rights (such as reproduction, adaptation and distribution) can be transferred by contract or licensed for use. Contracts transferring economic rights must be in writing, and the rights being transferred must be listed individually. Other countries have their own rules, but the principle that a transfer should be explicit and written applies broadly.
In practice, this means a general phrase like "the software will be delivered to you" may not be enough. The contract should clearly state which rights are transferred, to what extent, whether for a limited time or indefinitely and whether exclusively. We recommend getting help from a legal advisor when you draft or review your contract.
Assignment or license?
Contracts generally take one of two approaches:
- Assignment of rights: The economic rights to code written specifically for your project are transferred to you. You can use the code as you wish, change it and keep developing it with other teams.
- License to use: The code stays with the developer, and you get the right to use it under certain conditions. This is common when you use an existing product under your own brand.
For software built specifically for a project, an assignment of rights is usually expected. But for general tools and libraries the developer uses across many projects (for example, an admin panel framework they built themselves), giving you a perpetual, irrevocable license to use them is a reasonable compromise. What matters is that the contract clearly states which part has which status.
Open-source components
Almost every modern piece of software is built on open-source libraries. These libraries belong to their own developers, not to you, and they're used under their own licenses. That's normal, but a few points deserve attention:
- Permissive licenses (such as MIT, Apache 2.0 and BSD) usually place few restrictions on commercial use; they mostly require you to keep the license text and copyright notice.
- Copyleft licenses (such as the GPL family) may, under certain conditions, require you to share the source code of software you distribute together with that code under the same license. Their effect depends on how you distribute the software, so they need careful evaluation.
It's good practice to have the contract require delivery of a list of the open-source components used, along with their licenses.
Code delivery: as important as the rights
Even if the rights are yours, they're useless in practice if you don't have the code. Make sure these are clear:
- Code repository: The safest approach is for the code to be developed from day one in a repository under your account (for example, in an organization your company owns on GitHub or GitLab). That way there's no separate handover at the end, and you hold the full change history.
- Buildable, runnable delivery: Along with the code, you should receive setup and deployment instructions, a list of required environment variables and the database schema.
- Documentation: A short document covering the core architecture, integrations and key decisions.
- Design files: Interface design files and visual assets.
Account and infrastructure ownership
Just as important as the code is ownership of the infrastructure the software runs on:
- The domain name should be registered to your company.
- Hosting, database, email service, payment provider and other service accounts should be opened in your company's name or be transferable to your company.
- Developer accounts on mobile app stores and the Chrome Web Store should belong to your company.
- The development team can be given the permissions it needs on these accounts, but admin access should stay with you.
Taking over an app that was published under a developer's personal account can be a hassle later, so it's easier to set up the accounts correctly from the start.
Contract checklist
Before signing, check that the contract includes these points:
- The assignment of economic rights to code built specifically for the project, and its scope, is in writing.
- It states at what stage the transfer takes place (for example, upon full payment).
- The terms of the license you receive for the developer's pre-existing tools are in writing.
- Delivery of the list of open-source components and their licenses is committed to.
- It states that the code will be developed in, or delivered to, a repository under your account.
- Delivery of setup documentation, design files and the database schema is defined.
- Ownership of the domain name and service accounts is clear.
- Obligations on confidentiality and personal data protection are in writing.
- The terms for delivering the work and code completed so far in case of termination are set out.
The handover process when you switch teams
One day you may need to hand maintenance of the software to a different team. For that handover to go smoothly, these things matter:
- A list of access: A list of the code repository, servers, database, domain and all third-party service accounts, plus confirmation that you hold admin access to each.
- A working setup: The new team should be able to run the application on their own machines by following the documentation. That's the best test of whether the handover docs are good enough.
- Open work and known issues: A list of work in progress, known bugs and postponed improvements.
- A transition period: If possible, the previous team answers questions for a short while.
- Rotating secrets: Rotating API keys and passwords after the handover ensures that people who shouldn't have access can't get into the system.
Adding a clause to the contract committing both sides to cooperate on these steps in case of termination or handover reduces friction later on. Software with a well-managed handover can keep running and evolving even when the team changes. That's why the easiest path is to keep the handover documentation current throughout the project, not just at the point of parting ways; reviewing the setup notes and access list after each significant change is enough.
Conclusion
Source code ownership is as important in a software project as price and timeline. The transfer of rights should be explicit and in writing, the code should be developed in your repository from the start and infrastructure accounts should be opened in your name. These three steps strengthen your hand whenever you want to switch teams, raise investment or grow the software. At Weras Labs, the status of project-specific code and accounts is stated clearly in our written proposal; you can see how we work on our services page. For the legal aspects of your contract, we recommend consulting a legal advisor.
From Weras Labs
We can help you with this
We turn what you just read into working software for your business. You talk to the person writing the code; price and timeline are clear from day one.
Frequently asked questions
Does paying for software mean its source code belongs to me?
Not automatically. The transfer of economic rights needs to be set out clearly in writing in the contract; otherwise, you may only have a right to use it.
Is using open-source libraries a problem?
Usually not; nearly all modern software uses open-source components. But the license terms must be followed, and some copyleft licenses can bring extra obligations depending on how the software is distributed.
Why does it matter that the code repository is under my account?
If the code is developed in your repository from the start, you don't have to wait for a separate handover at the end, and you own the entire change history. Switching teams also becomes much easier.
Is it acceptable for the developer to use their own framework?
It can be, but it's important that you receive a perpetual, irrevocable license to use those parts and that the contract clearly states which parts have that status.
About the author

Habip Dayan
Founder of Weras Labs
Habip Dayan is the founder of Weras Labs, a company that builds software products for professionals and teams. He has been building software since 2018 and writes about AI, cloud architecture and product design.
Comments
Be respectful; no ads or personal data. Comments that break the rules are removed.




