Updated October 21, 2020:

What is Intellectual Property for Software?

Intellectual property for software is computer code or software protected by law under either a copyright, trademark, trade secret, or software patent.

Why Intellectual Property for Software Is Important

Software innovation is valuable to individuals, start-ups, and businesses. The law is the best way to protect material such as software. To use the law as protection, programmers and businesses treat software as intellectual property.

When you treat your software as intellectual property, you have more control over who gets to use it and how it gets to the public. Otherwise, people might use it without permission, and you'll lose the chance to get paid when people use your software. In extreme cases, you might lose the right to use the software you created.

What Is Intellectual Property?

Intellectual property (IP) is a piece of work that isn't a tangible object. IP usually comes from creativity and could be a manuscript, a formula, a song, or software. Under the law, copyrights, trademarks, trade secrets, and patents protect IP.

IP Theft

Both businesses and people have problems protecting their IP. Businesses with valuable IP like software have to watch out for theft from employees. Theft that happens from outside the business occurs, too, but not as often.

Having employees sign Non-disclosure Agreements is one way to protect company IP. Restricting employee access to IP like the software in development is another way. The book "IP & Computer Crimes" by Peter Toren includes a lot of information. It covers these crimes and how to protect against them.

Another way to protect IP is to use the law to protect it. That means getting a patent, copyright, or a trademark. Then if someone does steal your property, you have legal grounds to prosecute.

Ways to Protect Software

When you want to protect software IP, both a copyright and a patent offer legal protection. Each option covers different parts of IP protection. Some people prefer one or the other, while others go for both. Alternatively, you can choose to treat your software as a trade secret. Deciding what to do is an important step in protecting your software.

Trademarks are another option, but they don't protect your IP software code. What they protect is the name of the software or a symbol you use to advertise the software. Trademarking your software's brand name is a good way to keep others from marketing a product under a confusingly similar name.

Protecting Software Through Copyrights

Copyright law defines copyright as: "original works of authorship fixed in any tangible medium of expression." You can find this quotation and a longer definition in section 102 of U.S. Copyright Law. So the way you express an idea, like a work of fiction or software in code, falls under Copyright law.

The Copyright Act, 17 U.S.C. § 101 calls computer programs "literary works."

What Copyright Protects

  • Against word-for-word copying
  • Internationally, as soon as you create it

Registering your copyright with the Copyright Office is a good idea for legal purposes.

Rights Granted by a Copyright

A copyright grants you specific rights in terms of your software. When you hold the copyright to software code, you can:

  • Make copies of your software code
  • Sell or give away the code
  • Make a "derivative work," which is a second software that uses a lot of the original code
  • Post the code somewhere, or otherwise display it

An official copyright registration is easy to get and doesn't cost you much. It can cost as little as $35 and only takes about four months.

Copyrights last for the lifetime of the person who created the work, plus 70 years after that person's death. If you're copyrighting something you bought from a person you hired to create it, the copyright lasts for 95 years after you first publish that work, or 120 years after the work is created, whichever comes first.

Does Registering Your Copyright Make Your Code Available to the Public?

Some programmers worry about sending the code to the U.S. Copyright Office. If it's at the Copyright Office, you might worry competitors can look it up and take copies. However, you only have to send the first 25 pages and the last 25 pages, to identify your software. If you have trade secrets in the software, you can black those out.

Stealing from the software is more complicated than just plagiarizing because the software is more than just code. Software is an invention or an idea. Copyright law only protects how that idea is written down. Because a software program does something specific, protecting against copying might not be enough. Someone could use different code but still steal your invention.

Protecting Software With a Patent

To protect a process, like the function of software, you need a patent. A patent will protect things like:

  • Systems
  • Functions
  • Solutions to computer problems

You can use two types of patents to protect software: utility and design. Utility protects what the software does. Design protects any decorative part of your software.

Unlike copyright law, patent law protects the invention itself. That way, someone can't create a software program with different code that does the exact same thing your software does. But the patent doesn't protect your specific lines of code against plagiarism the way copyright does.

Keep in mind: you register your copyright, so you aren't applying for anything. You do apply for a patent, which means you might not receive the patent.

If you include information in your published patent application, that information is no longer a trade secret.

Things to Consider Before Applying for a Patent

  • Patents last for 20 years after the day you receive the patent. Then the work goes into Public Domain.
  • If you patent solving a specific problem, you might block other programmers from solving the problem in a different way.
  • Getting a patent can take as long as two years. 
  • Filing with the U.S. Patent and Trademark Office (USPTO) can cost $1,000 to $3,000.

Getting a software patent has been the subject of lots of legislation, including Supreme Court cases. The precedence for software patents isn't always clear, making getting a software patent even more difficult.

Patents at Home Vs. Abroad

A patent in the U.S. is only valid in the U.S. If you need a patent in other countries, you have to apply in each of those countries. Because patent law is different in every country, what gets you a software patent in the U.S. might not qualify in another country, or vice versa. 

