Home
@vernaq
things-product-managers-say

Things Product Managers Say

Public

• 40 items

A translation guide to the carefully worded phrases product managers use when prioritising features, aligning stakeholders, and explaining why something everyone wants will definitely not make the roadmap.

Items

It’s on the roadmap

It might happen someday.

Let’s align on priorities

Everyone currently disagrees.

Let’s avoid scope creep

The feature list is growing too fast.

Let’s break this into phases

This is too big for one release.

Let’s define the MVP

What’s the smallest thing we can ship?

Let’s focus on the user

We’re ignoring the internal request.

Let’s look at the data

This discussion needs evidence.

Let’s make it intuitive

Users shouldn’t need instructions.

Let’s put that in the backlog

We’re probably not doing that anytime soon.

Let’s run an experiment

We’re not committing to this yet.

Let’s sanity check this

Let’s confirm this idea actually makes sense.

Let’s ship something small first

We’re building a minimal version.

Let’s take a step back

This conversation is going off the rails.

Let’s talk about the user journey

How the user experiences the product from start to finish.

Let’s think about the user experience

How the product feels to use.

Let’s validate that

We don’t actually know if this is a good idea.

That’s a great question

I don’t have the answer right now.

That’s an edge case

We’re probably not building for that scenario.

That’s interesting

I’m politely unsure about this idea.

This might be a V2 problem

We’re not doing this right now.

This unlocks a lot of value

This feature could be very useful.

We don’t want to over-engineer this

Keep it simple.

We need clear success metrics

We need numbers to judge the outcome.

We need stakeholder alignment

Several people need to agree before we move forward.

We need to reduce friction

Something in the flow is making things harder than necessary.

We need to simplify this

This has become too complicated.

We should communicate this clearly

Users need to understand what’s happening.

We should focus on the core use case

Ignore the complicated ideas.

We should future-proof this

Design it so it won’t break later.

We should gather feedback

Let’s see what users think before continuing.

We should iterate quickly

Ship improvements frequently.

We should keep the scope tight

This feature is getting out of control.

We should learn from this

Something didn’t work but we gained insight.

We should optimise for adoption

Make it easy for people to start using.

We should prioritise impact

We’re not building that feature.

We should revisit this later

We’re not solving it right now.

We should test that

This might not work.

What does success look like?

How will we measure whether this worked?

What problem are we solving?

Why are we even talking about this?

What’s the long-term vision?

Where does this eventually lead?

Vernaq is in beta — we’d love your feedback. Send Feedback