Saul,
I agree with a lot (most!) of what you said, but there are a couple of items that I think you don’t get quite right, having to do with the underlying nature of software development.
Software development has been around for a while now. There indeed has been quite a lot of change not only in how that software is built, but also its inherent complexity, and (perhaps most importantly!) in how it is marketed and sold. However, as it is often the case, things with a shiny new label are often strikingly similar underneath to the product of yesteryear.
Let’s look at the notion of selling software packages (old model) vs. selling software subscription (new model) a little more closely.
In the old model, you’d sell your software package upfront, usually at a fairly significant price, since that initial outlay was the biggest chunk of money you were likely to ever get from your client. And then you’d charge them an annual maintenance fee, usually about 18% of that original contract cost, for which you provided support and maintenance releases. Note that while a retail consumer buying a $20 piece of personal software wouldn’t normally pay any kind of maintenance, any serious software used by an actual business would always carry maintenance charges. First, many software companies simply wouldn’t sell you their software without an accompanying maintenance contract; but more importantly, no serious business would ever WANT to forego maintenance - it’s just too damn risky, because having no maintenance leaves you wide open to cyber attacks, or ability to deal with other production problems. No support is a corporate IT manager’s worst nightmare. So any software more complex than Notepad (including enterprise licenses of Microsoft Office!) ALWAYS came with a maintenance revenue stream. So the math on software sales of yesteryear looked something like this:
Initial license: $1000
Annual maintenance: $180 (18%)
This kind of license usually included a few major upgrades for a free, and then, in 4-5 years, you’d have to pony up again for the major new version.
And this model worked fine for a long time, it had its challenges (initial sales were hard!), but it still made billions for people like Oracle and IBM and the like. But at some point, corporate people figured out that they just loooove the financial predictability of recurring revenue (and more importantly, the stock market does too!). So they created the subscription model. And now it looks like this:
Initial license: $0!
Subscription fee: $25 a month!
Annual maintenance: Included!
It certainly sells a lot easier, doesn’t it? But when you look closer, you realize that the subscription fee is little more than the annual maintenance turned into a monthly maintenance, with a little extra to account for the lack of that big initial payment. But is it really that different financially? Maybe not quite as different as it first seems. It’s more about psychology, sales, marketing, and accounting. And btw, this kind of simple calculation is exactly how first subscription-based software companies figured out what their subscription fees should be in the first place! Case in point: Office 2000 Premium used to cost $800 as packaged software. Now its equivalent costs about $10 a month.
The second point I want to make is about costs of software development. People outside the industry struggle to understand what software companies actually spend money on (in addition to salaries). Everybody understands factories and raw materials. Software is trickier. But software companies can also have significant operating costs. While these costs do scale a LOT better than costs of companies that make physical goods, they are not infinitesimal. It’s just a different model, particularly with the world of cloud factored in. Here are two important categories that software companies spend money on:
Tooling: developers don’t just work in Notepad. They need advanced development environment tools, debuggers, testing tools, code repository tools, data management tools, deployment automation tools, data profiling tools, security packages, databases, application servers, messaging middleware, the list goes on and on and on. Yes, open source changed the world, and you can get a LOT of stuff for free nowadays. But again, remember support. No one who is serious about their business wants to use tools that are not backed by someone’s deep expertise. Or tools that don’t come with security patching services. Or hotfixes for those pesky production issues. So - you pay for support - at least for all the important stuff. That’s how the RedHats and the Elastics of the world make their money - on support contracts for free software. The bottom line is that to build and maintain software at any kind of scale you also need to buy some software. And the bigger you become, the bigger those subscription or licensing costs to your suppliers become too.
Infrastructure: you gotta run your software somewhere, right? Desktops, test environments, quality assurance environments, production environments, contingency environments. Don’t forget the networking equipment, either! So, either you are buying all that stuff and putting it in a data center (and maintaining it pretty much non-stop), or you’ve gone to the cloud, in which case you’ve just outsourced all that dirty hardware work to Amazon, and they just charge you computing fees. Which - yes, you got it! - go up and up the more data you store and the more compute cycles you consume. They do a great job for you - but it does cost you money, and that cost grows the more subscribers YOUR software has. So every dollar Mongo Atlas makes translates into cents that their cloud service provider makes.
The Achilles heel of software is complexity. And that is the other super important difference in how software scales vs. how hardware scales. Tesla’s Gigafactory 2 looks pretty much like Tesla’s Gigafactory 3, and so on. Once they’ve figured one out, they can keep cloning them. Very clear, linear cost and growth model. Software isn’t like that. Software grows on itself. What’s wonderful about software (as you noted!) is that you can just keep selling the same thing over and over again! But the little understood dark underside of that equation is software complexity. With every new release, with every new customer, every new feature (does the wish list ever stop?!), the software grows more complicated. You need more developers, more testers, better tools and more infrastructure to keep managing it. Just like SaaS software sales, SaaS software complexity also grows exponentially, not linearly. That’s how the “dinosaurs” - Oracle, IBM, Microsoft - eventually become what they become. The first relational database was beautifully simple. So was the first word processing program. The first operating system. DOS used to fit on one 1.44MB floppy disk!! The first version was essentially written by one dude! (He is pretty famous now). Then 30 years of new releases happened. And now we have Oracle, MS Office and Windows 10. They take veritable ARMIES of people to manage now. What happened? Did those companies just start to suck somehow? Nope. It’s software complexity. And it is coming for them all. And - rarely talked about fact - SaaS software is actually a LOT harder to write than non-SaaS software to begin with - because it is inherently massively multi-tenant - and that is a HARD engineering problem.
Now you are still right in many, many of the things you said. Internet did change the world. There is a big difference between thick client software that needs to be installed and zero-footprint browser software that does not. Open source changed the world too. And so did virtualization, and cloud - yet again. Software became beautifully easy to use for end consumers. But the complexities underneath did not really go away. Each of these breakthrough innovations stands on the shoulders of the leaps before it, and so when you dig under the covers, you start to see that. SaaS companies with 90% gross margins feed tons of other SaaS companies with 90% gross margins. Which is why their net margins aren’t that great. Splunk uses Mongo. Zscaler uses Splunk. Mongo uses Atlassian. Atlassian uses DataDog. DataDog uses Elastic. Etc. etc. etc. - I am making some of these up, but you get the point.
All in all, I am still with you - I LOVE investing in SaaS companies, and we DO live in a special time where we can watch the world change before our eyes. But having been in software development all my life, I’d just advise a little caution, because it’s all far more incestuous than it first seems underneath, and for every SaaS company that has a truly groundbreaking product, there are 10 SaaS companies that do not, and are merely riding on the coattails of the overall SaaS excitement for the time being. So we have to be watchful. Not every SaaS company is created equal - not at all. And so I think our greatest success here remains not the fact that we recognize that SaaS is great, but in continuing to find true standouts and visionaries in the space, and investing in them for the long haul. And that also is a very old idea.