Should my software be open-source? Commercial Open Source Software models.
I am working on a SaaS software that I will be launching soon, and as an open-source contributor and enthusiast, I was wondering if it should be open or not 🤔. I collected a few notes about this during my research and realized that many people were wondering the same. So, I thought this might be useful for other people too. Here is what I learned from my research.
Let's start by saying that making your software open-source makes more sense in three scenarios:
- Your audience is developers or related technical roles. This will increase adoption.
- You want to appeal to medium-big customers. Open code makes it easier for them to try and use your software and helps them with data privacy and compliance. Like PostHog.
- Your users would benefit from self-hosting and a flexible, open, and accessible product. Like Cal.com.
However, there are many drawbacks like more difficult monetization and rip-offs. If you are unsure about it, please read this article by the founder of Cal.com: https://cal.com/blog/open-source. It is great at explaining when to make your software open-source.
How do you make it open?
I identified a few variants of open software. There is open-source software (OSS) that tends to be more liberal. There is free and open-source software (FOSS), free like libre not just like gratuitous. And there is open-core software which is a mix of open and restrictive licenses. Here is a high-level overview of them.
FOSS (Free and Open Source Software). Anyone can use the software for free, but if they improve or modify it, they shall publish the modifications. This includes yourself, so you cannot reverse this 👀. These licenses are usually referred to as copyleft licenses.
OSS (Open-source software). Anyone can use the software for free and do whatever they want without publishing it. I am talking about the MIT license here because it is the one I am more familiar with. See https://opensource.org.
Open-core software. You can think of it as a mix of open and proprietary software while keeping the open-source spirit. There are two options here, and you can mix them:
- Use the fair-code model: You have one open license that restricts some things, such as AWS stealing your business model. See https://faircode.io.
- Use the mixed licenses model: Parts of your code could be OSS or FOSS like MIT or AGPL, other parts can use the fair-code model, and others could have an enterprise license.
Additionally, there is the option of not publishing all the code. This one is simple. Let's say you publish the core of your product as OSS or FOSS (or as fair-code) and keep the rest private. For instance, you could keep plugins, a dashboard, or some utilities private.
Which is better for you? Well, it depends™️ on your use case.
I want to make clear that my take on this article leans more toward practicality and less toward ideology. However, both sides are interesting, and I recommend you study both.
On a historical note. It is interesting to me that the way the FOSS community was opposed to OSS is a bit similar to the way some people from the OSS community are opposed to the open-core model right now 🤔. I will leave this here and continue with the article … 👀 😬
How do I make money with open-source?
There are a few ways, and you can combine them:
- Sell derivative work: UI templates, starter projects, plugins, etc.
- Teach about related specific or deep stuff: webinars, courses, books, workshops, etc.
- Sell premium support and consulting.
- Create a SaaS or hosting company around the project. I recommend going with the open-core model for this one. With this model, a big chunk of the revenue typically comes from enterprise customers.
Is it reversible?
Yes! But only if you choose the right license. For instance, do not choose copyleft licenses if reversing concerns you. Choose something more liberal, like an MIT license, or use the open-core model. There are two interesting cases here:
- Taking an open source project back to proprietary when the license wasn’t appropriate as Octotree did: https://github.com/christianbundy/octotree/issues/1
- Taking an open source project back to proprietary the right way like Sizzy: https://kitze.io/posts/github-stars-wont-pay-your-rent
Companies that are using the open-core model
Here are a few interesting projects you can draw inspiration from:
- n8n: https://github.com/n8n-io/n8n
- Cal.com: https://github.com/calcom/cal.com
- PostHog: https://github.com/PostHog/posthog
- TimescaleDB: https://github.com/timescale/timescaledb
- Elasticsearch: https://github.com/elastic/elasticsearch
Take a look at their product, licenses, and pricing models; you learn a lot from seeing this in practice.
My recommendation (not legal advice 👀)
This is the path I will follow, and it is the one that appeals the most to me to build a sustainable business on top of an open project. Create a SaaS offering and choose a fair-code license, then transition to the mixed license model when you have enterprise features like SSO SAML, premium support, uptime SLA, dedicated cloud, compliance checks, etc.
I hope this helps. If you find any mistakes in this article, feel free to contact me, and I will correct them. I am not a specialist in software licensing, but this info might be useful to founders/makers like me that are wondering about open-sourcing their projects.
If you have any questions, please ask them in the comments, I would love to help!
If you are having process problems, facing hard technical decisions, or struggling with hard tech stuff, I offer tailored help for companies as a Fractional CTO or consultant. DM me on Twitter if you are interested, or follow me, I usually publish interesting tech/software/maker stuff.
Additional resources
Interesting articles:
