Copyright in software and commissioned work: step by step depends on one fact settled before any code is written: whether the person creating it is an employee or an external party engaged under a commission. For employees, the employer typically ends up holding the rights needed to exploit software created within the scope of employment. For anyone engaged outside an employment relationship, freelance developers, agencies, contractors, the starting position under Swedish law runs the other way: the author keeps the copyright unless it has been assigned in writing.
Who this concerns
This sequence matters to any business paying someone outside its own payroll to build software: a startup commissioning an MVP from a development studio, a manufacturer paying an integrator to write control software for a production line, a SaaS company outsourcing a module to a subcontractor, or an in-house team bringing in a freelance developer for a single sprint. It matters equally on the developer side: agencies and sole traders who deliver code without a written assignment clause remain the copyright holder even after the invoice is paid and the software is running in production.
Procurement, in-house legal and whoever signs off on a development contract need to know where the line sits, because the commercial value of software rarely lies in the object code alone. It lies in the ability to modify it, licence it to others, or sell the business that runs on it, and all three depend on who actually holds the rights, not on who paid the invoice.
What the law says
Swedish copyright law protects computer programs as literary works from the moment of creation, without registration and without a notice requirement. Protection attaches to the author, the natural person who wrote the code, not automatically to the company that commissioned it.
The relevant distinction is between software created within an employment relationship and software created under a commission. Where the developer is an employee acting within the scope of their duties, the general position under Swedish law as it currently stands is that the employer acquires the rights needed for its ordinary business use of the software. Where the developer is not an employee, a consultant, a freelancer, an agency, that presumption does not apply. The commissioning party acquires no rights automatically; it needs either an assignment clause in the contract or a separate written transfer.
Protection also extends beyond the object code the end user runs. Source code, technical documentation and preparatory design material can each carry separate copyright, and an assignment drafted only around "the software" without defining what that term covers can leave gaps around exactly these elements.
This is the point most commissioning parties get wrong: they assume paying for the work is the same as buying the copyright in it. Under Swedish law, it is not. Payment for services and transfer of copyright are two different transactions, and the second one has to be documented separately.
How it works in practice
The steps below run in the order a commercial dispute over software ownership actually gets tested: from earliest and cheapest to fix, to latest and most expensive.
Step 1: Identify who actually wrote the code
Before anything else, establish the real author. If a development agency subcontracts part of the work to a freelancer, the freelancer is the author of that part, not the agency, unless the agency itself holds a written assignment from that freelancer. Subcontracting chains are where rights most often go missing.
Step 2: Confirm the nature of the relationship
Decide, honestly, whether the developer is an employee or an external party. Titles and invoicing habits are not decisive. Someone invoicing through their own company, working from their own equipment on their own schedule for a fixed deliverable, is almost never an employee for this purpose, regardless of how the parties described the arrangement informally at the time.
Step 3: Check the commission agreement for an assignment clause
Read the agreement specifically for language that transfers copyright, not merely language granting a licence to use the software. A clause allowing "the right to use the software for its intended purpose" is a licence. A clause stating that copyright in the deliverables is assigned to the commissioning party on delivery, or on payment, is an assignment. The two produce very different outcomes once the relationship ends.
Step 4: Address moral rights separately
Assigning economic copyright does not automatically waive the author's moral rights, the right to be identified as author and the right to object to distortion of the work. A commissioning party wanting to modify, rebrand or sublicense the software without constraint should have the agreement address this point expressly, to the extent it can be waived under Swedish law.
Step 5: Cover third-party and open-source components
Very little commissioned software is written entirely from scratch. Identify any open-source libraries, third-party APIs or licensed components embedded in the deliverable, and check the licence attached to each. A copyleft licence on an embedded component can restrict how the whole deliverable may be used or distributed, regardless of what the commission agreement says about the code the developer actually wrote.
Step 6: Secure the assignment before delivery, not after
An assignment agreed after the software has already been delivered and put into production is enforceable if properly executed, but it is negotiated from a far weaker position: the commissioning party is already dependent on the software, and the developer knows it. The assignment belongs in the commission agreement, signed before work begins, not added retroactively once the relationship has turned difficult.
Step 7: Document delivery and acceptance
Keep a clear record of what was delivered, when, and in what state. This matters less for the copyright position itself and more for proving, later, exactly what was covered by the assignment, particularly where the software is delivered in stages or modified after initial acceptance.
Step 8: Retain evidence of authorship and the chain of assignment
Keep the signed agreement, correspondence around any variation, and a record of every subcontractor involved. If ownership is ever challenged, the commissioning party has to show an unbroken chain from the original author to itself, not merely that it paid for the work.
Step 9: Handle modules written by several developers separately
Where more than one developer contributed distinct modules, treat each contribution as a separate authorship question. A single umbrella assignment signed by the lead contractor does not necessarily bind a subcontractor who worked on a discrete component under a different arrangement. Joint authorship and separate authorship of severable parts are resolved differently, and the agreement should say which applies.
What to check before signing a commission agreement
- Whether the developer is contracting personally or through a company, and whether that company can bind any subcontractors it uses
- Whether the clause transfers copyright or only grants a licence
- Whether the transfer covers future versions, updates and derivative works, or only the version delivered
- Whether moral rights are addressed, and to what extent they are waived
- Whether embedded open-source or third-party components are listed and their licences disclosed
- Whether the assignment is conditional on payment in full, and what happens if payment is disputed
- Whether the agreement distinguishes source code ownership from object code ownership
If the developer is based outside Sweden
Where the developer, the agency, or a key subcontractor is established outside Sweden, the analysis does not stop at Swedish copyright law. The law applicable to authorship and the default ownership rule may follow the developer's own jurisdiction rather than Sweden's, particularly if the agreement is silent on governing law. A commissioning party dealing with a foreign development team should not assume the Swedish default position on assignments applies automatically. It should have the agreement state expressly which law governs the assignment of rights, and secure the assignment in a form that is also effective under the developer's home jurisdiction, since an instrument valid only under Swedish law may not travel well if the dispute ends up before a foreign court.
Who owns the copyright if the developer is a sole trader rather than a company?
The copyright rests with the individual who wrote the code, regardless of whether they invoice under a personal name or through a limited company. If the sole trader operates through their own company, that company does not automatically hold the copyright either, unless the individual has assigned it to the company, which has in turn assigned it onward to the commissioning party. Each link in that chain needs to be documented on its own terms.
Does a signed invoice count as a valid assignment of copyright?
No. An invoice evidences payment for services rendered; it does not, on its own, transfer copyright. Some commissioning parties rely on invoice terms referencing a broader agreement, but if that underlying agreement contains no assignment clause, the invoice adds nothing to the ownership position. The assignment has to be documented separately, in the contract itself or in a dedicated transfer instrument signed by the author.
What happens if the commission agreement is silent on IP ownership?
If the agreement says nothing about copyright, the default position under Swedish law as it currently stands favours the author, not the party that paid for the work. The commissioning party is left with, at best, an implied licence to use the software for the purpose for which it was commissioned, and no right to modify, resell, or sublicense it without going back to the developer for a separate agreement.
The numbers
There is no statutory deadline that forces a commissioning party to obtain a written assignment by a fixed date; the exposure here is commercial, not procedural. The point at which a missing assignment starts costing money is not the date of signing but the date the software goes into production, is modified by a different developer, or becomes the basis for a sale of the business relying on it.
What varies from case to case is not a fixed period but a set of factors: how many parties touched the codebase, how much of it depends on third-party licensed components, whether the original relationship has already ended by the time the gap is noticed, and how central the software is to the value of the business relying on it. A gap discovered before a financing round or an acquisition is far more expensive to close than the same gap discovered at the start of the relationship, because by then the developer is negotiating from a position of leverage rather than goodwill, and every week of delay tends to raise the price of closing the gap rather than lower it.
Where it usually goes wrong
The most common failure is treating the commission agreement as a services contract and nothing else, with IP terms left to a boilerplate clause nobody reads closely. The services get delivered, the invoice gets paid, and the copyright question only surfaces years later, typically when the business is being sold, refinanced, or when the original developer resurfaces with a competing product built on the same code.
A second recurring failure is assuming that because a developer worked "in-house" for a period, on-site, using company equipment, the employment presumption applies. It does not, unless there is an actual employment relationship recognised as such; a long-term contractor is still a contractor.
A third failure sits with subcontracting chains. A commissioning party gets a clean assignment from the agency it contracted with, but the agency's own agreement with the freelancer who actually wrote the code contains no assignment at all. The chain of title is broken one link down, and this typically is not discovered until enforcement or licensing is attempted.
A fourth failure is silence on future versions. An assignment covering the delivered version does not automatically extend to updates, patches, or a rewritten second version commissioned later from the same developer. Each engagement needs its own assignment, or the original agreement needs to be drafted broadly enough to cover the ongoing relationship as a whole.
A fifth, less obvious failure is treating source code escrow and copyright ownership as the same issue. Access to source code through an escrow arrangement does not transfer any rights in it; it only guarantees a copy exists if the developer disappears. A business can have full escrow access and still hold no right to modify or relicense what it is looking at.
What to do next
Reviewing the current state of a codebase's ownership is a document exercise before it is anything else: pulling every commission agreement, checking each one for an assignment clause, and tracing the chain back to every individual who wrote code still in production. That work identifies the gaps; closing them, retroactively where possible, is a separate negotiation with each party involved.
Where the gap is already causing a dispute, for example a developer threatening to withdraw a licence, or a buyer's due diligence flagging missing assignments, the next step is not another document review but an assessment of what remedies are actually available and how urgently they need to be pursued. A preliminary injunction in an IP dispute is one of the tools available where use of disputed software needs to stop before the ownership question is fully resolved, and whether it is the right tool depends on facts a document review alone will not surface. A preliminary assessment of the position is the more useful next step once the internal review has identified where the gaps sit.
For the broader context of how ownership and licensing questions are handled across intellectual property matters, see the intellectual property practice overview.