Protection of Software

How software developers and companies protect the intellectual property in the code they build, using copyright, trade secrets, patents, trademarks, and licenses together.

If you write software, the law gives you more than one form of legal protection for it, and the smartest companies use several at once. Copyright protects the way you wrote your code. Trade secret law protects the parts you keep hidden. Patents protect genuinely new functionality. Trademarks protect your product’s name and brand. Contracts tie all of it together. No single one of these does the whole job. Choosing the wrong one, or assuming you’re covered when you aren’t, is one of the most common and expensive mistakes a software business can make.

Here’s how each form of protection works, what it does and doesn’t cover, and how to layer them. That way your rights hold up the day someone copies your product, your lead developer leaves with a copy of the repo, or an enterprise customer decides the license terms were really more of a suggestion.

The five ways to protect software intellectual property

Software is unusual because one product can be protected by several bodies of law at the same time, each covering a different slice of what you built:

• Copyright protects your expression: the actual source code and object code you wrote, plus certain non-literal elements like the structure and organization of the program.
• Trade secret law protects valuable information you keep confidential. For most companies that means the source code and the know-how behind it.
• Patents protect a genuinely new and non-obvious functional invention implemented in software. That means the underlying method, not the code.
• Trademarks protect the name, logo, and brand that identify a product as coming from you.
• Contracts and licenses let you impose your own rules on how customers, partners, employees, and contractors use your software. They often reach further than the statutes alone.

Treat these as layers of protection, not a menu you pick one item from. A typical commercial product is protected by copyright the moment it is created, kept as a trade secret in source-code form, distributed only in object code under a restrictive license, and sold under a registered trademark. For the one or two features worth the cost, it is also covered by a patent. The rest of this page walks through each layer.

Software copyright protection you get for free, the moment you write the code

Copyright is the default and most widely used form of legal protection for software, and the easiest to obtain. It attaches automatically the instant original code is created and saved to a hard drive or any other tangible medium, with no formal application required. The Copyright Act treats computer programs as literary works, so computer software is protected in both source code and object code form. Protection can also reach beyond the literal code to certain non-literal elements, such as the program’s structure, sequence, and organization, where those reflect original expression rather than function.

The critical limit in copyright law is the idea-expression dichotomy. Copyright protects how you expressed something, not the underlying idea, process, system, or method of operation (17 U.S.C. § 102(b)). When courts decide whether one program infringes another, they run an abstraction-filtration-comparison analysis. They break the program into its levels of abstraction, filter out ideas, public-domain material, and anything dictated by efficiency or outside constraints, then compare only what’s left (the approach from Computer Associates v. Altai). What survives the filter is your protected expression.

A few practical points about copyright:

• Copyright protection is automatic, but registration is what gives it teeth. You can’t file an infringement suit until the work is registered. Registering before the infringement starts (or within three months of publication) is what entitles you to statutory damages and attorneys’ fees. Early registration also hands you a presumption that your copyright is valid.
• You can register without giving away your secrets. Registration normally means depositing a copy of the code, which makes companies nervous about exposing their source. The Copyright Office lets you deposit limited portions with the trade-secret material blacked out.
• Copyright won’t stop independent creation. If a competitor builds functionally similar software without ever touching yours, copyright gives you nothing: they wrote their own code. That gap is exactly where patents and trade secrets earn their keep.
• The first-sale and fair-use doctrines cut against you, and reverse engineering of object code to achieve interoperability has been treated as fair use in some cases. Well-drafted licenses (below) are how companies manage those limits on copyright protection.

Software copyright is the broad, cheap foundation of software IP protection. Almost every software company should be registering its important releases and isn’t.

Trade secrets: the right way to protect your source code

For most software businesses, the source code is the thing you’d least want to find pasted into a competitor’s repository. The natural way to protect it is as a trade secret. Trade secret law protects information that derives independent economic value from not being generally known and that you take reasonable measures to keep secret. It’s protected federally under the Defend Trade Secrets Act (DTSA) and at the state level under versions of the Uniform Trade Secrets Act (UTSA), adopted nearly everywhere.

Unlike copyrights and patents, it requires no registration and no government filing. It never expires, so long as the secret stays a secret. That’s the catch: the protection lasts exactly as long as you actually protect it, and not a day longer. The durable strategy for proprietary software is to keep the source code confidential and ship only the object code to customers, under a license that forbids copying, reverse engineering, and disclosure. Done right, you can sell and license your software widely while keeping trade secret rights in the underlying source fully intact.

“Reasonable measures” is the phrase that decides trade secret cases. In practice that means:

• Confidentiality agreements with every employee, contractor, vendor, and partner who touches the code or the know-how behind it.
• Access controls. Limit who can see the source, use need-to-know permissions, and log and monitor who opens what.
• Marking source code and sensitive documentation “CONFIDENTIAL,” so there’s no argument later about whether it was a secret.
• Source code escrow and other selective-release arrangements, with strict restrictions, when a customer legitimately needs assurance of continuity.

If someone misappropriates your trade secrets, the remedies bite: injunctions, damages for your loss and the defendant’s unjust enrichment, up to double damages for willful and malicious misappropriation, and attorneys’ fees. One requirement that’s easy to miss: your confidentiality agreements have to carry the DTSA’s immunity notice to keep the right to those enhanced damages and fees against an employee or contractor. If your agreements don’t have it, fix that today.

Patent protection for software: stronger, higher cost, slower road

