Back in 2024, I gave a presentation on an emerging network automation product. The tool, called Cisco Workflows, was designed to connect via API to the systems required to run a network, and automate common tasks across them based on low/no-code workflows the user could build.
The product messaging was built around the idea that we could solve the problem of tool sprawl, context-switching fatigue, and the general dread that comes from bouncing between consoles.
In preparation for this session, I wanted to establish the reason enterprise teams had a million consoles to begin with. Most of that research never made it into the presentation, but the findings were interesting enough to revisit here.
To level-set: the average enterprise relies on 473 SaaS applications and enterprise software spending is projected to surpass $580B annually by 2030.
What makes software unique is that it rarely replaces itself. A new car replaces an old car. A new phone replaces an old phone. That is not the case for software.
Software is additive in nature
With physical goods, versions are supplemental. You swap one thing out for a newer or different version of it. Software is different. Each generation is built and adopted on top of the last.
Take identity, for example. It started with Active Directory centralizing user identity on the corporate network. AD then fed into network access control. As work moved outside of the office, SSO and MFA built on top of the foundation AD had established. As entitlements grew, IGA arrived to govern access and prove compliance. ITDR emerged to defend identity from attacks. NHI followed to secure machine identities. Now IVIP is forming to unify the whole stack.
Instead of replacing what came before, each generation builds on top of it, so the old layers never leave. They just get buried under the new ones.
This is not to say replacement or consolidation never happens, but the more software that is created, the more opportunities there are for improvement. And if there's one thing we know is certain, it's that improvement generally gets rewarded.
The market rewards niche innovation
As complexity grows, more problems emerge that are narrower and narrower. This helps explain part of the example mentioned above.
These problems are real and painful, but specific nonetheless. When you account for the additive nature of software, you begin to see opportunities for innovation within pockets of the current generation. This narrow optimization gets rewarded by the market.
A startup can't out-build the incumbent platform, but it can own a solution to the problem the incumbents do poorly, and buyers feeling a specific pain will buy the tool that solves it today. So the narrow tool wins, and another layer gets added to the stack. Over time, this becomes mainstream. What was yesterday's innovation is now table-stakes, absorbed by the layer above.
The cycle continues
This process can be described by what I call the paradox of technology development. The paradox is that innovation has traditionally implied convenience. In the world of software, innovation often leads to more complexity. The cycle goes like this:
- A problem or opportunity is identified
- A solution is built for that problem
- The market adopts this solution
- A new problem or opportunity is identified
- A new solution is built and adopted on top of the previous
The more technology we create, the more of it we have to optimize, connect, secure, and make accessible. Every major shift creates an ecosystem to support it. Once that ecosystem gets adopted, it embeds itself into the business and seldom leaves.
Many companies realize this but struggle to do anything about it. The tools become essential, layered, and deeply connected. So instead, they adopt unifying tools that help automate tasks, build more visibility into the stack, and monitor for when things break.
The salvation here may be the rise of the headless state with AI, but until then, the cycle continues.