Outsourcing software development is extremely common among startups. A founder may have a strong business idea but no technical co-founder, so the startup hires a freelance developer or software agency to build the first version of its mobile application, SaaS platform, marketplace, artificial intelligence product or e-commerce infrastructure.

The startup pays the development fee, receives the application and begins operating the business.

Several years later, an investor asks a simple question during legal due diligence:

“Who owns the copyright in the software?”

The founders may respond:

“We do. We paid the freelancer to develop it.”

Under Turkish copyright law, however, paying a freelancer to create software does not automatically mean that all copyrights in the software transfer to the startup.

This distinction can become one of the most serious intellectual property risks facing a technology company.

The Turkish Ministry of Culture and Tourism expressly explains that the author of a computer program or database is generally the person or persons who write the source code. Where software is commissioned from an independent person or entity for payment, the customer does not become the author merely because it paid for development; the economic rights are instead exercised according to the written contractual arrangement.

Therefore, a startup that hires a freelancer should never rely solely on:

• an invoice,
• proof of payment,
• a WhatsApp conversation,
• delivery of a ZIP file,
• access to GitHub,
• or possession of the source code

as evidence that all intellectual property rights have transferred.

A properly drafted software development and copyright assignment agreement is usually essential.

This article explains who owns software developed by freelancers in Turkey, how economic copyrights may be transferred to a startup, which rights must be specifically identified, how future software developments should be handled and what founders should check before investment or acquisition due diligence.

Are Computer Programs Protected by Copyright in Turkey?

Yes.

Under Law No. 5846 on Intellectual and Artistic Works, computer programs expressed in any form and qualifying preparatory designs that lead to the creation of a computer program may receive copyright protection as literary and scientific works.

The law also recognises adaptations, arrangements and modifications of computer programs as potentially protected derivative works.

However, the ideas and principles underlying a computer program are not themselves protected merely because they are used in the software.

This distinction is important.

For example, the general idea of developing:

“an application that connects restaurants with customers”

cannot normally be monopolised through copyright.

However, the specific source code written to create the application may qualify for copyright protection.

The same may apply to qualifying:

• software modules,
• interfaces,
• database structures,
• technical documentation,
• original graphics,
• product texts,
• and preparatory software designs.

For a technology startup, the source code may therefore represent one of the company’s most valuable intellectual property assets.

Who Is the Author of Software Written by a Freelancer?

The general rule under Turkish copyright law is that the author is the person who creates the work.

For computer software, this usually means the individual or individuals who actually wrote the source code.

The Ministry of Culture and Tourism confirms this approach in its copyright guidance and specifically states that where a computer program has been commissioned for payment, the person paying for the development does not become the author merely because the development fee was paid.

Consider the following example.

Startup A hires Freelancer X.

Freelancer X develops a mobile application for TRY 500,000.

Startup A pays the entire development fee.

Freelancer X delivers the application.

The person who actually created the qualifying source code may still be the author for copyright purposes.

The crucial question is then:

Which economic rights has Freelancer X transferred or licensed to Startup A?

That question must be answered primarily from the written agreement.

Freelancer and Employee Software Are Legally Different

This distinction is especially important because Turkish law contains a specific provision concerning works created by employees.

Article 18 of Law No. 5846 provides, unless otherwise agreed or required by the nature of the work, that rights over works created by civil servants, employees and workers while performing their duties are exercised by the persons or organisations employing them.

Therefore, where a full-time software engineer develops code specifically while performing assigned employment duties, the employer may rely on the special statutory rule in Article 18.

A freelancer is different.

A genuine independent contractor is not automatically treated as an employee merely because the startup:

• gives instructions,
• pays development fees,
• determines milestones,
• or expects delivery by a deadline.

Consequently, a startup should not assume that the Article 18 employee rule automatically applies to freelance software development.

This is why a written copyright arrangement is even more important when software is outsourced.

Does Paying the Freelancer Transfer the Copyright?

No, payment alone should not be treated as transferring copyright.

Suppose a startup pays a developer EUR 50,000 for an application.

The parties agree on:

• features,
• delivery date,
• payment schedule,
• bug fixes,
• and technical support.

