Rethinking Enterprise Software: 5 Ways Best Practices Are Failing Your B2B SaaS Product
Uncovering a Hidden Obstacle Holding the Industry Back
💡 This is the first article in a thought-provoking series that dissects fundamental issues plaguing B2B SaaS product development and challenges common industry beliefs and practices. Subscribe to keep following!
Imagine launching your B2B SaaS product to an eager market, watching as it transforms your customers’ businesses, and spreads through their industry like a wild-fire, clients scrambling to hand over their cash to you, fiercely competing for your professional service resources to get it implemented in their own operations.
Now, snap back to reality.
Is your B2B SaaS product revolutionising your customers’ operations and living up to its full potential, or is it just another disappointing cog in your customers’ bloated IT stack?
Despite grand promises that digitalisation will transform businesses, enhance efficiency, and boost customer value, the reality of enterprise software in 2024 is a sobering wake-up call. As a B2B SaaS leader, you are likely all too familiar with this disconnect.
But what if there was a way to break this cycle and create software that genuinely delivers on its promises?
Let’s confront the uncomfortable truth: the track record of enterprise software development isn’t pretty. Various studies indicate that a staggering 60-70% of software projects fail to meet expectations, overshooting budgets, missing deadlines, or worse – never even seeing the light of day. The Standish Group has collected data on 2,500 to 5,000 software projects per year, mostly custom-made enterprise software (chart below).1 The success rate has hovered between 30% and 40% – where “successes” include software whose usability was considered substandard. Why hasn’t the industry improved more over the years?
If creating custom enterprise software feels challenging, developing B2B SaaS products is like playing the game in expert mode. You are not tackling just one company’s unique challenges – you are aiming to create a scalable enterprise software product for many. It is a whole new level of complexity.
Yet, this very challenge is also a golden opportunity to create new enterprise software products that don’t just meet expectations but shatter them, delivering value that makes customers wonder how they ever lived without them. And make no mistake, venture capitalists aren’t pumping billions into B2B SaaS out of charity – they smell blood in the water, and it is the blood of outdated, clunky B2B software ripe for disruption.
Y Combinator, the startup accelerator with a knack for spotting trends, has been saying since 2014 that “software used by large companies is still awful and still very lucrative”. They believe there is room for new enterprise software startups to solve problems in every industry and business vertical.2 Fast forward to 2024, and that statement still holds true.
So, here is the million-dollar question (or more accurately, the billion-dollar question?):
Why is this massive opportunity still up for grabs in 2024?
Why hasn’t the enterprise software industry made more progress, while consumer apps have leaped forward?
Most importantly, how can a B2B SaaS company seize this opportunity and fulfil this vast potential to create truly new customer value?
In this article, I am going to dive deep into these questions. We will uncover a hidden obstacle that has been holding enterprise software back, challenge some long-held “best practices,” and start a journey towards a groundbreaking approach that could redefine how we create value in B2B and Enterprise SaaS.
By the time you finish reading, you will have a new perspective on why traditional methods are falling short and what is really needed to create exceptional B2B software. Ready to rethink what you know about enterprise software development? Let’s dive in.
The Problem Landscape of Enterprise Software
Before we dive into the solution, let’s survey the battlefield. The enterprise software landscape is a minefield of issues that have been frustrating customers, draining resources, and stunting business growth for far too long. They include:
Misalignment with business needs: Enterprise software often fails to address critical business needs. It lacks features essential for efficient operations and good business decisions, leaving customers scrambling to fill gaps.
Excessive complexity: To close sales, products try to fulfil a flood of feature requests from different customers, and turn into a complex labyrinth.
Poor productivity: Using B2B products is often difficult, inefficient and frustrating due to poor user interfaces and complex interactions, which kill productivity.
Slow deployment: Cumbersome configuration, customisation, and integration contribute to implementation timelines that keep stretching, delaying ROI and testing customer patience.
Lack of flexibility and customisation: Inflexible software that cannot adapt to specific business needs forces organisations to conform to rigid solutions rather than vice versa.
High cost of ownership: Enterprise software is often so expensive to purchase, use, and maintain that its value just barely justifies the substantial investment.
These are not just minor inconveniences. They are symptoms of a deeply flawed approach to enterprise software development. But before we can revolutionise the industry, we need to understand why these problems persist despite best efforts.
9 Common Explanations for Enterprise Software Failures
Software industry isn’t short on explanations for why enterprise software often misses the mark. The following reasons are often cited as contributors to the persistent issues. But do they really get to the root cause, or merely just scratch the surface?
Complexity of business: Enterprise software must support complex businesses with multiple user groups, intertwined processes, and large volumes of connected data, which are challenging to understand and support.
Poor requirements: Gathering, managing and analysing the needs of many different stakeholders is difficult. Product requirements are frequently poorly defined, incomplete, and understood differently and incorrectly by different stakeholders.
Purchasers are not users: The disconnect between those making purchasing decisions (typically CIOs) and those using the software leads B2B software vendors to prioritise satisfying buyers rather than focusing on improving the productivity of users.
Vendor lock-in: The high costs associated with switching to alternative solutions create vendor dependency, which reduces the vendors’ incentive for radical innovation.
Functionality over customer value: Vendors tend to prioritise implementing new features to fulfil RFPs from customers, often neglecting value creation.
Communication gaps: Insufficient communication between Product, Engineering, Sales, Marketing, Customer Success and customers hinders the production of valuable software.
Rigid development processes: Lack of agility leads to failure in responding to ever-changing customer needs and market circumstances.
Inadequate testing and user feedback: Limited testing and user feedback during the development result in overlooking defects, usability issues and pain points.
Extensive integration: Integration complexities arise due to the multitude of software modules and products that large enterprises have from different vendors and eras, often utilising different and even outdated technologies.
While these explanations seem plausible on the surface, they are often used as convenient scapegoats. They distract from a more fundamental issue lurking beneath – one that, if addressed, could transform how we approach B2B SaaS development. But before we unveil this perspective, let’s examine why the current “best practices” aren’t cutting it.
Why Enterprise Software Needs More Than Just “Best Practices”
In the face of persistent challenges, the software industry has rallied around a set of “best practices”. But if these practices were truly the best possible, wouldn’t we have solved the enterprise software puzzle by now? I believe they don’t actually get to the root cause of the problems.
Let’s peel back the layers on these sacred cows and see why they are falling short. The following are 5 commonly suggested best practices and my critique of them:
“Embrace more agile processes” Critique: Agile might help you sprint, but it won’t show you the finish line. While it’s great for incremental improvements, it has limited ability to address larger scale software development. The worst problems in enterprise software are often “between” all the different parts of the customer’s overall IT stack. While the parts can be iterated and developed incrementally, the whole cannot.
“Welcome changing requirements” Critique: The agile principle to “welcome changing requirements, even late in development” assumes that customer needs are as fickle as the weather. But that is incorrect. Correctly understood, customer needs do not change quickly, and are a stable basis for developing large products.
“Prioritise user experience” Critique: While a sleek UI is nice, consumer-centric UX skills and methods are insufficient to tackle the complexities of enterprise software. Furthermore, the highest customer value in B2B often means no user experience at all: full automation.
“Improve testing practices” Critique: You can’t test your way to a great product. All the QA in the world won’t fix issues arising from poor, incomplete, and ambiguous understanding of customer needs. Valid testing results require valid requirements against which to test.
“Better communication and more feedback” Critique: While communication is necessary, we must know what should be communicated, why, when and how? Creating well-communicated mediocrity isn’t the answer. Even close involvement of customers and users has often resulted in lacklustre and failed products.
These “best practices” are not inherently wrong, of course, but they fail to address the core issue. It’s time to stop tinkering at the edges and dive into the heart of the problem. So, what is the core issue?
Back to Basics – The Crucial Understanding Missing from Software Product Development
Imagine designing and building a suspension bridge without understanding the basics of physics. Absurd, right? Yet, that is exactly what I think is happening in the B2B and Enterprise SaaS industry. A fundamental piece of the puzzle is missing, and it is costing billions in failed projects and missed opportunities.
I believe that the root cause of many troubles is in the very beginning of the software process:
What exactly are the “customer problems” that our software is supposed to solve in the first place?
It seems basic, but this deceptively simple question is the Achilles’ heel of our industry.
I can hear the objections already. “Of course we understand customer problems!” they might say. “We have user stories, we do market research, we have customer advisory boards! Everybody knows that understanding customer needs is key to building good products. That’s not news!”
But that could be confusing activity with understanding. Many product teams are drowning in data about customers and their needs, but still lacking real deep insight.
What will lead to a paradigm-shifting revelation is recognising this:
The most fundamental issue is that the industry as a whole has an insufficient, vague, and missing understanding of what “customer needs” or “customer problems” are. Not just in practice, but even in principle.
Are “customer needs” customers’ pain points, value drivers, features, gains, benefits, specification and requirements in an RFP, wants and wishes, exciters and delighters, aspirations? Maybe all of them? No. I believe none of them are correct or sufficient for innovating superior B2B software, directly and consistently.
This fundamental issue cascades throughout the whole development process. All the concepts, ideas and methods that build on top of a faulty foundation are necessarily also flawed. Much of the difficulties later in the software process are just symptoms of failure at the very beginning.
This fundamental shortcoming isn’t anyone’s fault. Product management discipline, software engineering practice, and their academic study are simply not yet mature.
This foundational flaw isn’t just an academic concern. It is a hidden culprit behind bloated features lists, misaligned products, and the persistent gap between what we build and what customers actually need. But the silver lining is that once we recognise this blind spot, we can open the door to a revolution in product development. It is time to see how deep the rabbit hole goes.
Why the Fundamental Issue Is Critical with B2B Software
In the world of consumer apps, intuition and iteration can save the day. But in B2B SaaS we are playing a whole different ball game.
With relatively simple consumer software products, the lack of a solid foundation at the root of product development isn’t an overwhelming obstacle. Everyone can have some kind of an intuitive understanding of the customers’ problems, which helps in coming up with reasonably good solutions. Some geniuses are even elevated on a pedestal, because they are thought to have an exceptional intuitive understanding of consumers and thus a better ability to come up with brilliant solutions (think Steve Jobs).
But with B2B software this is not the case.
Product developers are rarely the customers nor the users. We are outsiders looking in, trying to solve complex problems in industries of which we have no first-hand experience. It is like being asked to perform surgery without ever having studied medicine.
This disconnect isn’t just inconvenient – it’s potentially catastrophic. When we fail to truly and thoroughly grasp the underlying customer problems, we are not just risking a failed product launch. We are jeopardising entire business operations, potentially costing clients millions in lost productivity and missed opportunities.
Product developers must therefore discover and understand the customer needs explicitly to create a good solution. But doing it systematically, effectively and comprehensively is impossible if they don’t know what customer problems are even in principle. They cannot know what facts about the customer’s world they should find out, and what they can ignore.
Luckily, this is not just a challenge – it is an opportunity. Those who can crack this code will have the key to creating products that wildly exceed customers’ expectations. In the next section, I explore why this issue becomes even more critical with larger, more complex software solutions.
Why the Fundamental Issue Is Critical with Large Software
If misunderstanding customer problems is a stumbling block for small software projects, it is a veritable Mount Everest for large-scale enterprise software. Let’s unpack why size matters – and not in a good way – when it comes to this fundamental issue.
In the world of relatively small consumer products, iterating the solution (i.e. “agile”, “ideate and test”, “fail fast”, “trial and error”) will gradually correct mistakes, wherever the mistakes are: in understanding of customer problems, in the solution itself, in its marketing, or elsewhere. It’s like constructing a garden shed. If you make a mistake, you can easily tear down a wall, change the location of the door, move the whole shed a bit, or even start over without incurring massive costs or time delays.
But with a large B2B or Enterprise SaaS product, you are constructing a skyscraper. Every change is slow, costly, and potentially catastrophic if the fundamentals are wrong. You cannot simply move load-bearing walls, rearrange entire floors, move the whole building, or start over again. As the scale of the software grows, so does the cost of solving the wrong problems or solving them wrong.
Iteration, ideation, and testing with customers cannot significantly improve large enterprise software as a whole.
They can improve at most parts of it. Iteration doesn’t work anymore if:
The parts of the large software are not the right parts.
The parts don’t fit together well.
The parts are scoped wrong relative to other parts.
The scope of the whole is wrong.
In these scenarios, iteration is not a path to improvement. It is a long, expensive road to nowhere. By the time you realise you are off course, you could be looking at a decade of sunk costs and missed opportunities.
So, if our tried-and-true methods fall short for large-scale B2B software, what is the alternative? How can we ensure we are building the right solution from the ground up? The answer lies in a foundational shift in how we approach customer problems, which we will explore in depth as we continue.
Why the Fundamental Issue Is Critical With Scalable Products
Now, let’s zoom out to perhaps the most ambitious goal in B2B software: creating a scalable product. If building large software feels like hitting a fast-moving target, creating a truly scalable B2B product may feel like trying to hit it while blindfolded.
Scalability is not just about handling more users or data. It is about solving a common problem for many different businesses, all of which come to the software vendor with their own quirks and weird requirements. It is the holy grail of B2B SaaS – and also its greatest challenge.
With customer-specific B2B software, the lack of solid understanding of what customer problems are, in principle, isn’t necessarily an overwhelming obstacle. The development team can let the customers define the solution instead, as suggested by the agile principle of close collaboration between the development team and the customer. The people who will use the software can have an intuitive understanding of their underlying problems, which then helps them in coming up with a workable solution.
But that is not an option in creating a scalable B2B or enterprise software product for many different customers.
A product is a common solution to common customer problems. It requires a careful ability to distinguish between universal customer problems and client-specific needs. Without a crystal-clear understanding of what constitutes a “customer problem” in the first place, this task is generally not possible.
Some product teams try to look at feature requests from different customers, and assume that common requests imply common customer problems. This is fundamentally flawed. It first results in a bloated product backlog. Working through that backlog leads to bloated, unfocused products that try to be everything to everyone, and end up being nothing to anyone.
The inability to properly identify and address common customer problems is a potential death sentence for scalable B2B SaaS ambitions. But what if there was a way to cut through the noise, to see the true underlying problems with clarity? That is the promise of this article series and my newsletter. Keep reading, and subscribe now to find out how!
Busting 5 Myths Holding Back B2B SaaS Innovation
As if the challenges we have discussed weren’t enough, there is another insidious obstacle lurking in the shadows: a set of misconceptions that actively sabotage our efforts to discover and understand customer problems. Let’s list and debunk some of these myths that are holding us back:
Myth #1: “Customers don’t know what they need.” Reality: Customers know their problems intimately – we just don’t know how to ask and what to observe.
Myth #2: “Even if customers know their needs, they can’t articulate them.” Reality: They can – but it’s our job to provide the right framework for discussion and discovery.
Myth #3: “Customers can’t possibly know what they need from new technology, like a new product based on AI.” Reality: Their needs exist independently of our solutions – we just need to uncover them.
Myth #4: “Customer needs are always changing, so why bother trying to pin them down?” Reality: Customer needs are more stable than we think – it is the solutions that keep shifting so quickly.
Myth #5: “There are too many customer needs for large enterprise software to discover them all.” Reality: With the right approach, the set of customer problems is far smaller than it seems, though still not tiny – after all, most B2B and enterprise software are about solving complex problems.
These myths are not just harmless misconceptions – they prevent us from doing the deep, meaningful discovery work necessary to create truly valuable B2B software. If we cling to these beliefs, we give ourselves permission to skip the hard work of really understanding our customers.
So, if these are the myths, what is the reality? How can we cut through the confusion and get to the heart of customer problems? That is exactly what we will keep exploring next in this article, in this article series, and in this whole newsletter. Subscribe now to be among the first to get answers to all your open questions!
From the Ground Up – Reinventing B2B Software Development with First Principles Thinking
As an industry, it is time to build a solid new foundation to transform the development of complex B2B and Enterprise SaaS products, using first principles thinking. Not a minor tweak, but a revolution.
We must have the courage to challenge today’s conventions. It is time to strip away the layers of jargon, question the most cherished best practices, and ruthlessly eliminate unnecessary complexity that does not serve our ultimate goal: creating unparalleled value for our customers. And we don’t need yet another model, framework, or process from one more consultant.
What I am proposing is not just another methodology.
We need a foundational, testable, explanatory theory of how software products create customer value. We need to understand, with precision, how every feature, every function, every customer-facing aspect of the software contributes to solving the real customer problems and creating value. The theory must explain and predict why some software solutions are objectively more valuable for the customers.
A good theory must also explain how the best practical methods to create the most valuable solutions should work, why they must be like that, and how they would differ from today’s accepted wisdom and practices.
Imagine the power of being able to predict, with a high degree of certainty, which solutions will succeed and which will fail, before writing a single line of code. Envision being able to create software that doesn’t just meet customer needs, but anticipates and exceeds them consistently. That is the promise of the new approach.
By exploring and clarifying the foundational concepts and principles, it is possible to revolutionise the B2B and Enterprise SaaS industry. We can systematically and consistently create radically better B2B and enterprise software products with fewer resources. We can propel the software industry and our customers’ industries toward greater success and productivity.
In this groundbreaking series of articles, we will embark on a journey to redefine the foundation for better software. To keep following the series, subscribe now!
This is not just a professional interest for me. It is my life mission, a calling to help transform the software industry and unlock unprecedented value. And I know it’s a long road ahead.
Let’s start the exploration from the very beginning.
The topic of the next article is the cornerstone of the new foundation:
What, in principle, is a “customer problem” to which a software product as a whole is a “solution”?
Ready to challenge what you know about customer needs? Subscribe now to get the next articles directly in your Inbox!
Continue to part #2 of the series: “From Solutions to Problems: The Problem with Solutions”!
Jim Johnson: CHAOS2020 Beyond Infinity, Standish Group, 2020
Y-Combinator: Requests for Startups, archived from September 17, 2014