Signed Contract Ensures Software Ownership

The Business Review Few businesses these days could survive--yet alone, thrive--without computer software customized to meet their special needs. It doesn't matter what kind of business is involved--manufacturing, insurance, health care, engineering, architecture, or even law--customized software often provides the needed edge in today's marketplace. Moreover, in today's technical business environments, a custom-built software package often may be considered one of the most important assets of the business. While customized software packages can cost tens of millions of dollars and be sold by such well-known companies as IBM and Electronic Data Systems, the more common situations involve relatively small software consulting firms, often comprising only a few "entrepreneurial" computer system developers trying to make a living in a very competitive field. Therefore, it's not surprising that an unusually high number of both software developers and software "purchasers"--that is, businesses that hire outside consultants to write software--often overlook the question of intellectual property ownership when entering into a software development contract. Unfortunately, when such neglect occurs, one of the parties later may learn that what it bargained for is not what it received. There is no single reason why the question of ownership rights is not properly dealt with in software contracts. Instances in which the issue is overlooked include the case where a seemingly small software job (in which ownership is not so important) evolves in time into a larger project without ever being reduced to a written contract. Other times, incorrect assumptions regarding intellectual property ownership are made. In still other cases, the software component of the project is less predominant than the hardware component, so little attention is paid to software rights. Then it is not until some dispute occurs, or it is recognized that a substantial and valuable software product has been developed, that the issue of ownership is examined. By then, it is often too late for one of the parties. The real problem often comes to a head when one of the parties looks to resell or sublicense the software. For the software purchaser, this may occur when the business looks at expanding and using the software at new sites, or entertains the idea of being "bought out." For the software developer, it typically occurs when he or she realizes that the developed software has tremendous resale potential. In cases where the issue of software ownership was not addressed, one of the parties may simply be out of luck. Before proceeding with how to settle, or better yet, prevent such situations, one must first understand what it means to "own" software. Software rights really can be "owned" only under the legal principles of copyright, patent and trade-secret law. It should be recognized that ownership rights under these three areas can become extremely complicated. For example, it is possible for one party to own the copyright for a piece of software, while another party owns the patent rights, and still a third party owns the trade-secret rights. Moreover, it also is possible for certain ownership rights to be shared under any one of the above principles. Among the three, copyright ownership is by far the most pervasive--and often the most important--form of software ownership, because copyright protection attaches to any original piece of software as soon as it is written down in any tangible form. Alternatively, acquiring patent and trade-secret rights requires additional steps to be taken by the author. It is for the reasons stated above that the largest area of concern for most custom software developers and purchasers involves the question of who owns the copyright in the developed software, as opposed to who owns just a copy of the developed software. This is of critical importance because it is the copyright owner who has the right to sublicense the software and/or prevent others from using or selling it. In contrast, the owner of a copy of the software typically is limited to using the software only at a single location. A basic principle of copyright law is that copyright initially vests in the author of the work. When dealing with software, this fundamental principal really has only two exceptions. The first exception involves the case in which a signed contract exists between the parties that assigns the rights from the software developer (the author) to a third party. The second exception involves the case in which the software developer is considered to be an "employee" of the business. This second exception is referred to as a "work for hire." The first exception is fairly straightforward. The Copyright Act states that title to a copyrighted work, in most cases, can be transferred only with a signed writing (by the author) that expressly states the terms of the transfer. For example, the written statement, "I, Joe Smith, hereby assign all right and title in the computer program identified herein to Sally Smith, s/Joe Smith," probably would be adequate to transfer ownership. Alternatively, things such as unsigned writings, oral contracts and understandings will not act to transfer copyright ownership, regardless of the intent of the parties involved. While it is possible that something less than full title (for instance, a non-exclusive license) may be transferred or implied without a writing, both a non-exclusive license and an assignment of ownership almost always require a signed writing. With regard to the second exception, the software is considered to be a "work for hire," thereby causing title of the copyright to belong to the software purchaser if, and only if, the developer was acting as an employee of the software purchaser. Determining whether or not a developer was acting as an employee of the software purchaser can be subject to a somewhat complicated analysis. The analysis typically is based upon the common-law notions of agency, which include a variety of factors and may differ from state to state. The Supreme Court has held that an employee in the "work for hire" statute means a "bona fide" employee. New York courts generally have interpreted this to mean that the developer must be receiving employee benefits and be treated by the purchasing business as an employee for tax purposes. Thus, at least in New York, the employee "work for hire" exception is fairly narrow and rarely will apply to outside consulting firms. Therefore, between a consultant and a software purchasing business, copyright ownership typically belongs to the consultant unless a signed contract exists. In such cases, the software purchasing business usually will own a single copy or a non-exclusive license in the software. In summary, the best way to assure ownership rights when contemplating a development effort that involves customized software is to have a signed contract that clearly addresses the issue. Hoffman is a patent attorney with the intellectual property law firm Schmeiser, Olsen & Watts in Colonie and specializes in computer-related inventions and legal issues. need a loan fast with bad credit bad credit personal loans for