But the contract says nothing about copyright.

The startup may receive the software and have practical permission to use it, but the scope of its intellectual property rights may become disputed.

Did the freelancer transfer all economic rights?

Did the freelancer merely grant permission to use the software?

Can the startup modify it?

Can the startup sell the software?

Can it sublicense the software?

Can it integrate it into another product?

Can it commercialise the software internationally?

Can the freelancer sell the same code to another customer?

If the agreement does not answer these questions, the startup may face substantial legal uncertainty.

Source-Code Delivery Does Not Automatically Transfer Copyright

This principle is equally important.

The freelancer may deliver:

• the complete Git repository,
• source-code files,
• object code,
• database scripts,
• documentation,
• passwords,
• and server credentials.

This gives the startup possession or control of the relevant digital materials.

It does not necessarily mean that the economic copyright rights have been transferred.

Article 57 of Law No. 5846 reflects the broader principle that transferring ownership of an original or reproduced copy does not, unless otherwise agreed, automatically transfer the intellectual property rights attached to the work.

In software terms, receiving the source-code files and receiving the copyright are therefore different legal events.

A startup should obtain both:

1. technical possession and control of the software, and
2. legally sufficient rights to exploit the software commercially.

Which Copyrights Matter for Software?

Turkish copyright law distinguishes several economic rights.

For software businesses, the most important commonly include:

• adaptation right,
• reproduction right,
• distribution right,
• performance right,
• and communication to the public.

The Ministry of Culture and Tourism identifies these as principal economic rights under the copyright legislation.

Each can affect how a startup commercialises its technology.

Adaptation Right

The adaptation right is especially important for software.

A startup typically needs to:

• modify code,
• add new modules,
• rewrite functions,
• build new versions,
• localise the software,
• integrate APIs,
• correct vulnerabilities,
• create mobile versions,
• migrate architecture,
• and allow other developers to continue development.

Article 55 also provides that, unless otherwise agreed, transfer of an economic right or grant of a licence does not automatically extend to translations or other adaptations.

For software contracts, failing to regulate adaptation rights can therefore be particularly dangerous.

Reproduction Right

Software operation naturally involves forms of reproduction.

The company may need to:

• copy software onto servers,
• deploy new environments,
• create backups,
• provide client installations,
• duplicate code internally,
• or operate multiple cloud instances.

The startup should ensure that its contractual rights are broad enough for its actual technical architecture.

Distribution Right

Where software or physical copies are distributed, the distribution right may become relevant.

This may be especially important for:

• desktop applications,
• embedded software,
• enterprise installations,
• downloadable software,
• or products incorporating software.

Communication to the Public

Digital businesses frequently provide software or related materials through online platforms.

The relevant rights should therefore be broad enough to support the startup’s intended digital commercial model.

FSEK Article 52: Why the Written Agreement Is Critical

One of the most important provisions for freelancer software contracts is Article 52 of Law No. 5846.

Article 52 requires contracts and legal transactions concerning economic rights to be in writing, and the economic rights forming the subject of the transaction must be identified separately.

This rule has enormous practical importance.

A startup should be cautious about relying only on vague wording such as:

“All intellectual property rights belong to the customer.”

A stronger Turkish-law copyright provision should identify the relevant economic rights expressly.

Depending on the project, this may include the freelancer’s commitment to transfer the economic rights of:

• adaptation,
• reproduction,
• distribution,
• performance,
• and communication to the public

to the startup, within the intended scope.

The contract should also specify, where appropriate:

• territory,
• duration,
• exclusivity,
• media,
• commercial purpose,
• sublicensing,
• transferability,
• and consideration.

Assignment and Licence Are Not the Same Thing

Another major issue is whether the startup receives:

an assignment of economic rights

or

a licence to use the rights.

Under Article 48, economic rights can generally be transferred subject to limitations concerning duration, territory and content. The right to use an economic right may also be granted through a licence.

These two structures can create very different commercial outcomes.

Copyright Assignment

In an assignment structure, the freelancer transfers specified economic rights to the startup.

This is generally preferable where the software represents the startup’s core proprietary technology.

Copyright Licence

