Most features die quietly.

No one uses them.
No one measures them.
No one dares to remove them.

In fact, over 80% of new features are rarely or never used, according to a feature adoption study by Pendo.

Every feature is a bet.​
And to know if it paid off, you need to treat it like an experiment from day one.

Here’s how I approach the full lifecycle of a product feature:

1. Discovery – Where the idea comes from

Feature ideas usually come from one of three places:

• You feel friction in your own product
• A customer sends feedback or a request
• New tech (like AI) unlocks something that wasn’t possible before

Ideally, you build features that solve real pain, not just ideas that sound cool.

If you’re not getting real feedback, go find it.
Write users.
Jump on a call.

Ask them about their problems, not about your product, but about their work or life.

They won’t give you the solution. But they’ll give you the pain.
And that’s what you need.

Once you identify a strong pain point, write it down as a user story.

Then, turn that into a hypothesis:

Example:

This is key. It gives you something to measure later and a reason to remove the feature if it doesn’t deliver.

2. Design – Explore ugly and beautiful solutions

This is where you think through how to solve the problem.

I usually do two things in parallel:

1. Prototype the simplest possible working version (even if it’s ugly)
2. Design the ideal version, the one we’d love to build

Then we find a middle ground with the team.

What’s shippable? What’s valuable? What’s fast?

And don’t forget to involve developers early.

Their input will save you time and pain later.

Tools like Lovable make it super fast to turn rough ideas into prototypes, so you can test early without waiting for dev time.

3. Testing – Put the idea in front of humans

Before you build anything, you want signals.

Take your prototype and test it:

• With existing customers
• With teammates
• With friends in your target group

Ask:

• What’s confusing?
• Would you actually use this?
• How does this fit into your day?

If reactions are lukewarm, rethink the idea.

You’re better off pivoting now than launching something no one needs.

4. Delivery – Ship it fast, but prep for what’s next

You’ve got alignment. It’s time to build.

But don’t just write code and push it live.

You also want to:

• Add tracking for the feature (usage, retention, engagement)
• Add a feature flag so you can turn it off or run a split test
• Keep it small. Your goal is to validate the value, not impress anyone

Shipping should be fast, focused, and reversible.

5. Activation – Make sure users know it exists

So many features die here. They’re built. They’re shipped. But nobody sees them.

Your job isn’t done after deployment. You need to activate users.

How? Depends on your audience:

• For enterprise users: Jump on a call, walk them through it
• For B2C: Use emails, banners, nudges, or changelog updates

One smart trick:

Beta tester mode.

Let users opt in to new features early. They’ll give better feedback and feel part of the process, even if the feature isn’t perfect yet.

6. Impact – Measure, then decide

Once the feature is live and people are using it, start measuring.

Look at:

• Usage: Are users trying the feature at all?
• Frequency: Is it just once, or does it become a habit?
• Retention: Are users sticking around more because of it?

If your original hypothesis was “this will increase weekly active users,” check the data. Did it?

If yes → keep it

If somewhat → evolve it

If no → kill it

No hard feelings. No ego. Just product thinking.

Zombie features do more harm than good.

Final thought

Every feature is an experiment.

You don’t just build it once. You learn from it.

Treat your features like bets.
Track what happens.

And be brave enough to remove the stuff that doesn’t work.

That’s how great products are built.