Software Development: How to Protect Your Intellectual Property?

March 09, 2020 / Bryan Reynolds

Reading Time: 8 minutes

Technology plays an increasingly important role in our lives, especially in areas such as shopping, customer service, and social interaction. Anyone building a business today should be looking for ways to innovate their online marketplace, whether it’s simply streamlining existing processes or actually disrupting them. However, innovation is particularly challenging when software development isn’t one of a business’s core competencies.

These businesses must source their software development initiatives, but the demand for tech talent is greater than its available supply in many countries. In these cases, a business must turn to international outsourcing, which presents its own difficulties. Outsourcing often provides a short-term solution to the immediate need for software developers, but the protection of intellectual property (IP) should be a matter of great concern for any business owner considering this option.

Outsourcing software development generally involves handing a business idea over to a potential competitor. Your company therefore needs to begin develop its strategy for protecting its IP before even considering outsourcing. Documenting this strategy in a business plan helps ensure that IP remains top-of-mind for your company.

In cases where a tech-based business is just getting started, IP protection should be a critical component of the company’s business model. This is especially true when the business is based on a truly unique idea, as preventing the duplication of that idea is essential for the company’s survival. IP protection is also useful helpful for monetizing an idea, typically in the form of licensing when it comes to software development.

The methods used to protect IP may be generally categorized into contracts, patents and restrictions on the use of existing IP.

Source: Statista

Vetting Partners

Vetting prospective partners is an essential practice for protecting IP, as incompetent vendors are often the cause of IP compromises. This process primarily consists of detailed research to ensure vendors have the knowledge and experience they claim. A number of websites such as Clutch and Goodfirms review businesses and rank them based on client feedback. They may also provide information on a vendor’s previous projects. Furthermore, vendors’ portfolios can provide valuable insight on whether they specialize in technologies that have become outdated.


Contracts are a way for organizations to mitigate their business risks. A well-crafted contract is essential for protecting IP when hiring anyone related to software development, even if it’s a single freelance developer. It becomes even more important when hiring internationally, because it must be enforceable in all the involved countries. You should typically use an attorney in the developer’s home country to write the contract, but you may also need to consult with attorneys from other countries to ensure it will be binding on all parties. This step is necessary because the laws regarding IP vary greatly between countries.

IP protection should be one of the most critical parts of an outsourcing contract for software development. In particular, the contract should clearly state that your company owns the software developed during the project, including source code, documentation and any other related materials. It should also specify that you’ll receive all these assets once the project is completed. As the owner of the software, you can use and modify it however you want.

Types of Outsourcing

An outsourcing contract with a software developer should also provide information about the services the developer will provide, including project scope and the procedures for making changes. Additional details about the project such as development phases, deadlines, deliverables and costs are also essential parts of any software contract.

Outsourcing contracts may be classified into two types, including fixed price and time and material. A fixed price contract requires you to establish the project’s total cost and scope in advance, and it also specifies the costs of any deviations from this baseline. A contract based on time and materials specifies the hourly rate for each developer, allowing the hiring company to pay for the work by the hour.

A time-and-materials contract is standard for software development outsourcing due to its greater flexibility. Detailed specifications are particularly difficult to develop in advance for this type of work because its scope often changes over the course of the project. It’s therefore impractical in most cases to attempt to specify all aspects of the project in advance.

Non-Disclosure Agreements

A non-disclosure agreement (NDA) is a legal document that prevents the signing party from disclosing certain information to third parties. In the case of software development, this often includes the software’s design and technical data as well as information about the pricing policies and marketing techniques for the software. Information about the software owner’s customers and vendors are also commonly included in an NDA.

An NDA can also provide general protection for an idea test by preventing others from using it. Furthermore, an NDA remains in effect after the project is complete, which is why it’s used so often. Companies frequently require a potential partner to sign an NDA to discuss an idea before a contract is in place.

Specificity on the exact information you wish to keep confidential is the key to a successful NDA. However, the NDA should still cover the entire scope of the outsourced contractor’s work. This approach allows the company to use a single template for every hire, which it can then modify appropriately to accommodate specific requirements.

Once the business relationship with outsourcer ends, the company should remind those contractors about the exact information they’re obligated to keep confidential. This event typically takes place as part of an exit interview.

Employment Contracts

Employment contracts are a standard requirement for most large companies, especially software developers. While workers frequently sign an NDA as well, it doesn’t take the place of an employment contract. This is especially true when the prospective employee lives in a different country. Any well-written employment contract should contain clauses to address several common issues, such as dispute resolution, work for hire and compensation. Employment contracts for software developers may also contain more specific clauses such as IP assignments.

Source: United States Patent and Trademark Office

Dispute resolution clause

A dispute resolution clause specifies the laws that will apply there is a dispute regarding the contract. In particular, it indicates the jurisdiction that will adjudicate the dispute. This clause provides a strong starting point for protecting your IP. However, it’s also critical that your attorney work with the contractor’s attorney when developing this clause, especially when the two parties are from different countries.