Protecting Software as a Trade Secret

A trade secret is information you or your company has that other people don't have. You use this information in business, and it gives you a leg-up over your competition.

You don't file any documents or apply with an office to get a trade secret. Instead, the way you treat your software can make it a trade secret. You have to take "reasonable measures" to keep the software a secret:

  • Keep the software away from the public.
  • Have employees sign non-disclosure agreements.
  • Have employees sign non-compete agreements.
  • Do exit interviews with employees who are leaving to make sure they aren't bringing IP with them.
  • As soon as an employee quits or is fired, take away all their file and data access.
  • Investigate any suspicious employee activity.
  • Keep IP data stored in compartments, and only give access to employees who need it.

You can maintain a trade secret for as long as you want. Unless someone discovers your secret by what the law calls "fair means," your trade secret will last forever. If someone else discovers, on their own, a trade secret similar to yours, you can't take legal action. Sometimes companies and individuals don't see trade secrets as secure enough protection for valuable software inventions.

One difficulty with copyright and software comes from companies who hire software developers. Usually, copyright law says that whoever creates the work owns the copyright. However, the law also contains language to cover work-for-hire.

Employees and Work-for-Hire

If you are an employee of a company, and you create software for that company, the company owns the copyright.

17 U.S.C. § 101 states that IP that's part of a bigger collective, like a motion picture, is a work-for-hire. That gives the company copyright ownership of the code, not the individual who created it.

Some other work you might hire independent contractors to do automatically falls under "work-for-hire":

  • Part of audiovisual work
  • A translation
  • Supplementary work
  • A compilation
  • A test or test answers
  • An atlas
  • A set of directions

Independent Contractors

If you work as an independent contractor, you own the copyright to your work even if you create it for a company. You and the company have to sign a contract stating they own the copyright to change that, or you can license your software to the company instead of handing over the copyright. Whether you're a business or an independent contractor, it's best to get these details out of the way before work starts.

Who owns the copyright of software matters because of what copyright allows you to do with the code:

  • Reproduce it
  • Give it away or sell copies
  • Post the code somewhere (like on a website)
  • Make what the law calls "derivative works"

A license allows another party, like a business, to use the software you developed. Handing over the copyright, or assigning the copyright, gives them legal ownership of the copyright. No matter which side you're on, your contract needs to be specific.

Using Contracts and Licensing to Protect Software IP

Copyright and patents both have limits as far as how they protect software IP. To fill the holes, many people use contracts and license agreements.

  • Instead of selling software, you can license it.
  • A license protects your software from someone who might want to reverse-engineer, copy, or hand it out.
  • Have a legal professional draft your license to make sure it covers everything.
  • Some people challenge licenses in court, but courts usually rule to uphold licenses.

One problem with licenses is getting people to agree to them. If someone uses your software who did not agree to the license (like by using software someone else purchased) then they aren't bound by it. You can go after the person who violated the license by letting a third-party use the software. Using the license to protect your software against someone who didn't agree to it, however, is very difficult.

History of IP Software Law

Software as IP has a stormy history, with most problems coming from software developers seeking patents for their software. The question of whether or not the software can receive a patent is a complicated one, which Supreme Court cases can't even completely answer. In fact, lots of people still believe that you can't get a patent for software.

Unpatentable things include the following:

  • Computer programs
  • Rules for playing games
  • Business methods

If computer programs can't get patents, then how can software? The words "as such" appear with this list of unpatentable things. The "as such" means that if you create something that qualifies as a "technical invention," but it still appears on this list, you can patent it.

British patent law stayed basically the same from 1623 until 1977. In 1623, a patentable invention had to be a "new method of manufacture" according to the Statute of Monopolies.

When the U.K. became a member of the European Patent Convention, that manufacturing-based definition of patentable invention changed in the country. During the 60s and 70s, ideas about patents were changing, but computers weren't the driving force they are today. People didn't think about software very much (or at all) when putting together new patent literature.

At the time, the European Patent Convention copied the Washington Agreement (also known as the Patent Cooperation Treaty). They excluded computer programs from patentable inventions because computer programs were too complicated for patent officers to review. But banning all computer programs might mean that some of the best computer inventions couldn't get patents, so they added "as such" to the language.

The Boards of Appeal for the European Patent Office had to answer questions about the "as such" language not long after. They dealt with a Vicom patent application to do with image software. Guidelines about software patents came from their decision.

  • Programs need to have a "technical effect."
  • If they don't do anything novel or non-obvious, then running a program isn't technical enough to qualify.

Court cases started to define the details.

  • Software patents. Gale's Application talked about a software invention that could have met the patent criteria. In fact, computer experts find his method very useful. However, Gale didn't write the application very well and failed to prove that his computer program fit the definition of patentable. Thus, it was rejected in the Court of Appeals.
  • Computer programs. The EPO gave IBM a patent in 1997. Their actions set a precedent for giving patents to programs that solved technical problems when you run the programs on computers.
  • Business methods. In 2006, the British Patent Office veered from the EPO's decision. Instead, the BPO said business methods aren't patentable. Lots of software can be called a business method. Eventually, a case including plaintiffs like Astron Clinica went to the High Court. The BPO changed its policy as a result.