A patent is the most powerful form of software protection. It is also the hardest and most expensive to get. A utility patent gives you an exclusive right, the power to exclude others from making, using, selling, or importing your invention. Unlike copyright, it protects the functional application of an inventive idea rather than the specific code. That means a patent can stop a competitor who developed functionally equivalent software entirely on their own. Copyright can never do that.

The obstacle in patent law is patent eligibility. Under the Supreme Court’s Alice and Bilski decisions, software-implemented inventions face a two-step test. First: are the claims directed to an abstract idea, or another ineligible concept like a mathematical formula? Second, if so: do the claims add an inventive concept, something significantly more than the abstract idea and beyond simply running it on an ordinary computer? Claims that just apply a known idea using routine, conventional computing tend to fail. Claims tied to a specific, non-obvious technical improvement have a real chance.

Two practical realities:

• Disclosure is the trade-off. Patents are published and become public, which is the opposite of trade secret protection. The saving grace is that the USPTO routinely grants software patents claimed in terms of functionality without requiring you to disclose your actual source code. That holds as long as the application would let a skilled developer build the invention. You usually don’t have to choose between patenting the method and keeping the code secret.
• Patent protection makes sense selectively. Given the time and cost, they’re usually worth pursuing for the one or two genuinely novel features that give you a real edge. That is especially true where copyright and trade secret protection alone won’t stop a competitor from rebuilding the functionality.

Don’t overlook design patents, either: novel, ornamental icons and screen displays can sometimes be protected as designs.

Trademarks and trade dress: protecting your brand, not your code

Trademarks don’t protect your software. They protect the name, logo, and other source identifiers that tell a customer a product came from you. A strong mark is often one of a software company’s most valuable assets. Trademark rights flow from actually using a mark in commerce, not from being the first to think it up. The federal intent-to-use system, though, lets you stake out priority before launch.

For software companies, trademark and trade dress can cover product names, company names, logos, and sometimes the distinctive, non-functional look and feel of a user interface. If you license your mark (for example, to a reseller bundling your product), you have to exercise quality control over how it’s used. Otherwise you can lose the mark entirely. Clearing a name before you go to market and registering it federally are cheap steps. They head off the kind of forced rebrand that costs ten times as much after the fact.

Contracts and software licensing: the workhorse that ties it all together

Statutes set the floor; contracts are how you build above it. By licensing your software instead of selling copies of it, you can impose terms the underlying intellectual property statutes wouldn’t hand you on their own. Courts have enforced those terms again and again.

Most commercial software ships in object code only, and software vendors license it under a license (including shrinkwrap and clickwrap agreements) that:

• Grants a narrow, defined license instead of transferring ownership of a copy.
• Imposes confidentiality obligations and prohibits copying, modifying, and redistributing the software.
• Prohibits reverse engineering and other attempts to reconstruct your source code.

This matters because a license lets you contract around statutory limits like the first-sale and fair-use doctrines that would otherwise cut against you. Courts have enforced contractual reverse-engineering bans and upheld “you’re a licensee, not an owner” terms (as in Vernor v. Autodesk and Bowers v. Baystate). And a breach-of-contract claim isn’t preempted by copyright law, because it requires proving extra elements like mutual assent and consideration. Your license gives you a separate, independent path to enforce your rights. That is the same path that decides cases like a software licensing dispute or a customer recreating software to dodge a license.

A word of caution on open source software: depending on the license, pulling open source components into a proprietary product can trigger an obligation to release your own source code under those same open terms. The code you meant to sell ends up free for anyone who asks. Keep an inventory of the open source you use, read the licensing terms before you ship, and keep copyleft-licensed code out of anything you intend to protect.

Protecting software when people leave

A large share of software disputes have nothing to do with outside pirates. They start with a founder, employee, or contractor who walks out and takes the code, the documentation, or an unresolved argument about who owned it in the first place. The protections above only work if ownership was nailed down at the start:

• Get IP assignments in writing. Employee and contractor agreements should clearly assign all rights in the work to the company. Independent contractor work in particular does not become yours automatically without an assignment. That is a gap you tend to discover the week the contractor’s lawyer sends a letter.
• Use confidentiality and invention-assignment agreements consistently, with the DTSA immunity notice included.
• Manage departures on purpose. Recover devices and credentials, remind the departing person of their continuing confidentiality obligations, and write down that you did.

These are exactly the situations that turn into litigation over a software developer’s rights and founder exits involving software IP. The cheapest time to fix an ownership problem is before there’s a dispute.

How to put the layers of software IP protection together

There’s no single right answer for protecting intellectual property in software. The right protection depends on what you’re protecting, how much disclosure you can stomach, and what you can afford. As a starting framework:

• Register copyrights on your important releases. It’s cheap, broad, and it’s what lets you sue and collect statutory damages.
• Protect your source code as a trade secret. Keep it confidential and secure, distribute object code only, and lock it down with agreements and access controls.
• Patent selectively. Reserve the time and expense for genuinely novel functionality that copyright and trade secret protection can’t reach.
• Clear and register your trademarks before you launch.
• Make your licenses and your employment and contractor agreements do real work. They’re what let you enforce everything above.

Software disputes are rarely won on a single legal theory. They turn on whether you built your IP protection on purpose, or just assumed you had it. If you’re not sure where your software IP gaps are, that’s worth a conversation with experienced software counsel before a problem forces the question for you.

Frequently Asked Questions