Ownership of the intellectual property rights to custom software created by an independent contractor can be tricky. Because custom software can be highly valuable and expensive, it’s important to understand IP ownership issues.
Over the last decade I’ve seen both businesses who paid for custom software and software developers be surprised and outraged by ownership issues. I’ve seen millions of dollars spent on litigation trying to untangle IP ownership and millions of dollars of potential revenue lost because IP ownership issues couldn’t be cleaned up after the code was created.
IP ownership to custom software in part depends upon: 1) the relationship between the software developer and the client; and 2) the authors of the code.
1) The Relationship
Without a clear contract between an independent software developer and a client that defines and clarifies intellectual property rights, copyright assignment or license terms, IP rights to custom software will be murky at best.
And it doesn’t matter if the client paid a large amount of money for the creation of the custom software. Without a clear, written contract, the client may end up with nothing but a limited, implied license to use the software.
The default law under the Copyright Act is that the author of the work — the independent software developer— owns the copyright to the software. Moreover, a transfer of the ownership to the software’s copyright is only valid if it is in writing and signed by the author or owner of the work.
To further complicate matters, if the client contributed design ideas or process information that qualifies as a trade secret and this IP was integrated into the custom software, the client may be a joint owner of some IP rights.
Importantly, the parties may have different views on IP ownership that may or may not have been discussed as part of the business deal.
The Client’s Perspective. A business client that is paying for complex, custom software may want to own all of the copyright rights to the custom software. For example, it may want to be able to make derivative works — modifications of the original program — or the ability to sublicense the software or sell it to others. A business client with this attitude and a lawyer may require a standard independent contractor agreement that fully assigns all IP to the client. A business client without a written contract or an understanding of copyright law, however, may mistakenly assume that it owns the copyright if it paid for the creation of the custom software. (See my former post for an explanation of the types of copyrights rights.)
The Software Developer’s Perspective. In contrast, an independent software designer who has spent several years creating the core code that is customizes for clients, will probably want to retain some or all of the IP rights. He may want to reuse the core code for future clients and only give the client a non-exclusive license to the custom software. Of course some developers may not care about owning any rights to the custom code. They my also not care about infringing the copyright to their former work.
Importantly, the software developer who wants to retain some IP rights may have signed an independent contractor agreement early in its relationship with a client and may need to renegotiate the terms regarding IP rights. It is possible to negotiate a carve out of some IP rights, even with a big client, but the independent contractor may need a lawyer’s help. An independent contractor may be able to negotiate this carve out with the client’s lawyer himself but he may not get the rights he thinks he is getting. (I’ll write more about what a software developer needs to watch out for in a licensing clause in later posts.) .
The only way to hammer out IP rights is with a written contract. Oral agreements are not valid to fully transfer copyright ownership. Contracts need to address trade secret issues and be specific about who owns what and the limits to the corresponding rights. Both parties need to understand what they can and can’t do with the software.
2) The Authors of the Code
Ownership of custom software gets even more complicated if: a) more than one software developer worked on the code; b) the software developer has a development company that doesn’t own his works; or c) open source code with a restrictive license was used in the custom software.
Oh what a tangled web.
a. Multiple Developers
First, if the custom software was developed by more than one developer, all developers may be joint authors and owners. One key is whether the developers have independent contractor agreements or IP assignment agreements that assigned any IP rights to code they created to a larger umbrella company that then owns the rights and has the ability to transfer or license those rights. Without written contracts with all developers, there is an IP ownership mess. This is why some clients require a warranty from the developer regarding ownership of the IP being transferred or licensed. A breach of the warranty may negate the contract and lead to hefty damages.
b. Software Development Company Rights
A second issue is whether the software development company even owns the rights to the custom software. A software developer who owns a development company may not have even assigned his rights to his own company. Indeed, the code may have even been created before the incorporation of the development company. Moreover, the software may be sold through a different business entity without an employment relationship or written contract with the software developer.
Warning. A contract between a software development company and a business client may not transfer or license the IP rights to the software if the development company didn’t obtain the original rights from the actual software developer.
Is your head spinning yet?
c. Open Source Code
Third, incorporation of open source code into the custom software may complicate IP ownership even further. Some open source code requires a restrictive pass through license that creates a legal mess. Some clients are aware of this issue and scan custom code to ensure that all open source code is identified and that any underlying licenses are appropriate for the transaction.
The bottom line is that clean IP ownership to custom software requires a written contract and a genealogy of the creation of the code. Without both, IP ownership of custom software will remain unclear.
This post was probably as clear as mud. Any questions about the general information?
For more information about copyrights see the following related posts:
- Copyright Rights and Licenses
- Why Copyright Assignments Can Be Critical for Your Company
- Copyrights, Independent Contractors, & the Work Made For Hire Doctrine
The information provided in this legal blog is not intended as legal advice and does not create an attorney-client relationship. Please do not submit questions or comments seeking legal advice or submit confidential information through this blog. By communicating through this blog, you understand and agree that the information will not be treated as confidential and the publisher has no duty to keep it confidential.