Under a licence, the freelancer may retain the underlying economic right while allowing the startup to exercise it within an agreed scope.

A licence may be sufficient for some projects, especially where the freelancer is licensing pre-existing technology rather than creating custom software exclusively for the startup.

However, the licence must be drafted carefully.

Exclusive and Non-Exclusive Software Licences

Article 56 distinguishes between different forms of licence.

Where the rights holder remains free to give the same licence to others, the licence is generally treated as a simple or non-exclusive licence.

Where the licence is exclusive to a single licensee, it is treated as a full or exclusive licence.

Unless otherwise understood from the law or contract, a licence is generally treated as non-exclusive.

This can be extremely important.

Suppose a startup commissions a highly specialised algorithm.

The contract merely states:

“The freelancer grants the startup the right to use the software.”

If exclusivity is not established clearly, the freelancer may potentially argue that it retains the right to license the same technology to another customer.

If the startup’s competitive advantage depends on that software, this could be commercially disastrous.

Existing Software and Future Software Require Different Treatment

Another technical issue arises because the software may not yet exist when the development contract is signed.

Article 48 provides that dispositions transferring economic rights concerning a work that has not yet been created or completed are invalid.

However, Article 50 permits contractual undertakings concerning future works even before the work has been created.

This distinction is highly relevant for software development contracts.

When Startup A signs an agreement with Freelancer X on 1 January, the application may not exist yet.

The contract should therefore be structured carefully to create:

• an enforceable obligation to transfer specified economic rights when the software comes into existence; and
• where appropriate, confirmation or implementation of that transfer as deliverables are created and accepted.

A professionally structured development process may include periodic IP confirmations attached to milestones or final acceptance documents.

This can reduce disputes about whether future software rights were legally transferred.

Why “All Future Intellectual Property Belongs to the Startup” Can Be Problematic

Startup contracts frequently contain broad clauses such as:

“All software and intellectual property that Freelancer develops now or in the future shall automatically belong to Startup.”

This wording may create several problems.

First, Turkish copyright law distinguishes existing works from future works.

Second, Article 52 requires relevant economic rights to be individually identified.

Third, the clause may be excessively broad if it captures unrelated software developed independently by the freelancer.

A better agreement should connect the transfer undertaking to:

• the defined project,
• deliverables,
• specifications,
• modifications,
• updates,
• extensions,
• and other clearly identifiable project materials.

Precision usually provides greater protection than an unlimited one-sentence clause.

Can the Freelancer Keep Reusing the Source Code?

This depends on the agreement and the nature of the code.

Software projects often contain a mixture of:

1. custom code created specifically for the startup;
2. freelancer’s pre-existing libraries;
3. general development tools;
4. open-source components;
5. third-party licensed code.

The contract should distinguish these categories.

Custom Project Code

Where the startup has commissioned unique software and receives the relevant exclusive economic rights, the freelancer should generally not be entitled to reproduce or commercially reuse that protected code inconsistently with the transfer.

Background IP

A freelancer may already own reusable libraries, frameworks or development tools before the project begins.

It may be commercially unrealistic to require transfer of every pre-existing tool.

Instead, these components should be identified as Background IP, and the startup should receive the licence required to use them within the product.

Without a background-IP schedule, disputes can arise after the startup becomes valuable.

Example: Freelancer Claims the Core Framework Was Pre-Existing

Suppose a startup pays a freelancer to create an AI analytics platform.

Two years later, the startup receives a EUR 10 million investment offer.

During due diligence, the investor discovers that 60% of the platform is based on a framework the freelancer claims to have created before working with the startup.

The original contract simply states:

“The software will be delivered to the customer.”

There is no IP assignment.

There is no background-IP schedule.

There is no licence provision.

The startup may now face a serious problem precisely when the company is preparing to close its largest investment round.

The dispute could have been avoided through proper documentation at the start of development.

Open-Source Software Can Affect Startup Ownership

Even a perfectly drafted freelancer assignment cannot give the startup more rights than the freelancer legally possesses.

Software developers routinely use open-source components.

Common licences include:

• MIT,
• Apache,
• BSD,
• GPL,
• LGPL,
• AGPL,
• and other open-source licences.

Each licence has different conditions.

