Intellectual property
Rights to Software in Custom Development: Who Owns Them
By default, rights to software in custom development remain with the person who created it — the developer or their employees, unless the contract states otherwise. The customer must secure the transfer of rights in a document in advance; otherwise, the paid-for code formally does not belong to them.
The question of rights arises later than one would like: the code has been written and paid for, and the client is about to refine the product, sell it, or attract investment — and discovers that formally they own nothing. A computer program is protected as an object of copyright, and by default the rights remain with the person who created it — the developer or their employees. A contract without a rights clause does not change this situation.
Below — what to fix in the subject matter of a custom development contract, how assignment differs from a license, what rights exist, and how to formalize the transfer when changing contractors, with multiple clients, when an employee leaves, and during due diligence before selling a business.
Who Owns the Rights to the Software If the Contract Is Silent
If the contract contains no clause on rights, the proprietary right to the software remains with the developer. A computer program in Kazakhstan is a copyright object, and as a general rule the proprietary right initially belongs to the author or their employer. Payment gives the customer the result: a working product, access, support, but not the scope of rights. As long as the contract is silent, the customer uses the software only within the limits directly arising from the transaction — and it will not be possible to expand them retroactively without the right holder's consent.
Ownership of rights is determined by the text of the contract, not by the fact of payment. A transfer of rights is possible only through an express provision in the agreement: without such a clause, the contractor has assigned nothing. The interpretation of the terms of the transaction is a matter for the court, and here what is decisive is how the parties described the subject matter and the scope of the rights being transferred. Practical advice: before signing, check whether the contract names the method of disposing of the right and what exactly passes to the customer — the code itself, the right to use it, or both elements.
Rights to the Software in a Custom Development Agreement: What to Include in the Subject Matter
The subject matter must expressly identify the software as an object of copyright and fix the scope of rights the customer receives. The wording "software development" alone is not enough: it does not show whether the exclusive right is transferred in full or only the right of use. Therefore, the subject matter describes the transfer of exclusive or non-exclusive property rights, lists the ways of use, the term and the territory.
When the scope of rights in the subject matter is not defined, at acceptance it is unclear what exactly the acceptance certificate confirms, and during operation — whether the code may be modified, the contractor changed and the system transferred to third parties. The subject matter links the rights through identification of the result: name, version, composition of modules, functional purpose. The transfer is formalized in a separate intellectual property section with a reference to the subject matter — this way the terms do not diverge from one another.
Bonafacto lawyers, when reviewing such agreements, start with the subject matter: if it lacks the ways of use and the territory, the remaining sections have to be interpreted blindly. A practical technique is to list in the subject matter all the actions the customer plans to perform with the software and to verify them against the rights section.
What rights to a program exist at all: personal and property rights
From the moment the result appears, the creator of the code acquires personal non-property and property rights. Personal rights are vested in the author inalienably, while property rights freely participate in circulation. This distinction matters for a transaction: some items remain with the programmer under any contract, while others pass to the customer.
Personal non-property items confirm the creator's connection to the result. They cannot be waived, sold, or gifted — they remain with the author under any transaction and under any change of customer. Even if the code has long been in production at the client's, the programmer's authorship does not disappear.
The list is as follows:
- right of authorship — vested in the author forever and inalienably;
- right to a name — retained regardless of the transfer of property rights;
- right to protection of reputation — not subject to assignment;
- property rights — may be transferred under an author's contract as exclusive or non-exclusive;
- right to remuneration — a property right, determined by the terms of the contract;
- right to publication — exercised by the author upon release of the result to the public.
A summary of each item is provided in the table below.
| Right | Nature | Can it be transferred |
|---|---|---|
| authorship | personal non-property | no |
| name | personal non-property | no |
| protection of reputation | personal non-property | no |
| exclusive right | property | yes |
| remuneration | property | yes, the amount and procedure of payment are set by the contract |
Personal items follow the author, property items follow the contract.
When reviewing such a contract, Bonafacto lawyers first of all verify which property rights exactly and to what scope of code are being transferred. Without this verification, the author's personal items remain with the programmer, and the customer receives only what is expressly named in the text of the agreement.
Alienation or license: how the customer obtains rights to the software
The exclusive right to a computer program in Kazakhstan is a property right and passes to the customer under an author's agreement on the transfer of exclusive rights, or is granted under an agreement on the transfer of non-exclusive rights (a license). Upon transfer of exclusive rights, the customer becomes the rights holder from the moment specified in the agreement; state registration of such a transaction is not required in the RK . Under a license, the rights holder remains the same, and the customer receives permission to use the program within the limits of the agreement.
Alienation deprives the contractor of the ability to use the result and dispose of it, and the customer receives the full set of powers: to use, modify, distribute and transfer the asset further. A license does not grant such scope: it defines the manner of use, the territory, the term and the permitted actions, and anything not expressly permitted is deemed prohibited. Bonafacto lawyers advise checking before signing which of the two structures is embedded in the subject matter of the agreement — this determines whether the customer will be able to modify the code without regard to the contractor.
It is more convenient to compare the options by criteria:
- subject matter of the agreement: full assignment of the exclusive right or granting of the possibility of use;
- scope of the customer's powers: disposal of the asset or use within specified limits;
- fate of the exclusive right with the contractor: loss or retention with the possibility of granting licenses to others;
- possibility of modifying and refining the code without the consent of the rights holder;
- transfer of powers to third parties and contribution to the charter capital;
- risks in developing the product beyond the agreed terms.
| Criterion | Alienation | License |
|---|---|---|
| Rights holder after the transaction | Customer | Contractor |
| Scope of the customer's powers | Full | Only as provided by the agreement |
| Disposal to third parties | Possible | As a rule, with the consent of the rights holder |
| Modification and refinement | Freely | Within the permitted limits |
| Risk in developing the product | Minimal | Depends on the license terms |
The scope of powers is determined by the agreement; registration in the state register is not mandatory but confirms ownership.
How to formalize the chosen structure: documents and procedure
The choice between alienation and license is fixed in the text of the agreement and confirmed upon transfer of the result. The wording "rights are transferred to the customer" without specifying whether they are exclusive or not leaves the scope of powers undefined — which means the parties will be arguing already at acceptance or product launch.
A procedure that reduces risk:
- Subject matter: identify the program as an object of copyright — name, version, composition of modules, functional purpose.
- Type of transfer: expressly state that exclusive rights are transferred or that the right of use is granted, and list the ways of use.
- Limits: for a license — territory, term and permitted actions; anything not permitted remains with the rights holder.
- Acceptance act: record the delivery of the result and the transfer of the tangible medium with the code, description and distribution package.
- Composition of the result: separately stipulate the rights to the design, database and documentation — for each element.
A typical mistake is signing the acceptance act without attaching the medium with the code to it: the act by itself confirms the delivery of works but not the transfer of the object. Another is leaving in the agreement a general phrase about software development from which it is not clear whether the contractor has lost the ability to dispose of the result. Both points should be checked before signing: reworking the wording later is harder than agreeing on it at the start.
What the rights to the program cover: code, design, database, documentation
The product consists of several objects, each with its own author and protection regime. Access to the repository does not mean the entire scope is transferred: code, interface, data structure, and documentation follow different rules.
The legal regime of code arises for developers as authors by virtue of the creation of the work. Design and database exist separately: the interface, graphics, and data structure may be protected independently of the code and have different authors. Documentation, the technical specification, diagrams, and instructions are separate objects.
The scope is determined by which elements were included in the result and what is recorded in the contract. If only the code is described, the customer will not receive the design, database, or documentation even with full payment. Each element is secured separately, not with one general phrase.
The result can be checked by a simple test: name each element of the product and find a line for it in the contract. An element without a line remains with the author — even if the files are on the customer's server.
If the contract says nothing about the rights to the program, the customer receives the finished product for use, but not the object itself — they will not be able to dispose of it. Aizhana Medetova
Rights to the Software and Open Libraries: What the Customer Receives Along with the Code
If the software uses free libraries and third-party code, the scope of rights is limited by their licenses: the customer's exclusive right covers the part created by the contractor, but not third-party components. Library licenses apply independently of the contract with the developer.
Open licenses fall into permissive and copyleft categories. The former allow the code to be used in a closed product provided that authorship notices are retained; the latter require the derivative software to be distributed under the same terms, up to and including disclosure of the source code of the custom development.
A license review shows their compatibility with each other and with the customer's plans. Conflicting terms or a missing notice create a risk of claims from rights holders and of rewriting part of the product — and the contractor's silence about components of third-party rights in the code does not change that.
What to request from the contractor before signing the acceptance certificate:
- a list of the libraries and their versions included in the build
- the license texts of each component and the notice requirements
- the presence of copyleft terms and their impact on the closed nature of the code
- compatibility of the licenses with each other and with the development contract
- the origin of code fragments taken from external sources
- documents confirming the contractor's rights to the transferred code
This list should be attached to the acceptance certificate: this way the composition of the transferred code is recorded in writing, and when the product is further developed by another team, the question of the origin of the components will not be left hanging in the air.
Another contractor continues the work under the program: how rights are transferred
When the developer changes, the customer needs not only working code but also confirmed right to dispose of it. Proprietary rights to the code pass to the customer only if this is expressly stipulated in the contract with the developer. Otherwise a conflict arises: the previous contractor retains authority over the modules written, while the new one cannot lawfully modify them.
In the contract with the new contractor, it is important for the customer to confirm the ability to dispose of the program: include a condition on the transfer of the source code in full, including comments, build schemes and configurations. The legal regime for modification is fixed separately: what is created anew, what is changed, and who owns the result for each block of work. (Also check what exactly is considered the result — the repository, the build, or access to the environment.)
What should be fixed in the contract before the work starts:
- Fix in the contract the transfer of the source code and technical documentation in full.
- Specify that the rights to the program upon modification pass to the customer at the moment of acceptance of the result.
- Determine who is responsible for the use of previously created modules and libraries.
- Obtain from the previous contractor confirmation of no claims to the transferred code.
- Stipulate the procedure for actions when the developer changes and the scope of materials to be transferred.
- Fix the obligation of the new contractor not to use the code outside the customer's tasks.
Rights to a program held by multiple customers: replication and exclusivity
An identical scope of rights under a standard contract with all customers means that exclusive rights arise only to the extent expressly stated in the contract. With general wording, the developer is entitled to transfer the code to the next buyer — including a direct competitor. This can be checked before signing: it is enough to see whether the text names specific ways of disposing of the result.
Exclusivity is achieved through a precise description of the scope: the ways of use, territory, term and the possibility of sublicensing. Replication without the customer's consent is a violation if the contract restricts the transfer of the code to third parties. The wording "everything provided for by law is transferred" does not provide such protection.
Registration of rights to copyright objects in the RK is not mandatory, but serves as evidence: it confirms who owns the version of the code and what terms of its use have been agreed. Depositing the source code with a notary serves the same purpose in practice — it records the state of the code on a given date.
Terms worth agreeing in the contract:
- The list of transferred rights: ways of use, number of copies, territory, term.
- A prohibition on transferring the code to third parties without the customer's written consent.
- A non-disclosure and non-competition condition with respect to similar products.
- The procedure for transferring the source code, builds and technical documentation.
- Recording the result of the work and registering rights in the state register as evidence.
- The developer's liability for unauthorized replication of the program.
Dispute over rights to a software program: what the court examines
The court assesses who created the code and on what basis the exclusive rights passed to the customer. Computer programs in Kazakhstan are protected as copyright objects, but possession of a copy or the source code by itself proves nothing — what is needed is the chain "author → contract → transfer".
The main evidence is the custom development contract. If it states that exclusive rights pass to the customer, this simplifies the position. Without such a condition, they remain with the developer, and the customer receives only the right to use within the scope under the contract.
Transfer is confirmed by acceptance certificates recording the delivery of the work result. Their weight increases when the source code, description, distribution package or other medium is attached. Courts verify not only the signing of the certificates but also the actual transfer of the code and the possibility of its use.
The evidence base should be assembled in advance — here is what it includes:
- a custom development contract with a condition on the transfer of exclusive rights or on their retention by the contractor;
- acceptance certificates recording the transfer of the work result and the tangible medium with the code;
- source code, documentation and distribution packages that allow the program to be identified;
- work assignments, correspondence between the parties, approvals of the technical specification and amendments;
- information on access to the repository, change logs and other technical traces of development;
- payment documents confirming payment for the work under the contract.
Practical advice: annexes to the certificate (list of files, version, checksums) should be prepared at the time of delivery — restoring them later, when access to the repository is already closed, is difficult.
Rights to the Software Leave with the Employee: What the Customer Should Do
When an employee wrote the software, the key question is who the author is and who owns the economic rights. Under the Law of the RK "On Copyright and Related Rights," rights to a work created in the course of employment belong to the employer, unless otherwise provided by the contract. If the employment contract or job description does not include an obligation to create code, the employee may challenge the status of the work as a work created in the course of employment. Therefore, protecting interests begins with reviewing HR documents.
When a developer is dismissed, authority does not disappear automatically, but access to the repository, server, and documentation may be lost. If the code was stored on the contractor's personal resources, the customer loses the ability to use and modify it. Bonafacto lawyers advise that, before a dispute begins, you record which objects were created under the contract and where they are physically located.
Next is the procedure to follow before and after parting ways with the developer:
- Review the employment contract, job description, and work contract: is there a clause on a work created in the course of employment or on the transfer of rights.
- Record the composition of the created code, versions, dates, and authors using acts, correspondence, assignments, and access logs.
- Ensure that source code, builds, and documentation are stored on the customer's resources, not on the developer's personal media.
- Execute an acceptance and transfer of rights act and revoke access to the repository and infrastructure upon dismissal or termination of the contract.
- Send a written demand for the transfer of materials and confirmation of rights, keeping proof of dispatch.
- If necessary, register the rights to the software with the authorized body as additional evidence of ownership.
Practical conclusion: specify the transfer of materials and access in HR documents in advance — then a specialist's departure does not turn into a dispute over who owns the code.
What to Attach to the Transfer Act and How to Verify That the Code Is Yours
An acceptance and transfer of rights act serves as evidence only when the result itself is attached to it. A signature stating that rights have been transferred is not enough: the court looks at the actual transfer of the code and the ability to use it. Therefore, the act should be accompanied by a medium with the source code, a build description, and deployment instructions — so that the product can be launched without the former developer's involvement.
It is convenient to conduct the review by the composition of objects rather than with a single line "software transferred." The code, design, database, and documentation are protected separately, and for each element the act should state exactly what is being transferred.
- Source code: the entire repository, including comments, build schemas, and configurations.
- Design: interface layouts and graphics — as independent objects with their own authors.
- Database: the data structure and a description of the relationships between tables.
- Documentation: the technical specification, schemas, instructions, and operating manual.
- Libraries: a list of components with versions and license texts included in the build.
A typical mistake is to mistake access to the repository for the transfer of authority: a login in the system shows the ability to view the code but does not confirm that the customer has the right to dispose of it. The second is to leave the build and configurations with the contractor: without them, the source code exists, but there is nothing to launch the product with. The third is not to record which modules were written anew and which were taken from the contractor's previous work.
Practical advice: before closing the act, ask the new contractor to deploy the product from the transferred package on their side — if the build succeeds without contacting the former developer, the transfer has occurred in fact, not just on paper.
Typical mistakes in a custom development contract: a checklist before signing
Reviewing a contract before signing comes down to seven points: they gather the places where the wording leaves the customer without rights to the result. Each point is checked against the text of the agreement, not against correspondence and promises. Below is a checklist that is convenient to go through before signing.
- The object in the subject matter: whether the result is named as an object of copyright — the program, its parts, the design, the database, the documentation, and not only "development work".
- Type of transfer: whether it is expressly stated that the exclusive right is transferred or that a right of use is granted under a license.
- Scope, term and territory: whether the ways of use, the term of validity and the territory covered by the rights are described.
- Breakdown by element: whether the rights are secured separately for the code, design, database and documentation, rather than in one general phrase.
- Open libraries and authorship: whether open-source components and the procedure for preserving authorship notices are stipulated.
- Transfer materials: whether the transfer of source code, builds and documentation is provided for, and not only the finished product.
- Rights acceptance certificate: whether a separate document is provided that records the moment the rights pass.
A general phrase "the rights are transferred to the customer" without detail leaves open the question of what exactly and to what extent has been received. At Bonafacto, the cost of the stage is fixed in the contract before work begins, and this is the same principle: the terms are described in advance, not reconstructed from memory after the project is delivered. Bonafacto lawyers advise checking the checklist against each section of the agreement and its appendices — discrepancies between them are discovered already in a dispute.
Rights to Software When Selling a Business and Attracting Investment: What Is Checked
When a company is sold or investment is raised, a check is made of who owns the software: computer programs in Kazakhstan are protected as copyright objects, and the buyer or investor assesses who holds the exclusive rights and whether there are any encumbrances. The legal status of such an asset affects the transaction price: what is being acquired is a product that can be used, modified, and transferred.
The check includes an analysis of the chain of creation: who was the author, whether agreements were concluded with developers, and whether works made for hire were properly documented. Without documentary confirmation, the asset is considered risky. For the investor, both the ownership of exclusive rights and the absence of disputes with former participants or contractors are important.
Practical advice: assemble the chain of documents before the transaction — agreements with authors and contractors, acceptance certificates, work assignments — otherwise the buyer or investor will see a gap in the supporting evidence. A check is also made of whether the exclusive rights were transferred to third parties under licenses. Such a package should be prepared in advance: restoring documents after negotiations have begun is more difficult.
What to check before signing a custom development agreement
Rights to the software are determined by the agreement, not by the fact of payment: an invoice and an acceptance certificate alone do not make the customer the rights holder. The type of transfer — assignment or license — is chosen based on plans for the product: to sell it, to modify it with third-party developers, or to use it within the company. Rights are secured for each element separately: code, design, database, documentation.
Open-source libraries and works made for hire by the contractor's employees are checked separately — clear terms are needed for them, otherwise part of the product will remain outside the deal. The transfer is formalized by an act with the medium: what exactly is transferred, in what scope and on what terms.
- Subject matter: assignment of the exclusive right or a license with a clear scope.
- Elements: code, design, database and documentation are secured separately.
- Libraries: the terms of open-source components and works made for hire are described in the agreement.
- Transfer: the act records the medium, the composition of materials and the moment of transfer.
Wording is checked before signing, not after acceptance: rewriting terms retroactively is harder than agreeing on them in advance.