Software companies buying software: a story of ecosystems and vendors

Why are new startups growing so fast? Why is the wage distribution getting larger for software engineers? Why do I love infrastructure? Is open source dead?

I think a lot of these things, and some more things, all have their roots in a big shift in how we build software. Or rather, how we buy software. Software development today is a lot about using the right vendors rather than building technology yourself.

Just a random note: this blog post isn’t really about AI (though we’ll talk about it). And it’s also not about SaaS. So what is it about? It’s about companies that sell software to software companies. Which is something I think about a lot!

What’s a tech company?

A long time ago, I spent seven years at Spotify. It’s a great example of a company whose identity was very much one of a “tech company” since, well, it built tech. Building Spotify, was hard! Of course, we used Linux and Postgres and many other open source technologies. But pretty much everything else was built in-house.

I worked on a lot of random things at Spotify, but one of my contributions was a vector database, called Annoy. I figured probably another 50 companies probably had the same problem, so I open sourced it. Turns out I was somewhat right, and several other companies ended up using that (including Twitter and Instacart).

I like to think of this technology sharing as a sort of “factoring out” of common technology. It’s wasteful if 1,000 companies build the same thing, and it makes more sense to factor that out into a single (hopefully better) component that all 1,000 companies can use.

The predominant way to do this, at least among startups, was through open source. Some of this eventually became standalone businesses. But those were a bit tricky! First of all, the software industry was much smaller back then, so there were fewer potential buyers. But open source has always been a tricky way to make money — if something is already open source, then what do you charge for?

We needed a better way to build these supply chains.

Enter the cloud

A very seminal thing happened with software development starting in 2007 — the emergence of cloud vendors. This shift hasn’t been super easy, and my hot take is we’re still in the early days in this transformation. But it’s been almost 20 years and a lot of software engineering changed with the advent of the cloud.

Cloud platforms laid the groundwork for software platformization since they broke out a set of shared constraints across companies and sold it back to them through software.

But cloud adoption hasn’t happen quickly. Some of this is economics — it’s taken time to be cost-competitive. But a bigger reason is probably what my first reaction was when I heard about AWS — this sounds nuts. How could I put my code on someone else’s computer?

Over time though, companies have learned to think about security in a different way. This security mindset shift is a recurring pattern, and we will talk more about it later. But the general thesis I have is — economic forces eventually cause security concerns to change.

Refactoring the software stack

The cloud refactored the most core layer of software engineering — the ground floor of the software building. But software has many floors! And honestly it’s more like a DAG. One attempt to capture today’s software stack is that it looks something like this:

The exact shape of this stack isn’t material to the general thesis of this blog post. What’s material is that there are a number of more boxes in this map. And I think what happened to the ground floor — the cloud — is happening with every floor of this building:

• Cloud is obviously here already
• But we’re also seeing “2nd layer cloud services” like Vercel, Render, Railway, Modal, and others
• Last decade has brought us many infrastructure-as-service companies like Snowflake and Datadog
• API vendors like Stripe and Twilio have been around for a while
• In the last few years, we’ve seen an explosion of AI API vendors

In short, the software stack is getting deeper, and all the layers, except the top one (biz logic), are getting shifted out to vendors.

Everything becomes an API

What used to be built in-house, is now mostly handled by separate companies. These companies, to be somewhat reductive, are all “API businesses” in different forms.

These new vendors often default to a fully managed, multi-tenant approach. Not open source, not on-prem, often not even cloud-prem. Just an API you call. We’ll talk about the security implications of this in a sec. But from an engineering perspective, this is a great way to deliver software:

• The vendor now has full control over the deployment
• They can manage capacity better
• They have a stronger incentive to reduce cost.

Open source plays a smaller role in this new world. It’s always been hard to make money from open source of course, but software companies would do in order to get into customers more easily. But the tradeoff is different today — a closed-source fully-hosted software product can still get a lot of customers, and the revenue per customer is way more. I don’t think open source is dead, but I think it makes sense only for a very small set of software products today — maybe ones where it lets you get in front of millions of customers. ¹ The cutoff has shifted very far.