A freelancer cannot simply transfer exclusive ownership of third-party open-source code as though it created the code personally.

Therefore, the development agreement should require the freelancer to disclose:

• all open-source components,
• licence types,
• versions,
• modifications,
• and dependencies.

The startup should also prohibit use of specific high-risk licences without prior approval where necessary.

Why Open-Source Due Diligence Matters

Consider a SaaS startup preparing to be acquired.

The buyer discovers that a freelancer included an AGPL-licensed component in the core product without disclosure.

The legal implications may affect how the software can be distributed or operated.

The buyer may then demand:

• replacement of the component,
• remediation,
• a purchase-price reduction,
• additional warranties,
• or indemnification.

Accordingly, software ownership does not mean merely asking:

“Did the freelancer assign the code?”

It also means asking:

“Did the freelancer have the legal right to assign every component?”

Third-Party Commercial Software Must Also Be Identified

Freelancers may also incorporate proprietary commercial libraries.

For example:

• mapping APIs,
• payment software,
• image libraries,
• analytics tools,
• proprietary SDKs,
• fonts,
• commercial databases,
• or licensed AI models.

The startup should know:

• who owns the licence,
• whether the licence is transferable,
• whether commercial use is permitted,
• whether usage limits apply,
• and what happens when the freelancer relationship ends.

A third-party account registered personally in the freelancer’s name can become a serious operational problem.

The Startup Should Control the Git Repository

Copyright ownership and operational control are separate issues.

Even if the freelancer signs a perfect assignment agreement, the startup may still face serious commercial risk if:

• the Git repository is in the freelancer’s personal account;
• only the freelancer has administrator privileges;
• server passwords are personal;
• domain registration is in the freelancer’s name;
• cloud infrastructure belongs to the freelancer;
• or the startup has no backups.

Every startup outsourcing software should ensure that critical infrastructure is under company control.

This should include:

• GitHub or GitLab organisation,
• cloud provider,
• hosting,
• database accounts,
• domain names,
• app-store accounts,
• API keys,
• analytics accounts,
• and production credentials.

Should Source Code Be an Express Contractual Deliverable?

Yes, where the startup is commissioning custom software.

The contract should distinguish between:

• object code,
• executable version,
• source code,
• development environment,
• database schema,
• documentation,
• configuration files,
• deployment scripts,
• and credentials.

A freelancer who merely provides a functioning application but refuses to provide source code can effectively make the startup technologically dependent on the freelancer.

This is known commercially as vendor lock-in.

A startup should avoid this situation unless it intentionally purchases a hosted or licensed product rather than custom software.

Moral Rights Should Not Be Ignored

Turkish copyright law also recognises moral rights belonging to authors.

These include rights concerning:

• disclosure,
• attribution,
• and protection against certain modifications.

The Ministry identifies moral and economic rights as separate categories of copyright protection.

A freelancer agreement should therefore not focus exclusively on economic rights.

Software will inevitably be:

• modified,
• updated,
• renamed,
• integrated,
• translated,
• restructured,
• and developed by other engineers.

The agreement should contain appropriate authorisations and consents regarding the startup’s normal commercial exploitation and modification of the software, within the limits permitted by mandatory copyright law.

Turkish law also protects authors against certain modifications that damage their honour or reputation or fundamentally distort the nature of their work, even where broad written permission has been given.

Can the Startup Register the Software in Its Own Name?

Copyright protection does not generally depend on registration.

The Ministry’s voluntary registration system is intended primarily to provide evidentiary convenience rather than create the underlying copyright.

The Ministry also explains that where a computer program has been commissioned from an independent person or entity for payment, the customer is not treated as the author merely because it commissioned the program. Instead, economic rights are exercised according to the written contractual arrangement.

Accordingly, founders should not view registration as a substitute for a proper copyright chain.

The contract remains critical.

What Should a Freelancer Software Agreement Contain?

A strong startup software development agreement should generally address at least the following issues.

1. Scope of Work

The software being developed should be clearly described.

2. Technical Specifications

Features, platforms, integrations and performance requirements should be documented.

3. Milestones

The agreement should establish delivery stages and deadlines.

4. Acceptance Procedure