The terms of a dispute resolution clause are often influenced by the current demand for the contractor’s services. Contractors will certainly consider the likelihood of obtaining work from other clients when deciding if they’ll agree to the terms in this clause. Your willingness to offer fair terms in the event of a dispute can also make your business more attractive than your competition for creating long-term relationships with contractors.

Work for hire clause

A work-for-hire clause specifies that all work that the contractor performs is considered “Work Made for Hire” as defined by US copyright laws. This clause essentially means that the hiring company owns all the work and is considered the author of that work even if the contractor actually created. In the case of software development, the contract should also specify that the work-for-hire clause applies to software.

The source code itself is generally considered to be a trade secret, while the executable code is usually treated as copyrighted material with respect to publishing, sharing, licensing and selling the software. Owners therefore need to protect their software in a manner similar to that used to protect books. In other words, the software owner typically maintains source code internally as a trade secret while protecting the software’s functionality as copyrighted material.

Compensation clause

A contract generally must provide consideration for both parties to be binding. This concept may be known by various terms such as quid pro quo or a bargain for the exchange of values, depending on the jurisdiction. In other words, compensation is necessary to ensure that the relationship specified in the contract isn’t one-sided. Compensation doesn’t necessarily need to be money, however; many startups offer only equity in exchange for the developer’s services. Regardless of the specific type of compensation that you’re offering, the contract must clearly indicate its details.

IP assignment clause

Some contracts may contain an IP assignment clause that indicates that the hiring entity will own any work generated by the contractor. This clause may be necessary if the concept of work for hire is absent or inadequate in the applicable jurisdiction for that contract.


The protection of software IP rights is often challenging because it can occur under multiple legal categories, including copyrights, patents and trade secrets. Furthermore, various components of software may fall under different categories, which can make the definition of derivative works particularly difficult. For example, the European Council Directive 91/250/EEC on the Legal Protection of Computer Programs, WIPO Copyright Treaty (WCT) and World Trade Organization’s (WTO’s) TRIPS Agreement all assume that source code is a literary work subject to copyright protection.

This view is complicated by the fact that different source code can provide identical functionality, meaning that different applications can do the same thing. Different jurisdictions have contradicting interpretations on the issue of whether copying an application’s functional elements is a copyright infringement. Generally, the copyright of literary works doesn’t fully apply to software functionality or works derived from that functionality.

Companies therefore turn to patents to protect IP related to software, resulting in the filing of many patents related to software. For example, the European Patent Office (EPO) and United States Patent and Trademark Office (USPTO) both issue tens of thousands of patents to software developers each year. It’s in the best interest of software developers to explore all possible patents for their ideas before starting to develop the software because patent law has a concept known as a “limited patentability threshold.”

This concept means that nearly idea that can be implemented on a computer can be patented, provided it meets certain technical requirements. However, international copyright law generally doesn’t allow generic ideas to be patentable. Take Kanban boards, for example. Many project management applications provide Kanban board functionality, but you wouldn’t be able to patent a Kanban board by itself. However, you could patent a particular implementation of a Kanban board. Exploring patents is thus an effective way to protect IP, considering that 23 percent of all patent infringement suits are based on computer hardware, software or electronics.

“Global Trademarks and Patents” Source: World Intellectual Property Organization


The approach that a company uses to develop software can dramatically affect the method it uses to protect is IP. For example, a large enterprise is more likely to develop customer software from scratch, while smaller companies are more likely to build on top of existing code. This approach often uses open-source software, which generally grants users full rights over any new software they develop based on the original source code. Many developers publish open source software, but this type of distribution license doesn’t always cover a particular developer’s use case.

In all these scenarios, it may be necessary to purchase existing source code to develop a new application. This occurrence makes it imperative to determine the legal rights you have over the purchased source code. In some cases, you may have the right to modify the code and use it but prohibited from distributing it to third parties. It’s also important to understand when the relevant IP legislation considers the modified software be a new product.

Images present unique challenges in IP protection because they may qualify as artwork, which is regulated by more mature legislation than software. Images that are derived from other designers can thus cause more problems for software developers than infringing on source code. Stock images are generally available at no charge, but the exact terms of their use can vary greatly. For example, the licenses for some stock images require attribution while others prohibit the use of the image for any commercial purpose. The use of fonts is even more varied, with some licenses limiting their use to a particular number of users or computers.

Third-party information such as booking prices, pricing lists and tickets may qualify as IP, even when the information itself is public. A service provider’s terms of use may prohibit anyone from using this information in a software application. Other providers may only require attribution to use their information.

The placement of source code for customer software provides another consideration on the use of IP. If you host the source code yourself, you simply need to decide how to transfer its usage and ownership rights to end customers. However, if another party hosts the source code, you must take additional measures to prevent the host from developing a similar application.


The protection of IP is more challenging for software because these laws are still evolving. They often try to classify software with older types of IP such as artwork or literary works. However, many common scenarios fail to protect IP as well as it should. The most effective strategies should still focus on the traditional methods of contracts and patents, even when it seems like you’re going overboard with them.