The buy it vibe shift

If new companies are adopting these vendors natively, what happens with existing companies that were built before of this started to happen?

Let’s go back to the example of Spotify, or more broadly the tech darlings of that era. These are tech companies who set out to build something (generally a consumer experience) and had to build a ton of deep tech as a part of that.

But building the hard tech is no longer needed to the same extent. You can just use a ton of the vendors that are out there. In fact, building it yourself is maybe even a a competitive disadvantage, because the external vendors providing these services often have better services, since they can collect much more revenue across their user base and invest more into it.

In the last few years, I’ve noticed a real “vibe shift” in these later stage tech companies. What previously used to be an obvious “build it” decision is now increasingly a “buy it”. And what previously used to be a hard constraint to host things themselves is now increasingly becoming a “just use the API”.

I think this in large part also explains why later stage tech companies have had layoffs and have been growing a lot slower. They just don’t need to build all of this technology internally! Why build your own internal ML platform when you can just buy one from the outside. This is obviously not an easy shift — there’s a lot of sunk cost, maybe pride, security concerns, and maybe other things. But economic forces prevail over those things in the long run.

Twitter laying off 75% obviously doesn’t have a control group, but it strikes me as an experiment that a lot of tech execs and board members will be paying close attention to

— Erik Bernhardsson (@bernhardsson) October 26, 2022

In a way I think it goes back to what’s a tech company? A lot of companies (like Spotify) were forced to be a “tech company” 20 years ago because some very custom technology was needed. But is HBO a tech company? Is Netflix a tech company? What’s the difference? In a way, I think every company is becoming a tech company, making the label somewhat meaningless.

The complexity of the supply chains also affects other things. One thing I expect to change is enterprise sales. If you built a B2B software biz in 2010, you absolutely had to sell to enterprise. The common wisdom is that this is where the revenue is. I’m not sure that this is true in 2026. Enterprise companies still spend a lot of money! But instead of selling to companies, you can sell to companies who sell to companies. This is arguably easier (shorter sales cycles) even though you add a middleman.

It’s not just the consumer products that are undergoing this transformation. Other software-heavy spaces such as biology and finance seem to be going through a similar process. These are industries that could benefit from a lot more “layers” and are big enough to create an ecosystem of such vendors. I think there’s a great opportunity for venture capital to fund platform-y type companies in these spaces.

The security vibe shift

I mentioned earlier that the journey to the cloud has taken a while, partly because of the security. Using vendors in software is a bit different than using vendors in other industries, since you’re sending sensitive data to those vendors. So that does make it a bit different.

My theory is that this proceeds quite slowly, until the industry hits a “tipping point”. What happens? I think roughly three things:

1. Vendors are suddenly being seen as the mature default choice
2. The economics of the new models are beneficial
3. There’s FOMO

This causes a sudden large adoption of the new deployment model.

IaaS and API businesses are now at a similar point as the cloud was five or ten years ago. Some customers are comfortable with whatever, some need cloud-perm, some don’t want it at all. My prediction is we’re all this VPC and BYOC stuff will be seen as outdated in a few years. There are large benefits in multi-tenancy, so shift the concerns to the vendor. AI FOMO does feel the final nail in the coffin that’s going to drive a ton of later-stage companies to adopt multi-tenant fully-hosted vendors.

The economics of a deeper stack

What happens when we have all these companies selling software to software companies? I think a few things are direct corollaries of this deeper dependency graph.

First of all, the business of hosted services means that companies are “factoring out their COGS”. This causes higher revenue with lower margins. And because there’s a chain of companies doing this, this effect is amplified.

What used to be one company buying hardware for $1k is now a deep stack where company n pays company n+1. So you end up with n companies having more or less $1k revenue each. But note that we’re n-counting here! So some of the revenue growth seen in tech today is arguably more of an accounting artifact.

Going up and down the stack

Companies at different layers of the stack rarely compete. AWS or Anthropic can of course go up the stack, and they do sometimes, but often this just means competing with a vendor that would have spent money on them anyway. ² I often find the “what if they go up the stack” question to be a bit too paranoid for this reason. The economic reason often doesn’t quite exist, plus being master at one layer is hard enough as it is. I wrote a lot about this in a previous blog post (in particular, Redshift vs Snowflake).