The startup should have a defined period to test deliverables.

5. Development Fee

Payment schedule and taxes should be stated clearly.

6. Copyright Ownership

The agreement should identify which economic rights are transferred or licensed.

7. Future Works

The freelancer should undertake to transfer specified economic rights when future project deliverables are created, with implementation procedures that respect Articles 48 and 50.

8. Background IP

Pre-existing software should be listed.

9. Open-Source Components

All third-party open-source use should be disclosed.

10. Commercial Third-Party Software

Licences should be identified.

11. Source-Code Delivery

Repositories and development files should be delivered and controlled by the company.

12. Modification Rights

The startup must be able to continue development with other engineers.

13. Sublicensing and Transfer

The startup may eventually need to license the software to customers, subsidiaries, investors or purchasers.

14. Confidentiality

Source code and business information should remain confidential.

15. Data Protection

The freelancer’s access to customer and employee data should be regulated.

16. Cybersecurity

Access controls, passwords and security standards should be specified.

17. Warranty of Originality

The freelancer should warrant that it has the authority to grant the relevant rights.

18. Infringement Warranty

The agreement should regulate claims that the software infringes third-party rights.

19. Indemnification

Responsibility for third-party intellectual property claims should be considered.

20. Termination

The agreement should specify what happens to unfinished software and IP after termination.

Warranty of Authority Is Especially Important

Article 54 of Law No. 5846 makes the question of authority particularly significant.

A person acquiring an economic right or licence from someone who lacks authority may not necessarily obtain protection merely because the acquirer acted in good faith.

This is why the freelancer should expressly warrant that:

• the freelancer created the relevant original code;
• the freelancer owns or controls the rights being transferred;
• no undisclosed third party contributed protected code;
• no previous employer owns the relevant rights;
• and all third-party components have been disclosed.

This can be extremely important where a freelancer works simultaneously for several technology companies.

What If the Freelancer Uses Code From a Previous Employer?

Suppose Freelancer X previously worked for Software Company A.

After leaving, Freelancer X develops software for Startup B.

The freelancer copies a substantial amount of source code created during the earlier employment relationship.

Startup B may pay for the project in good faith.

However, if Freelancer X did not possess the right to transfer that code, Startup B can face serious infringement claims.

The contract should therefore require the freelancer to confirm that no confidential or protected material belonging to:

• previous employers,
• other customers,
• previous clients,
• or third parties

will be incorporated into the startup’s product.

Confidentiality Should Cover More Than Source Code

The freelancer may have access to extremely sensitive information.

This may include:

• product roadmap,
• customer list,
• API credentials,
• passwords,
• investor information,
• pricing strategy,
• database contents,
• business model,
• unpublished features,
• and cybersecurity architecture.

The agreement should define confidential information broadly enough to protect these assets.

It should also regulate:

• use limitation,
• disclosure,
• subcontractors,
• return and deletion,
• duration,
• cybersecurity,
• and consequences of breach.

Can a Freelancer Subcontract the Development?

Only if the contract permits it.

This issue is often overlooked.

Startup A signs an agreement with Freelancer X.

Freelancer X secretly gives part of the project to Developer Y.

Developer Y writes 40% of the code.

Who owns Developer Y’s contribution?

Did Developer Y assign the relevant rights to Freelancer X?

Can Freelancer X validly transfer those rights to Startup A?

Article 49 also creates restrictions concerning onward transfer of economic rights acquired from an author, requiring written consent in the circumstances regulated by the statute.

For this reason, startups should require prior consent for subcontracting and should ensure that every contributor signs legally sufficient IP documentation.

Software Agencies Require the Same Analysis

The problem is not limited to individual freelancers.

A startup may contract with a software development company employing twenty developers.

The startup may assume that because the supplier is a corporation, intellectual property ownership is clear.

It may not be.

The agency itself must have adequate rights from the developers creating the software.

The startup agreement should therefore require the agency to warrant a complete chain of title.

The startup should be able to prove:

Developer → Agency → Startup.

If one link is missing, ownership may become disputed.

Artificial Intelligence Tools Create Additional Risks

Freelancers increasingly use generative AI coding tools.

