We had customers that wanted 'permissions' for their "sub" accounts so they could have fine grained access to features. They would threaten to not use our system until this was implemented.
Implementing this feature was a lower priority and more difficult to implement for us then other revenue generating features (also a good way to prioritize things).
The interesting bit is they still used our system, despite the missing feature. I think because we focused on things that generated revenue. We kept good conversations with our customers and let them know when we thought we would add it. We kept delaying it and it took us 6+ months. In the meantime, we increased our (and their) revenues the whole time.
Once we finally rolled out the feature, existing users didn't really care and new customers just had the feature. This strategy worked really well a number of times.
By consistently delivering on everything else that they are asking for and most importantly... helping increase their revenues (or whatever other metric you use with your customers for their success).
Not delivering sometimes has a reverse psychological effect that you can use to your advantage... it keeps them wanting more.
Personally, I feature flag them and hide it for all other customers. If the feature requires extra cost to keep going then I let the customer know the situation and charge them to keep it going.
This leads to building a feature factory. It's a more sales driven development approach. You'll eventually hit a scaling problem making it too concrete for some people or worse when there's a misfit between what the customers abstract representation of the feature request is vs. what you actually develop. Which then leads to more costly changes.
>So far your instinct as product designer/manager/engineer might be to take what customers say they want at face value.
That would be the worst way to go about building anything. Taking solutions from customers as opposed to problems to identify jobs-to-be-done and reasons for non consumption isn't something someone who knows how to build products does.
The question then becomes how does someone who generally knows how to build the right things build the bare minimum feature, the original question and title of the post, given the constraints on time and resources cited in the first paragraphs.
One can do several things. For example, writing the description and code examples for a yet to be library and shop it around, see if it makes sense, then write the library.
I also do that for internal tools, libraries, SDKs. I'll send client code around and see if it makes sense to engineers. I also had non engineers who never coded use libraries to do something useful. I just give them a laptop and docs and see how they use the thing. If they can do it, I know programmers can.
To get back to the original problem, prioritizing can lead towards minimal features. We have a section called "Instances" in our issue templates. If a feature issue does not have several instances where the problem manifested for several people, we just won't do it. We need concrete examples of a problem being frequent and expensive / high impact (loss of work, or prevents work in the first place).
For example, I'll look at the analytics for our internal platform and see that my colleague who we built the thing for is not using it. Why, we ask. It turns out the Docker images are too large and take a lot of time. He loses patience. They contain several libraries that he does need.
We built a minimal image that can get him to start after 30 seconds instead of 2 minutes, and we saw usage increase.
Yesterday, I saw he was giving a demo using his local environement, not the product. I'll ask why. What's wrong. What sucks. Why did he use his laptop instead of the platform.
The general sentiment of the article is sound. Always observe, ask questions, look for the underlying problems and how frequently they happen, how expensive they are (as in what are they doing to solve that, is there someone working on it, does it cost opportunities, etc)
> * Taking solutions from customers as opposed to problems to identify jobs-to-be-done and reasons for non consumption isn't something someone who knows how to build products does.*
What’s amazing to me is how this concept is either a “you get it or you don’t” thing.
Sure, it takes a little practice to learn how to turn feature requests into the underlying business problem, but, like, I work with so many people who still can’t even grasp this basic concept after many, many years.
This is dangerous as well, especially in enterprise deals where the prospects say they like the product but it lacks one feature, and someone on the team goes "Sure, we can add that" with the delusion that they'll close the deal if they just add this one feature. It rarely, if ever, is the case. If the "feature" is not about some specific security or compliance concerns but an actual feature, questions need to be asked during that meeting.
One common pattern is "Your product does not have X? Product Y has that feature", and one common pitfall for people who don't "get it", as you said, is "We should definitely add the feature X that Product Y has". One better approach is to ask "How long have you been using Product Y and how is it working out for you?". The answer is invariably "We don't use Product Y". Of course they're not; we probably wouldn't be meeting in the first place if they were.
Sometimes people tell me about products of my "competitors", or people from these companies make jabs or passive-aggressive snide remarks about me or the product: I'm building an MLOps platform; my competitors are people's laptops.
That pursuit of listening to prospects' features and solutions, or looking at what others are doing and following it is not a good way. Asking people what they are trying to do or accomplish and extracting problems is effective. What's the current state, what's the desired state, how they're trying to bridge the gap between the two, why they're failing to do so.
I wrote a bit about this here with the following example: a friend of mine asked me how to solder a thick wire to a thin metal plate. I asked him what he was trying to do. It turns out he wanted to solder a thick wire to a fuse because the fuse couldn't handle a stronger current and melted. I told him the fuse did its job precisely upstream, and gave its life so more important and expensive appliances downstream could live. This is one example of XY Problem: https://en.wikipedia.org/wiki/XY_problem
1. Talk to customers enough that you know what they actually want to achieve, and how specific additional features in your product will get them there
2. Ship the absolute minimal possible deliverable feature (a log of which I keep here: https://twitter.com/RozenMD/status/1364881512500404224?s=20), and mercilessly remove unused functionality after a few months of zero use.