More Features Don't Necessarily Make a Better Product
Every feature has a cost, even when it's free. How I decide what to add, what to leave for later and what to remove when building products, and the one question I ask every time.
In developing a digital product, the easiest thing to do is add a feature. Someone suggests it, it seems useful, we build it. A few months later the product has fifty such features, each one justified on its own, and together they've produced something nobody wanted: a product that's hard to understand, slow to maintain and expensive to support.
I write about this as someone who faces that decision constantly. On my own products, Bizko among them, I regularly have to decide what to add, what to leave for later and what doesn't belong at all. I won't reveal anything internal here; what interests me is a way of thinking that can be applied to any product.
The main idea is simple: more features don't necessarily make a better product. Often they make the opposite.
Every feature has a cost, even when it's free
When we talk about a new feature, the conversation usually revolves around how long it will take to build. That's the smallest part of its cost.
A feature has to be explained: in the interface, in the documentation, in support. It has to be maintained: with every change to the system, a library or the data model, someone has to check that it still works. It has to be tested in combination with all the other features. It takes up space in the interface, where it competes for attention with things that may matter more. And it creates the expectation that it will be there forever; removing a feature is harder than building it.
When I look at a feature that way, the question "can we build it" matters less than the question "are we prepared to have it".
The question I ask every time
For every proposal I ask the same question: does this feature simplify something for the user, or does it just make the feature list longer?
The answer isn't always obvious. A feature one customer asks for can merely clutter the screen for the other ninety-nine. A feature that sounds advanced can solve a problem nobody actually has. And the reverse: a boring fix that saves the user two clicks on something they do every day can be the biggest improvement of the year.
With Bizko the starting point is always the same: less re-entering of data, less administration, a more logical flow of work. Every new feature has to be measured against that. If it saves work, it has a place. If it merely moves the work to a different screen, it doesn't, however good it looks.
Feature creep happens in steps
Nobody decides to overload a product. It overloads itself, step by step, and every step was reasonable.
Imagine a typical example. One customer asks for an export; we add an export. Another asks for a different format; we add an option. A third wants a scheduled export; we add settings. A fourth wants a notification when the export is done. Each of those things was small and justified. Together we have an export module with its own menu that most users never open and that has to be maintained with every change to the data model.
The only way I know to counter this is to decide before each step, not after. What is the core of the product? Does this request belong to it? If not, can we solve it without a new feature: by changing an existing one, by a better default, or by not solving it?
It also helps if, for every new feature, I write down whom it's for and why. Not for documentation, but for the decision. If the note says "for one customer, because they asked", that's a different argument from "for everyone who does this every day". Surprisingly often, writing that sentence shows there's no reason, and the feature stays on the list where it bothers nobody.
Complexity doesn't show in the demo
A product with many features looks impressive in a presentation. Every question has an answer: yes, we can do that too. The problem shows up later, when the user is left alone with the interface.
Onboarding a new user takes longer, because they have to understand more things before doing the first useful one. Support gets questions about features that were built for someone else. Settings grow, because every feature needs an option to switch it off. Development slows down, because every change affects more places.
That's technical debt the accounts don't show. It's paid in time that couldn't be spent on improvements that would genuinely help the user.
What "leave it for later" means
When I reject or postpone a feature, that's not a judgement on the idea. It's a decision about order. Most of the ideas I postpone are good; they just aren't good enough to displace what needs doing first.
A simple rule helps me here. If one user asks for a feature, I write it down. If several users ask for the same thing in different words, I look at it again. If it turns out they're solving the same problem with a workaround that costs them time, it gets priority. A request on its own isn't yet a need; repetition and workarounds are.
I also think it matters that "later" is honest. I don't promise a feature I don't intend to build. I'd rather say it doesn't belong in the product than leave it on a list where someone is waiting for it.
Removing is development too
We think of products as something that grows. Less is said about the fact that removing a feature can be just as much of an improvement. For me it's one of the harder decisions, because every feature has someone who uses it.
Even so, it seems fair to ask the product now and then: which feature does more harm than good? Which one generates the most support questions relative to its number of users? Which one was built for a case that no longer exists? Removing a feature like that makes the product lighter for everyone else and frees up time for what matters.
Of course it requires talking to the users who use it, a transition, and sometimes a replacement. But it's work that pays off. A product that only ever grows eventually can't do anything well anymore.
How I know whether a feature succeeded
A feature that's built isn't yet a feature that succeeded. So I try to say before building what success would mean, and check it after a few weeks.
The measure isn't the number of clicks on it. The measure is whether it saved users the work it was created for. If it was built to remove double entry, that entry should disappear. If it was built to shorten a process, the process should be shorter. If neither happens, the feature hasn't succeeded, even if everyone uses it, and they probably use it because they have to.
Support questions help here. If more questions arrive after a new feature, something's wrong: either with the interface or with the idea itself. If questions about the old problem stop, that's a better sign than any statistic.
I check features that have been in the product for a long time the same way. Some of them nobody misses until I remove them, which means nobody missed them. Others turn out to be more important than I thought. Both are information I wouldn't have without checking.
Focus is a decision, not a consequence
A focused product isn't the result of a lack of ideas. It's the result of someone having rejected ideas. That's less pleasant work than adding, because every "no" disappoints someone, and because a "no" never appears in the list of what's new.
What helps me hold the line is one question: what is the thing the user uses the product for in the first place? If a new feature makes that thing better, it has a place. If it makes it harder to reach, because the user now has to get past one more menu, it doesn't.
I take a similar view of programs that do one thing really well. There it's about small tools; here it's about a product that can be considerably bigger. The principle is the same: the quality of an individual feature is worth more than the number of them.
How I talk about this with customers
When a customer proposes a feature, I don't say no. I ask which problem led them to the proposal. It often turns out the problem is different from the proposed solution and can be solved better, with less. Sometimes it turns out the feature already exists, only it wasn't found, which is a sign that the problem is in the interface, not in a missing feature.
And sometimes it turns out the proposal is good and belongs in the product. Then I build it. But only once it's clear what it simplifies for the user. The feature list grows by one. That's fine, as long as everything on it is there for a reason I can state.
