0. This idea is bad.
1. This idea is probably bad, but if someone wants to put together a more compelling argument we will discuss it at a future meeting.
2. This idea needs to be more fully developed before we can decide whether it is good or bad.
3. This idea is probably good, but it will remain in backlog limbo until someone makes a compelling argument that it is a priority.
4. This idea is good, and while it is not a high-enough priority to displace our current tasks, we will actively discuss including it when we plan our next sprint/release.
Depending on who you work with these may need to be gussied up with manager-speak to let people save face or to prevent people from hijacking the agenda to turn the meeting into a brainstorming session. But treating all of them as synonymous with "no" loses useful nuance.
1. The idea is technically feasible
2. The idea aligns with company's business goals
3. The idea is our team's responsibility and cannot be done by another team
4. The idea is more important than the other things our team plans to work on in the future
5. The idea is more time critical than the other things our team is working on now
If any of these cannot be proven, then it goes on the backlog as a P4 and nobody realistically will ever look at it. It's just the reality of corporate software building. There are always 10-50x more ideas than there are staff/time to work on.
Of course, all five of those can be, and often are, overridden by the Prime Directive:
0. One of the executives (often one of your grand-bosses high up on the totem pole) wants it.
Some engineer wants it bad enough that they just build it -or some version of it- and then some executive gives the go-ahead to invest more into it.
At the end of the day, ideas are just ideas. Execution is everything.
If you have to convince someone of all of those things in order to build some reasonably large thing over the space of a few weeks, that's probably reasonable.
If you have to convince someone of all of those things in order to allocate a few hours to fixing some tech debt or minor bug then your codebase is going to slowly deteriorate until the same someone is asking you why there's so many bugs and everything takes so long to develop.
Is it really true that your company cannot implement any idea that could potentially be done by more than one team?
Option value is a notion that Don Reinertsen promotes in his Lean 2.0 notion (google that and his name, mandatory stuff for wannabe PMs IMHO). Very simply put, he draws an analogy with stock options. They give you an option in the future to get some value. But there's a chance they'll be worthless and that you lose your money. The point is that the payoff can be much larger than the value loss. That's why they are popular tools for stock traders. There's a non linear relation loss-profit function. Which means you only need a few of your options to convert to profit to finance all of them. VC capital is based on this notion as well. Most startups are a write off. But a handful turn into unicorns and pay for the rest.
In product management, option value is the notion that some idea might be worthless but could end up being worth a lot. Doing a lot of work on something that's just not worth a lot is probably wrong. Doing a little bit of work on something that might have a huge payoff is probably smart. Even if it's slightly risky or uncertain. Doing a lot of work on a lot of things that might be valuable like that at the cost of stuff that you actually should be doing is probably not optimal and very risky. But you should be taking some calculated risks at least part of the time just in case. Worst case you lose some time. Best case you create a lot of value in a way that you never planned to. Balancing risks is your job as a PM.
The point here is that if you only do planned things and don't even entertain doing things that might be valuable outside of that scope, you are probably destroying a lot of value and you are placing a risky bet on your plan instead. If the plan is wrong, you might lose everything.
Which is one of Reinertsen's key arguments against the original lean movement. You throw out the baby with the bath water if you do that. Bad idea for startups because you now make a risky bet on your plan being correct. Which of course it often isn't in startups. Pivoting is the notion of being able to turn a bad plan around. That gets easier if you invested in some option value that gives you the option to do so. A lot of unicorns emerged out of the ashes of failed startups.
Big organizations are notorious for being risk averse and not having the internal capability to innovate even after they've identified the need to do so. As soon as management chains get involved, that's what happens.
As someone who has reason to call technical meetings on a regular basis, I've always had trouble with this. Do you mention 'brainstorming' in the agenda? Do you use a different header?
Most of the meetings I end up having are only vehicles to get necessary players into the same room and engaging in dialogue about a problem with a technical angle.
Advice appreciated.
I've personally found you should almost never need more than 30 minutes unless you specifically want to get into rabbit holes. And if you do need more than 30 minutes, it's probably better to split it into multiple sessions of no more than 30 minutes anyways to prevent this from happening. If you still have this problem at 30 minutes, shave 5 from either side (or both), which you can even use the excuse of giving time to transition between meetings.
That's not to say you shouldn't genuinely allow room for brainstorming, but if you're going to take an entire room of peoples time, make sure it's something the room agrees is worth discussing and find another time to do it instead of getting sidetracked now. If not, offer some 1-on-1 time, and move on.
The way I deal with this is several custom fields in our issue tracker kanban board that qualify any idea, no matter how good, crazy, in-feasible, etc.
The most important ones are:
- Value & Effort (one field) this is a quadrant of HighLow, HighHigh, LowLow, LowHigh. It's a reflection on what we would get out of doing something with the idea. High value and Low effort means you need a good reason not to kick an idea further. Low value and High effort kind of means a no, unless there's a really good reason. Anything in between can be decided on a case by case basis. I like the Low effort ones. They may not be that valuable. But sometimes they are nice to do. And you can just squeeze them in.
- Next Step: This is a range of values that provide me an indication of when I should look at it again. Some things need to be fast tracked. Some things need more discussion/elaboration. And the rest is stuff that we might revisit or reject right now. I don't tend to spend time on rejected ideas unless somebody brings those to the table again. Things that linger too long without being actioned are going to end up labeled as rejected. Which just means they stop consuming my time.
I have a few other fields (tags, priority, etc.) that are a bit more standard. But those two are the primary tools I use for deciding where to bucket ideas and how often to look at them. I should spend more time on high value ideas than on low value ones. And I should prioritize actioning items that have a next step that says I should do so. Anything else I can safely ignore indefinitely. If somebody doesn't agree, we can always discuss and change it. But there needs to be a good reason.
This isn't perfect but it's a good mental model of dealing with incoming ideas in a bit structured way. I hate overly long and poorly organized backlogs because they suck up a lot of time and energy without delivering much value. And the longer and more unwieldy they get, the less likely it is anything will happen. I sometimes refer to these things as idea shredders. Good stuff goes in, and then nothing happens.
Anyway, I'd be curious to learn what others are doing with their backlogs.
Just be direct and realistic. If it's to a customer, "we'll add it to our backlog for review" and tag it as customer suggestion so it doesn't just sit there forever.
1: Don't worry, nothing's going to happen.
2: Something may be happen but we should wait and see
3: Maybe we should do something about it, but there is no clear action
4: Maybe there was something we could've done, but it's too late now
Stringing along a bunch of people who think they are being heard and listened to when you are not is a morale killer when the tide goes out & we see who's been swimming naked.
Rarely have I met one that can define actual priorities outside of this.
[0] https://en.wikipedia.org/wiki/List_of_countries_by_greenhous...
1. No such crisis exists
2. Why would you believe such a thing?
3. It's too early to draw any conclusions before the full investigation
4. Look over there, a new scandal
In all seriousness, the best thing is to have management that clearly communicates what the high level company goals are on a quarterly (or whatever cadence is appropriate for your business) basis. People don't like to hear no, but they understand "the main objective for the quarter is to close $X in new deals in Y market segment, and since this isn't going to directly contribute to that, it's not going to be a priority in the near future."
It's a great idea in theory until you see how much two full days of timeboxed planning every quarter beats down dev morale in practice. It's great for teams that literally don't know what they're doing and don't know their dependencies, because it forces them to confront their mediocrity. But you have to move beyond it eventually.
One reason they persist in their insanity is everyone is an expert in giving excuses why their own team is too tied up with work to assist. Sure this reduces conflict over telling middle-management why their ideas are stupid, but in the long-run it's detrimental to the organisation to avoid explicitly hashing-out disagreements. Creating a culture where everyone lies to avoid hurting one another's feelings is not good.
You often still need people to feel like their ideas are being considered so they don't just shut down and contribute nothing in future meetings, or consider you to be railroading every meeting.
Granted, after the meeting, I'll often joking-but-only-serious point out "Look, our backlog is really long -- let's be honest, we're not going to revisit <that> for months at this rate, so I hope you realize it's not a priority and probably won't be unless the priority changes. If we need it on a shorter timeline, talk to <personName>."
I have very occasionally used hard-shutdowns of ideas or requests, but I think I have only used it when an idea was threatening to balloon the scope far beyond any hope of success. Maybe twice in the last few years.
("No, I'm not going to implement it that way -- it's needlessly complicated" or "I will not discuss timelines for phase 2 of this project until phase 1 is complete -- let's get back to closing out the outstanding issues with phase 1.")
There's a time to be frank, and other times you need to smile and gently redirect just to get things moving again before you waste an hour sparring or circling an endless unresolved debate.
Inside a company, I don't think there should be space for these sorts of responses. I can see these only being necessary/used where people are disenfranchised and not involved in setting or understanding the overall product priorities. But then I've always seen the PM's prioritisation role more as an expert mediator than a dictator...
I think its a funny website to browse and say "haha", but nothing more.
In practice, there is no easier way to annoy these types than by taking these platitudes at face value. Don't go gathering the data.
(I get why this style of communication has become common in business settings, especially in large orgs. It still rubs me the wrong way.)
Food for thought, don't make someone say no as often.
Nothing wrong there, it's not "no". Sometimes we put ideas on ice until there's time, or other factors align.
If your role is long-term, you have the underrated power of long-term planning. Often in past I saw the desire to tear down and hastily build something amazing in a few weeks, rather than chip away long-term where "amazing" gradually fades into view.
This one time, I was asked to make a countdown timer for new website launch, back when I worked with PM's who thought users gave a shit about website launches.
I am not sure what this site adds other than the ability for the uncreative to find snarky ways of telling people to fck off.
/s some, some PMs try and build product, most are large corps are figuring out how to segment their niche and extract max rev from the tech ladder
Nearly the entirety of this discussion outlines political and organizational dysfunction.
Blah blah blah the interests of the business. Fuck that. Capitalism sucks the joy out of software.
You'd think "it does X, Y, Z, and nothing else" would be clear-enough, but in practice a blanket prohibition is too vague to have force, it's an invitation for scope creep. So saying "it will not handle W" is useful, even if it seems redundant at first glance.
(Context: https://www.youtube.com/watch?v=hNuu9CpdjIo&t=56s)
Sales Engineers for example are trained never to give the hard No to a customer request. Sometimes, they think they are saying no but the customer hears, "maybe". For example, "we'll consider adding that to the roadmap". Now the PM is stuck developing a single feature, the customer just got handed a stick to beat you with, and your CFO just got lumped with revenue thats unrecognize-able until some feature ships in who knows when.
The features were typically well implemented and integrated with the rest of the product, and totally unused.
The features added substantially to the complexity of the code base. It's funny to see HN defend quality over quick and dirty software. Though I understand and agree with the sentiment, the unused features were much more difficult to remove because of their "quality" (as measured in the eyes of the dev team).
Assuming a PM cannot comprehend entire roadmap, vision and details in their head, simply have the answer based on merits.
This is the intercom post from 2013 on the same topic - https://www.intercom.com/blog/product-strategy-means-saying-...
Anyway, copied the "reasons" here in case you want to use it locally. e.g.
## bash:
shuf -n 1 why-not.txt
__ const sampleData = [
{ "text": "Let's add that to our discovery backlog" },
{ "text": "What problem are we trying to solve?" },
{ "text": "That's an interesting perspective for our long-term roadmap" },
{ "text": "Let’s park that idea for now" },
{ "text": "That’s worth considering once we have more resources" },
{ "text": "We should validate that with users first" },
{ "text": "Can we revisit this after the next sprint?" },
{ "text": "It’s a great thought, but let’s prioritize our current goals" },
{ "text": "I’d like to hear more thoughts on this from the team" },
{ "text": "Let’s circle back after we’ve tackled the core priorities" },
{ "text": "We need to ensure alignment before moving forward" },
{ "text": "That might be more relevant in the next planning cycle" },
{ "text": "We should let this marinate a bit longer" },
{ "text": "Let’s pencil it in for further discussion later" },
{ "text": "Let’s table this for now" },
{ "text": "That’s a good thought, but let’s revisit it later" },
{ "text": "Let’s keep this in mind for future consideration" },
{ "text": "We’ll need to assess this in the context of our current objectives" },
{ "text": "Let’s put this on the back burner for now" },
{ "text": "Interesting idea, let's explore that next quarter" },
{ "text": "We should prioritize getting feedback from stakeholders first" },
{ "text": "This might be a phase two initiative" },
{ "text": "That could fit in a future roadmap iteration" },
{ "text": "We’ll need to revisit this once we’ve hit our milestones" },
{ "text": "Let’s gather more data before moving forward" },
{ "text": "I think this could be valuable down the line, let’s revisit then" },
{ "text": "Let’s schedule a follow-up on this when the time is right" },
{ "text": "This could be part of a larger initiative, but let’s hold off for now" },
{ "text": "Let’s focus on the immediate deliverables first" },
{ "text": "We’ll circle back once we have more clarity" },
{ "text": "We already finalized our OKRs for H1 but if you throw it in the backlog maybe we can get it prioritized in H2 planning"},
]