New Zealand’s copyright laws contain an important feature known as the “commissioning rule”. Software developers – whose stock in trade is intellectual property – need to beware of this rule.
Note: the Government is proposing to repeal this rule. As of April 2009, the amending Bill (carried over from the previous Labour-led Government) sits at number 18 on the Government’s Order Paper (right after the Dog Control Amendment Bill), so the rule may not be repealed for some time.
The commissioning rule – who owns 1st copyright in code?
If a software developer is hired (i.e. “commissioned”) by a customer to develop some code, an important question is who owns the copyright in the resulting code – the customer or the developer? The rule that governs who owns commissioned works is known as the commissioning rule, which in New Zealand is contained in section 21 of the Copyright Act 1994. Under that rule, the answer will typically be one of the following scenarios:
- If the software developer is a person (as opposed to a company) who was hired as an employee (part time or full time) by the customer, then the customer (i.e. employer) will own the copyright in any original code produced by the developer.
- If the software developer (either a person or a company) is contracted by the customer to produce some code, and is to be paid for it, then the “default rule” is that, again, the customer will own the copyright in any original code produced by the developer. Importantly, the customer will have ownership of the software whether or not they have actually paid the developer for it.
- If the software developer (either a person or a company) is contracted by the customer to produce some code, and both agree that the developer will own the copyright, then the developer will own the copyright in the code they develop for that customer. The agreement would usually be in writing (though it need not be a formal, or even signed, contract). A verbal agreement will suffice, though without any written evidence, it may be difficult to prove what was agreed.
The simple rule is that if the software developer and the customer agree in advance as to who will own the copyright, then that agreement will prevail.
However, in reality as many will know, the contracting/paperwork side of software development can be a bit of a mess. Projects are started without contracts being place, undocuments variations and “sub-projects” may emerge, “interim” off-contract solutions are implemented, and final agreements may never be signed.
In particular, with the increasing use of agile development methodologies, the emphasis is even more on delivering working code than negotiating contractual terms – though as always, getting a contract in place before starting is highly recommended.
When the parties have not agreed (usually in writing) who will own the copyright, then the “default rule” is that the customer will own the copyright (scenario 2 above).
Copyright ownership and code reuse
Copyright ownership is of particular importance to software developers who reuse code – which means virtually all developers. Simply, unless a developer owns copyright in some particular code (or obtains an appropriate licence), they are not entitled to reuse that code anywhere else. This applies even if the developer wrote the code themselves – no copyright ownership, no reuse. If the developer does not own the copyright, then the copyright owner’s approval (or their authorised licensee) must be obtained.
This is the basis on which open source software works. Under the GPL version 3, for example, a developer is licensed to reuse the code as they see fit (subject to some conditions). The developer does not actually own the copyright of the open source code they are reusing, but they are licensed by the copyright owner(s) to reuse the software in their projects.
For in-house code libraries, it is essential that the developer retains copyright in the relevant code they develop. Often, this code will not be of particular commercial value to any one else but the developer who wrote it, but it is very valuable to the developer to be able to reuse it in other projects. It should be noted that if a developer already owns copyright in code that is used in a customer project, then the developer will not be at risk of losing that existing copyright. But if the code library is modified, then the copyright in those modifications may be be deemed to be owned by the customer. It is easy to imagine how this could potentially result in complex, tangled situations.
Unfortunately, it is not possible to retrospectively “claw back” ownership of code that has been developed for and owned by another customer. In this situation, the developer would need to get the customer to assign (e.g. transfer ownership of) the copyright to them. If the customer wants to own the copyright of code they have paid for – which is perfectly reasonable – then the developer may want to either separate out and retain ownership of common, generic code that they intend to reuse on other projects, or license back such code.
In any case, it is much easier to deal with these issues at the outset of the project, in the form of a clear, easily understood contract.