Difficulties With Patenting Software

The difficulties around software patents stem from the definition of what is patentable.

The United States does not consider three things to be patentable:

  • Abstract ideas
  • Natural phenomena
  • Laws of nature

When you patent software, it has to meet lots of USPTO and legal criteria. That's why not all software qualifies for a patent. The most important include:

  • Your software has to be useful or have a specific application.
  • It has to be new.
  • It has to have an "inventive step" that is not obvious to people in the field.

You can't patent an algorithm on its own because that's an abstract idea. But if the algorithm has a specific purpose and application in the software, then the software may qualify for a patent. If your software solves a specific technology problem in a way you can discuss in detail, then you could qualify for a patent. An abstract idea (like math or an algorithm) that creates a specific or tangible result can qualify for a patent.

Abstract ideas are where most software patent applications run into trouble. Proving that software is not an abstract idea, but qualifies as an invention, is difficult. That's why so much recent legislation has focused on the subject.

Examples of successful software patents:

  • Amazon "One-Click-Buy" software, U.S. Patent No. 5960411
  • The mp3 audio software, U.S. Patent No. 5579430

Alice Corporation Pty. Ltd. V. CLS Bank International et al.

In 2014, the Supreme Court ruled on the Alice Corp V. CLS Bank ("Alice") case, which covered software patents and abstract ideas. The ruling was that the software in question was an abstract idea and therefore did not qualify for a patent. The Alice ruling has made getting software patents more complicated and has invalidated some software patents already granted.

Unfortunately, the Alice ruling didn't talk about what kind of software can get a patent.

What About Agile Software Development?

Traditional software development involves a series of five steps. A developer completes the first step before moving to the second step or before handing the software off to another developer. The people working on each step don't usually communicate. Clients and customers don't see the software until the developers are finished.

Agile software development doesn't follow a sequence like traditional software development. Instead, developers work together on different parts of the project, communicate as the software evolves, and solve problems as they appear. The developers do this in bursts of work called "sprints." Clients or customers also see the partly finished software.

In a traditional software development environment, IP is easier to figure out. Defining who worked on which piece of code — and therefore owns it as IP — is relatively straight-forward.

IP Problems in Agile Development

Agile development happens more quickly than traditional software development. The fast pace, combined with the teams of people working very quickly, makes it difficult to figure out where IP belongs. Plus, the pieces of software that professionals develop during agile development might only be parts of code and might not function on their own without the rest of the software.

Identifying IP software is important to copyright, trade secret, patent, and trademark. The question of legal ownership gets more complicated when IP gets lost because of development methods.

Common issues add to the difficulties in identifying IP during agile development:

  • A short development cycle
  • Less time to think about or document possible IP created during the cycle
  • Lots of people working on pieces of the same code
  • Difficulty seeing how small innovations during different work cycles fit together to create IP
  • Less communication between the developers and company lawyers who could advise about IP

IP Solutions and Techniques in Agile Development

An agile development cycle still produces IP that you or your company can protect. However, people using agile development have to adjust the techniques they use for finding and detailing IP.

  • Have employees and contractors sign nondisclosure agreements.
  • Make sure employee and freelancer contracts include clauses about who any IP produced belongs to.
  • Create security measures around every project, like document management and data backups.
  • Encourage your employees to be inventive by recognizing their innovation with awards or bonuses.
  • Mark in-development projects with copyright notices to add extra protection.
  • Treat your projects like trade secrets by adding trade secret protocols around developing projects.
  • Store in-development projects away from non-secret projects.
  • Teach your employees about trade secret practices.

Client Feedback: A Third-Party Agile Development Solution

In agile development, the client or customer gives feedback on the unfinished software. Protecting IP while showing it to a client is difficult.

Before you start agile development for a client, include a nondisclosure agreement or a product advisor agreement. A "feedback clause" within these agreements says that any ideas or feedback that the client produces is free for the developer to use, keeping the client from being able to claim part of the code as their IP.

Filing for Patents During Agile Development

Some companies start filing provisional patent applications during agile development. A provisional patent application gives you a filing date for your patent, but it isn't your full application. It gives you a year to create the non-provisional application, which is your published patent application and can lead to your approved patent. Provisional patent applications are a way to protect software that's in development while you show it to clients.

Useful Intellectual Property for Software e-Forms

Patent Application (provisional and non-provisional)

Copyright Registration

Trademark Application

Contact an Attorney

Getting legal protection for your IP software is a complex process. Start the process with a competent lawyer on your side. You can post your software patent or other legal needs here and get free custom quotes from the top 5% of lawyers on UpCounsel with an average of 14 years of experience.