When people see a successful software product, they only see half of the story.
An incredible amount of work has gone into these products, but behind them, invisible to an outsider, there is often just as much code buried in internal systems and ‘supporting’ projects.
Here’s what this looks like for us: our product ‘Tower’ is a desktop GUI for Git. It helps over 100,000 users in companies like Apple, Amazon, and Google work more productively with the Git version control system. The codebase for the macOS version alone has over 300,000 lines of code.
But in the background, we have another major internal ‘product’: our licensing system. It controls everything from licenses, plans, and subscriptions all the way to discounts, sales offers, and custom orders. It’s fair to say that these 140,000 lines of code are vital for our business – but largely invisible to the outsider.
Build or buy: a tough decision
Almost eleven years ago, when we started developing Tower, we instantly saw the need for this licensing system. But it took us quite some time to decide if we should build or buy it. Finally, as you already know, we went ahead to build our own custom system.
At the time, the following considerations lead us to build (instead of buy):
- Choice of third-party systems. The market, at that time, didn’t offer much choice. There were only a few systems that did what we wanted, and they seemed awfully expensive.
- Existing skills. We knew we had all the necessary skills to build it with our own team. We wouldn’t have to learn new technologies or hire new people for this.
- Manageable effort. We were pretty confident that we’d be able to build our own, custom-tailored system without too much effort.
Surprises along the way
It goes without saying that the reality of building such a complex system had some surprises.
A huge time investment
Anyone who’s been part of a slightly larger software project might have giggled at my naive hope for ‘manageable effort’: ‘quick and easy’ projects do not exist in software development! And, of course, our licensing system was no exception: to this day, we’ve invested approximately three person-years in the system. For a company with just nine team members (and even fewer in the past), this is truly a huge investment.
It’s never done
Time and again, we were convinced that the system would soon be ‘complete’. Done. Finished. Finito! But new requirements kept coming up from inside our own sales and support team. Only recently we finally understood that the system evolves with our own business model – and therefore will probably never be finished!
It’s all custom
When we started, we thought we were about to recreate a fairly standard piece of software; it would take care of licenses and activations, something that’s common for many software products. But we came to realize that most of the system is highly custom to how we do things, how our own software works, and how our internal workflows are designed.
Was it the right decision?
Today, eleven years later and with lots of lessons learned, there’s an interesting question to ask: ‘Would we do it again and build instead of buy?’
On the one hand
No, because of the huge time investment. The time required to develop and maintain the system varied a lot through the years, depending on whether our business itself changed or not. But in high times, we often struggled to make time, because all efforts here came on top of our product development.
No, also, because building your own system often tempts you to overdo it with the features you (think you) need. If we had gone with a standard solution, bought or rented from a third-party vendor, we would have had to be content with the features that system offered. If you’re building your own, the sky’s the limit – and additional requirements from inside your own team never stop.
But on the other hand
Yes, because developing such a vital system ourselves makes sure we’re not locked into a third-party product. In general, we are big fans of not building our own stuff; there are lots of great tools and services out there! But for such a vital part of our business, it feels good to be in control. A third-party product going out of business or going in the wrong direction would have a severe impact on our company.
Yes, also, because we would have a hard time handling many requests with a standard software system. For example, many of our bigger customers are buying their licenses through a ‘reseller’. The purchasing process is quite different in such a case, compared to a customer who’s buying Tower for themselves. Our own system allows us to carefully design this process exactly as we see fit.
There’s no clear answer
As you can see: there’s clearly no clear answer to this question ?
The details of your project matter quite a lot, which makes it hard to give a generalized answer. That’s why there’s only a little advice that I dare to give.
1. Try not to build your own! In most cases, buying is the better decision. Often simply for financial reasons, because most projects tend to be more complex and require more time and resources than initially thought. But also because it makes it harder for you to focus: instead of giving your core product all the attention and resources you have, you begin to spread yourself thin.
Only when the system in question is tightly connected to your business model – and its evolution – might it make sense to build your own.
2. If you decide to build, be sure you can stick it out! When we made the decision to build, we estimated the effort for an initial version pretty accurately. But we were in no way prepared that the project would develop a life of its own, causing so much work on an ongoing basis. Therefore, if you decide to build something, make sure you have the resources to keep it up for a long time.