Should companies go down the stack and not use vendors for things? We’ve already talked about the power of using vendors — you get better software, can move faster, etc. For most customers, the only rationale for building it yourself rather than using a vendor is when you’re operating at a large enough scale where cost is critical to optimize. This breakpoint tends to go up over time as vendors mature.

In the early days of the cloud, only small companies used it. Today, not using the cloud really only makes sense if you’re at Meta-level scale. And even if you could save money, you’re losing out on the latest and greatest tech by not using a vendor — something that very few companies can afford to do.

What does this mean to the software ecosystem?

When 1000 companies factor out their tools into a vendor, you’re not going to end up with a thousand vendors. Within each category, you’re going to end up with a really small set, probably some power-law distribution. This is partly because of economies of scale, partly because picking vendors is a complex Schelling-like coordination game where perception of winning can drive winning itself.

Because of all the layers of indirection, the best engineers can have way more impact on the software ecosystem today, vs what they could have had ten years ago, when at most they could affect just one company. This in turn causes engineers at these companies to be very valuable, which is why I think we’ve seen the top 1% of engineer salaries shoot up recently.

The high degree of vendorization also creates a complex graph of B2B sales, which is I think benefits companies being in SF. Thus, SF is back.

I do genuinely think you can create a successful startup all over the world, especially if you’re building a consumer business. You can probably also build SaaS anywhere too, but your early adopters might be in SF.

If you’re selling software to software companies, it gets harder not being where the customers are. My company is based in NYC and I suspect the only way we made this work is through incredibly strong product-led growth. I don’t think it’s a coincidence that the two big IaaS startups in NYC — Mongo and Datadog — both had a similar motion.

Ok, but what about AI?

It’s pretty absurd that I wrote a whole blog post, (almost) without talking about AI!

Anyway, my general view on AI as a technology is that it breaks down into:

1. AI is a productivity enhancing technology just like many previous ones — compilers, high-level programming languages, relational databases, cloud compute, etc… (though probably faster and larger than those)
2. Idiosyncratic things — what’s actually unique to AI vs other technology shifts?

On the second point, there’s one big one: GPUs are expensive! This further drives revenue up and margins down, and it strongly favors multi-tenancy (which drives utilization up).

But I really think everything else just belongs in the first point. There’s been a dubious thesis circulating the last few days that companies won’t even use vendors because AI just lets them build tools themselves. I highly doubt this.

Note that the economics still favors companies factoring out shared dependencies into a vendor. AI-coding means vendors too can create more value! It’s possible existing software will go down in value, but for new software, the economics of factoring out code into vendors still applies.

The total value created by vendors is roughly a function of the number of customers. As the software ecosystem keeps growing, I expect the trend of vendorization to increase.

Summary

In this blog post, I’ve laid out my thesis for why a lot of things are happening to software:

• You see a lot more startups with super fast revenue growth
• Margins are thinner
• Engineering inequality is growing
• SF is back
• Digital natives had a bunch of layoffs

My thesis is that all of this is a direct corollary of platformization of software, and that this is going to continue!

If you’re familiar with my background, this blog post might come off as a bit self-serving! For the past 5 years, I’ve been running a company called Modal which basically sells AI infrastructure-as-a-service. But in fact, a lot of what’s in this blog post are things we’ve believed in for a long time, and we’ve been building Modal with all of this in mind. Much like I’m talking about “factoring out” tools into open source projects, I realized this belief should be factored out into a blog post!

I also imagine this blog post feels very “obvious” if you take a step back. We have two hundred years of technological shifts going back to the industrial revolution and Adam Smith. Supply chains have been refactored countless times since then. From that perspective, what’s happening isn’t exactly weird — it’s expected. It just took some time.

Why? Partly because we had to rethink security in order to do it. Partly because the software industry just wasn’t big enough ten years ago. Partly because it took something like AI to create a ton of FOMO and push through even more of this.

Either way, I’m very excited about the complex web of software companies we ended up with!