A development contract should therefore regulate whether the freelancer may:

• upload the startup’s proprietary code to external AI systems;
• use AI-generated source code;
• use confidential product specifications in prompts;
• or incorporate generated output without legal and technical review.

The risks include:

• confidentiality,
• cybersecurity,
• third-party rights,
• code quality,
• and licensing uncertainty.

For startups developing valuable proprietary technology, AI-tool use should not remain entirely uncontrolled.

What Happens If There Is No Written Copyright Agreement?

This is where disputes become difficult.

The startup may attempt to argue that the parties’ commercial relationship necessarily implied significant usage rights.

The freelancer may argue that:

• only limited use was permitted;
• copyright was never assigned;
• further modification requires permission;
• resale was not permitted;
• or the same code may be licensed to competitors.

The exact outcome will depend on:

• communications,
• project documents,
• invoice descriptions,
• purpose of the transaction,
• delivery conduct,
• source-code access,
• and applicable copyright rules.

However, litigation over these issues is far more expensive than drafting a proper agreement before development begins.

Can the Problem Be Fixed After the Software Has Already Been Developed?

Usually, the parties can attempt to execute a subsequent written copyright assignment or licence agreement covering already-created software.

Indeed, the fact that the software already exists may make the Article 48 issue concerning future works easier to manage.

The agreement should clearly identify:

• the software,
• version,
• repository,
• modules,
• economic rights transferred,
• consideration,
• territory,
• duration,
• and related materials.

For startups preparing for investment, performing an IP clean-up before opening the data room can be extremely valuable.

Why Investors Care About Freelancer Copyright Agreements

Venture capital investors frequently conduct intellectual property due diligence.

They may ask:

• Who created the MVP?
• Were the founders developers?
• Were freelancers used?
• Did every freelancer sign an IP assignment?
• Does the company control the repositories?
• Are open-source components documented?
• Were any agencies involved?
• Are domain names owned by the company?
• Are trademarks registered?
• Is core technology licensed from third parties?

If the answer is:

“A freelancer built the entire platform, but we never signed an IP agreement,”

the investor may consider this a material legal risk.

Possible consequences include:

• postponement of investment;
• requirement for corrective documentation;
• valuation reduction;
• additional founder warranties;
• indemnification;
• escrow;
• or cancellation of the investment transaction.

Why Buyers Care Even More During Startup Acquisitions

The problem becomes even more serious when the startup is sold.

Imagine a buyer offering EUR 30 million for a software company.

The buyer’s primary target is the technology.

During legal due diligence, the buyer discovers that the initial software architecture was created by an independent developer five years earlier.

There is no written assignment.

The freelancer cannot be located.

The buyer may ask:

“If the company does not clearly own the technology, what exactly are we buying for EUR 30 million?”

A missing IP agreement that could have been solved for a modest legal cost at incorporation may therefore jeopardise a multimillion-euro exit.

Example: Properly Structured Freelancer Development

Consider the following structure.

Startup A hires Freelancer X to develop an online marketplace.

The written agreement states that:

• Freelancer X will develop specified software;
• milestones are described;
• all pre-existing components are disclosed;
• open-source components require documentation;
• Freelancer X undertakes to transfer the individually identified economic rights in future deliverables when those rights arise;
• relevant assignments are confirmed upon milestone acceptance;
• Startup A receives broad rights of adaptation and continued development;
• source code is maintained in Startup A’s GitHub organisation;
• Freelancer X cannot subcontract without permission;
• confidentiality applies;
• Freelancer X warrants that no third-party protected code is included without disclosure;
• and all credentials and documentation are transferred at termination.

This structure gives the startup substantially greater protection.

Example: Poorly Structured Freelancer Development

Now consider the opposite situation.

Startup B sends Freelancer Y a WhatsApp message:

“Can you build us an app for TRY 300,000?”

Freelancer Y agrees.

There is no written contract.

Payment is made.

The freelancer builds the app in a personal repository.

Three years later:

• the startup has 100,000 users;
• the company is raising Series A;
• Freelancer Y still controls the repository;
• the software contains code from another client;
• no open-source list exists;
• and Freelancer Y claims the startup only purchased a licence.

