Every software product begins with a simple idea. Somewhere between that idea and the finished product, complexity creeps in. It arrives quietly, feature by feature, requirement by requirement, until the product that was meant to make life easier has become something users dread opening.
Complexity is not an accident. It is the default state of software that is built without restraint. Every stakeholder has a feature they believe essential. Every competitor has a capability that seems necessary to match. Every user request, however niche, carries the weight of a real person's need. Without a clear philosophy of what the product is and, more importantly, what it is not, software grows until it collapses under its own weight.
The Anatomy of Complexity
Complexity in software manifests in three forms: feature overload, poor workflows, and confusing interfaces. Each is distinct, but they reinforce one another until the product becomes unusable.
Feature overload is the most visible form. It is the settings panel with forty options when four would suffice. It is the dashboard that displays every metric the engineering team can measure, regardless of whether anyone needs them. It is the product that tries to be everything to everyone and ends up being nothing to anyone.
Poor workflows are more insidious. They occur when a task that should take three steps takes twelve because the software was designed around its own internal logic rather than the user's mental model.
Confusing interfaces are the surface symptom of deeper problems. They appear when every possible action is given equal visual weight and when the interface communicates the product's complexity rather than shielding the user from it.
Why Simplicity Requires More Thought
There is a common misconception that simple software is easy to build. The opposite is true. Simplicity is the result of difficult decisions made deliberately. It requires saying no to features that seem reasonable, to requests that come from influential voices, to patterns that are familiar but not optimal.
Complexity, by contrast, is the path of least resistance. Adding a feature is easier than explaining why it should not be added. Expanding a settings panel is easier than designing intelligent defaults. Building what the user asks for is easier than understanding what the user actually needs.
Consider the evolution of consumer software over the past two decades. The products that have endured — those that people genuinely prefer to use — tend to share a common trait: they do fewer things, but they do them exceptionally well.
Design Principle
At SaintsLink, every feature proposal must answer a single question: “If we remove this, would the product still serve its core purpose?” If the answer is yes, the feature does not belong in the initial release. It can be added later if evidence demands it. It is far harder to remove a feature than to never add it.
The Discipline of Restraint
Removing unnecessary complexity is not a one-time exercise. It is a continuous discipline. Every product team faces pressure to add: new features for competitive parity, new capabilities for specific customers, new options for configurability. The forces that create complexity are constant and powerful.
Resisting them requires a clear understanding of what the product is for. Not what it could do, but what it should do. This understanding must be shared across the organisation and defended against the gradual erosion that comes from well-intentioned additions.
At SaintsLink, we approach this through what we call “subtractive design.” Rather than starting with a list of features to include, we begin with the core problem and ask what the minimum viable solution looks like. We then test that minimum solution with real users before considering any expansion.
A Different Standard
The software industry has developed a culture that celebrates capability over clarity. Product announcements emphasise feature counts. Marketing materials list integrations and configurations. Reviews compare checklists. This culture rewards complexity because complexity is easy to demonstrate.
But the products that people love — the ones they recommend, the ones they return to daily, the ones that become indispensable — tend to be the ones that make hard choices about what to exclude. They earn trust not by promising everything, but by delivering exactly what matters.
Closing Reflection
The best software is not the one that can do the most. It is the one that gets out of the way.