When you decide to create a mobile app for your business, it can be hard to understand where the code is coming from and who owns what part of it.
Your business needs to ensure your proprietary ideas are secure and wholly your own, but if you are unsure how code ownership works, understanding who owns your business’ proprietary ideas may not be as straightforward as it seems. This overview will guide you through the ins and outs of code ownership and help your business determine if owning code is necessary for you.
There is also a lot more to the intellectual property of a company than the bits and bytes of source code and the mobile app it drives.
How does code ownership work?
Code ownership has evolved over the years. Back in the 1970s, most applications were written from scratch, so code ownership was a lot more straightforward. Today things are a bit more complicated since most things are the work of much larger teams and may incorporate open source, 3rd party libraries and generally get quite large. The basic principle is the same: when someone writes some code, as with any other creative endeavor, the author is the initial owner of the creation. In a business context the code typically becomes the property of the business through the contracted agreement with their employee, contractor, or development company that writes the code.
To create an app today, very little your app’s functionality is written from scratch – it could be as little as 5% – the rest is built upon what is already established. Instead, the complete final project includes code written in house, APIs available via the mobile operating system, open source components, commercial libraries, and–in a growing number of cases–cloud services. Looking into the three different possible sources of the other 95% of code can give us a clearer picture of code ownership.
3 ways code to manage ownership of code that you did not directly write
Open source code products give you permission to use, modify, and redistribute the code that you have access to. This is the primary way people gain access to reuse other developers’ code in their projects, and the adaptability of open source code creates greater collaboration between developers.
While there are many variations to open source, these are the two primary approaches:
Very few restrictions: MIT, Apache, or similar licenses allow others to license the code without any limitation other than retaining the author’s header in the source. The resulting product can be used for any commercial purpose.
More restrictions: Licenses that allow usage of the code but put some limits on what you can do. The best example is the GPL license, known as the viral license, which requires that any derivative work created from the source must also be released in full as open source.
While the original author is the copyright holder and owner of the code, open source licenses allow others to utilize the code for free. The benefit of open source code is helping to provide the building blocks for others to create bigger and better solutions within a community to have better coding solutions in the future.
Unlike open source code, most commercial creators do not want to provide their work to others. However there may be some commercial benefit from allowing others to review and audit the code. Visible source code is a compromise: specific parties can look at the code but cannot use it or disclose it. This can help ensure that there are no security exploits or other issues with the code while still maintaining its value. This approach also allows collaboration between companies to build tightly integrated systems or services. In this case, the owner retains control over the code.
Source code escrow
If you are using a commercial system, platform, or no-code solution–which is a service that you license to create a new configuration of pre-existing app code–and they go out of business, what happens to the code? This question could be an important one for your business continuity or for critical systems viability.
In those situations, source code escrow is the answer. Source code escrow is a fail-safe that offers your business a way to move forward without the original developer. It is a legal agreement which guarantees your business use of the existing code if something happens to the developer or service provider so that you can continue maintaining the code they developed for you. Ownership of the code would still belong to the original entity, or their survivor, but you would retain the right to use the code to operate your business. This type of agreement can happen between your company and a company which makes code specifically for your use or with an app company that provides the same code framework to many companies, in which case multiple clients are all receiving the source code to continue their operations.
Source code escrow is a great way to ensure continuity, particularly when working with smaller service providers.
Who owns the code when you create a mobile app with no coding?
Creating a no-code mobile app means engaging with a service so that you can get all the features you want on your app without needing to hire a developer or learning to code yourself, which is why it has become a popular way to lower the barrier to entry on mobile apps for businesses. But when your business isn’t doing any coding, you also won’t own code for the app. Since most apps only use about 5% of original code, not owning the code isn’t a huge difference.
However, not owning the code doesn’t mean you don’t own a stake in your app. When you create a no-code mobile app, you own the configuration of the features of the application and your content. Building your configuration on an existing library or code service, called a walled garden platform, can be risky; if the platform goes out of business, your app will not be functional as just a configuration without a platform. In cases like this, it is important to have a clear understanding of code escrow to ensure the continued functionality of your business’ app.
Is it important to have ownership of your app’s code?
While it somewhat depends on your app idea, for most businesses it isn’t important–or even possible–to own all your app’s code. Only a fraction is written from scratch, and a lot of it uses collaboration to improve on what already exists. Trust and intellectual property are the two main factors in deciding if owning code is necessary for your business.
In some situations, such as working on a top secret government project or developing a new highly secure payment system, having the business or government directly own the code is the best choice. Still, even large companies, like Netflix, don’t own their web or mobile app’s code because it isn’t important for their business to do so. Netflix built on Amazon Web Services to create their platform, and while delivering high speed and quality videos is part of their business, their brand and content is more valuable than the video delivery code. Netflix trusts that AWS will continue operating as a platform while Netflix retains the right to their intellectual property.
Another important consideration is that without constant maintenance and upkeep freshly written code, like fresh produce, will start to rot. The tools, languages and libraries used to create code are constantly moving. Even if an app is perfectly bug free and fully supporting every possible feature it will require modifications and upgrades to keep it running on the latest platforms.
What should you focus on owning?
Code ownership isn’t as straightforward as someone learning to code and sitting down to type. The prevalence of open-source code and walled garden platforms has created a highly collaborative environment where developers are constantly working to improve others’ work. With the majority of code in apps today being recycled from other sources whether you hire a team of engineers or use a no-code solution, you aren’t going to own much code.
The business value in having an app doesn’t come from the code itself but the power of your idea, your brand and your customer relationships.