This is exactly the type of dispute that proper IP documentation is designed to prevent.

Freelancer Software Copyright Checklist for Startups

Before hiring a freelancer, startups should ask:

1. Who will actually write the source code?
2. Is the developer an individual or an agency?
3. Will subcontractors be used?
4. What software already exists before the project?
5. What will be developed specifically for the startup?
6. Which economic rights will be transferred?
7. Are those rights individually identified?
8. Is the agreement written?
9. How will future deliverables be transferred?
10. Will the startup have adaptation rights?
11. Can the startup sublicense the software?
12. Can the startup transfer the software during an acquisition?
13. Is the licence exclusive if rights are not assigned?
14. Can the freelancer reuse the code?
15. Who owns improvements?
16. Who owns updates?
17. Who owns bug fixes?
18. Who controls the Git repository?
19. Will full source code be delivered?
20. Are open-source components disclosed?
21. Are third-party licences disclosed?
22. Is background IP listed?
23. Can the freelancer use subcontractors?
24. Have subcontractors transferred their rights?
25. Are confidentiality obligations included?
26. Are cybersecurity obligations included?
27. Is personal data protected?
28. Is AI-tool use regulated?
29. Does the freelancer warrant originality?
30. Is there protection against third-party infringement claims?
31. What happens when the agreement terminates?
32. Does the startup receive all credentials and documentation?
33. Can the startup prove the complete IP chain during investor due diligence?

If the answer to these questions is unclear, the startup may not have a clean intellectual property structure.

Conclusion: Do Copyrights in Freelancer-Developed Software Automatically Transfer to a Startup?

The answer under Turkish law is generally:

No. Paying a freelancer to develop software does not, by itself, automatically transfer all copyrights in that software to the startup.

The person who creates the software remains the author in the copyright-law sense.

The Ministry of Culture and Tourism specifically confirms that the source-code creator is generally the author and that where a program or database is commissioned from an independent party for payment, the client is not transformed into the author merely because the development fee was paid. The economic rights are exercised according to the relevant written contractual arrangement.

This is fundamentally different from the special rule applying to works created by employees while performing employment duties under Article 18 of Law No. 5846.

For freelancers, the written software agreement is therefore critical.

Article 52 requires contracts and transactions concerning economic rights to be in writing and requires the relevant economic rights to be identified separately.

Startups should accordingly ensure that the agreement addresses the individual rights required for commercial exploitation of software, particularly:

• adaptation,
• reproduction,
• distribution,
• performance,
• and communication to the public.

The company should also decide whether it requires an assignment or merely a licence.

Where a licence is used, exclusivity should be expressly addressed because Turkish copyright law generally treats a licence as non-exclusive unless otherwise established.

Future software requires additional care.

Article 48 does not permit an immediate disposition of economic rights in software that has not yet been created, while Article 50 allows contractual undertakings regarding future works.

For this reason, properly drafted Turkish software agreements should distinguish:

• existing software rights;
• obligations concerning software to be created;
• and the legal implementation of the transfer once deliverables come into existence.

Finally, copyright assignment alone is not enough.

A technology startup should also control:

• source-code repositories,
• cloud infrastructure,
• domains,
• credentials,
• technical documentation,
• background IP,
• open-source components,
• third-party software,
• subcontractor rights,
• confidential information,
• and AI-development practices.

For founders, the practical rule is straightforward:

Never assume that paying for software means owning all of the intellectual property in that software.

The correct questions are:

Who wrote the code?

Under what contract?

Which rights were transferred?

Were the rights separately identified in writing?

Was the software already created when the transfer occurred?

Can the startup modify and continue developing the software?

Can the startup sublicense or sell it?

Can the freelancer reuse the same code for a competitor?

Are third-party and open-source components properly licensed?

Can the company prove the entire chain of intellectual property rights to an investor or purchaser?

For a software startup, these questions directly affect company valuation.

A startup may have significant revenue, thousands of users and strong growth, but if its core software was developed by freelancers without legally sufficient copyright documentation, the company’s most valuable asset may not be as secure as the founders assume.

The safest approach is therefore to establish the intellectual property structure before development begins, not after the startup becomes valuable.