JIRA + a tree of tickets is so bad for project planning I recommend using the backlog as a diplomatic tool and a polite way of letting things get lost. It is is better to use advanced scheduling tools, like a spiral-bound notebook or sticky notes, rather than a backlog. The backlog is for management and politics.
I hate this approach. I totally get it, to be clear. I've done it. But I hate it. It's a sign of a really bad culture if you have to placate people in this way.
If your senior leadership is clearly communicating priorities, you should be able to say, "Look, this is an interesting idea, but as you know this quarter we're very focused on X, and this just doesn't align with that. The best route to get this done is to give your feedback in the next planning process and see if you can push Y to be a priority, then we can definitely talk about getting this on the roadmap."
A huge part of the job of a PM is to say no. If people aren't able to take a no on feature requests, there's a problem somewhere. Maybe it's with the way you're delivering it, maybe it's with the overall culture or maybe it's with the person making the request. Whatever the issue is, though, it's better to deal with it and create an environment where people understand that sometimes their requests will get declined for valid reasons.
What do you use and what are its top features?
If you just drop every customer email complaining about a supposed problem into a ticket in your company’s private queue, no one but internal employees will ever see it (and 99% of those won’t ever notice it or read it) but if you give your users a place to vent and discuss their ideas (with moderation of course) you can have a pretty powerful new idea/roadmap tool.
Get a stable product and then wait till someone else does something innovative and copy that.
But if they're around anyway, they can keep it in whatever personal backlog they have instead.
How should I manage my personal backlog? There’s over a 100 post-it’s on my desk. Should I create another backlog for longer-term ideas or maybe hire a personal PO?
> Should I create another backlog for longer-term ideas
IMO yes. That way you can easily review it before meetings, and come ready to said meetings with your most important items. I think this is quite a personal thing, so this kind of workflow may not work for you. But I found it almost impossible to work without such a list.
It's work to keep a backlog not a total disaster, but that doesn't mean the answer is "tool x" or whatever. It's just work. Ugly annoying work. Ie, work.
Seemed super effective.
In short: maintain a list of long term refactors that everyone's gradually working on, without necessarily showing it in the ticket tracking system.
Why? Why have two places for the same thing? It's just an awkward tagging system. When would you search this but not search tickets?
Alternatively, just don't write them down. If you don't get a benefit from keeping the idea, don't write it down.
Mid-option, I think linear does this by default, cancel backlog items older than X. Not been touched or moved? Probably not relevant. Plus you can always search through cancelled tickets.
A ticket is a different level of detail. Takes more time, thought and effort to put together a good ticket. If it's for something that's not going to happen for 12 months, then there will have been enough change in the product/org/etc. that the original ticket won't work as written anyway.
A doc with a bunch of categorized feature ideas has enough info that you don't lose any good ideas, and then when it's actually time to attack one of those categories, then you can do the work of building out actual, ready-for-implementation tickets.
> Alternatively, just don't write them down. If you don't get a benefit from keeping the idea, don't write it down.
Totally agree with this. A lot of stuff isn't worth writing down. If it's way out in the future and really important, it'll come up again anyway.
I'll frequently have an idea and toss it into a backlog ticket. Maybe just as a title to start. When a customer mentions that problem/feature, I can add that info in the backlog even if it doesn't immediately become a priority.
When the issue does become something worth working on, I'll usually add more details but the various evidence accumulated over 6 months of letting the item "bake" is invaluable.
A ticket-system like JIRA is the same as an e-mailclient to me. You sort by activity, having the most active tickets on top. You can flag/mark them, you can put them in different boxes or just use tags,... All are just means to create order in chaos.
But I would never think to move my old e-mail to a different 'system' than my normal e-mail(client). I never think of old e-mails or drafts as something I need to clean up.
You can then just tag them.
This means that a search can ignore them, or it can bring them up while you're looking at features/etc.
All that administration overhead is why the ticket based system doesn't get this information. If it takes 30 seconds to create (and properly organise/categorise) a ticket then that's too slow. I want to be able to write tickets as fast as someone can say them, and move/reorder them with my usual copy paste / text editing tools.
For example, ctrl shift v is how you paste unformatted in ms teams. You’d think by that logic, ctrl shift c would be copy but no it starts a call. There is no built in way to eliminate that and when I ask ms people they say “oh use powertoys and blah blah I had to do the same”.
There are multiple times this has been raised on the forums
https://answers.microsoft.com/en-us/msteams/forum/all/turn-o...
Do you want to put things like this on a different list, basically a “won’t fix” list? Why even write them down? Just to make people think you are listening?
This is across 8-10 jobs in multiple industries over close to 20 years. Some places have been better or worse than others but I can't think of any place where people routinely were creating, organizing, and categorizing tickets this quickly, at least not tickets that had any value to anyone other than them as a reminder to do one very specific thing.
Sure, for tickets that you deliver. But when we're talking about managing a backlog there might be 50 potential tickets that never get implemented (or even scoped) for every one that does. And you don't really want those to ever become a ticket at all because that ends up being far too much product work, precisely because it takes ~20 minutes for each ticket.
Put another way: you need a way to track high-level work for prioritisation before putting too much into scoping and detailing what implementing it would involve.
The trick is to have each "ticket" be basically a bullet point in a list (where lists are grouped by headings/subheading in a single document). Maybe some are 3-4 lines, but most will be a single line bullet point. That way you don't have to search it (which doesn't tend to work very well as you won't know what you're looking for), you can actually browse the entire document.
But it's worth reading the comment in context. If your problem is that old tickets are a nuisance because they're almost always irrelevant, just have them auto cancel and when you get that notification rescue the 2 per year that you truly want to keep.
If you don't have that problem, keep them.
> Why search through cancelled tickets which are resolved to find and unresolved issue?
Why would resolved tickets be cancelled?
Also, why search through two different systems?
> when you get that notification rescue the 2 per year that you truly want to keep.
That makes even less sense. Looking at notifications and making a decision on closing/reopening is a form of review. If you have time to review, do it properly on your own schedule and in batches rather than be beholden to some arbitrary autoclose timeline with yet another focus-destroying trickle of notifictions
It was when it was created, it's not now. And it is then practically removed.
Again you can build whatever workflow you want, tag stuff or move things if they're super important to you. Subscribe to them if they're vital. Or don't auto close if that doesn't work for you.
I don't think that having a tiny number of issues that are
* Never looked at
* Never prioritised
* Never searched for
* Not subscribed to by anyone that cares about them
* Somehow super important to not have a "cancelled" status on them
Should define your workflow to this degree that you start keeping multiple lists of work. I'm not sure I've ever come across an issue worth leaving like this. Can you tell me about an issue that fits this description?
> It's not now
You don't know that, in the process you yourself proposed that determination was done when you get an autoclose notification
A ticket is something where there is an understanding that we want to do it if time and resources permit, something where it would be okay for someone to grab it and do it.
On the other hand, an idea or suggestion may easily be something that should not ever be done, that drives the product in an inappropriate direction or adds an ability that we don't really want to exist for various reasons; and that is conceptually fundamentally different and should be kept in a separate place from the "big todo list".
If you want it to be that, sure. They're really just notes with IDs and tags. What you're describing is a curated backlog / upcoming work.
> On the other hand, an idea or suggestion may easily be something that should not ever be done
Ok? So either say why and cancel the ticket or delete it if you don't want a record of it. I don't get the value of writing it down in a different place so that you have to search in two places.
Usually when customers give feedback it's to address an immediate need they have, so they'll suggest adding a button/option/toggle/whatever. And that's fine, but if you do that for every piece of feedback, you'll end up with an unusable mess. Especially because it's usually very easy to add that one extra button/option/toggle.
You usually require someone to go through all the feedback and try to address the root cause of what they're asking for. Sometimes the extra option is unavoidable, sometimes it leads to redesigning some system to be more generic to support what the customer wants + more.
I do think the feedback needs to be linked to the work somehow, not hidden away in a separate PM tool or whatever. Ideally retaining the raw feedback, because sometimes when summarizing it, things get lost.
There is the issue of dupes but it avoids the other issue, which is that if you hard decline too many requests from right after they are submitted, stakeholders may stop giving you feedback, which is a bad thing. So it is an unhappy middle ground (which is I feel the normal place which product management occupies. I could setup a small shop in the unhappy middle ground and sell souvenirs.)
Maybe you don't want raw feedback dumped directly into your development board, so you might not just add extra columns to it, but another parallel board whose "done" column flows into the dev board's backlog seems like a reasonable approach.
I agree that you need some system to track feedback. I'm not convinced a board is the optimal choice, because (some?) feedback is kind of timeless. In my mind, it is never "done". Feedback can apply to future features that haven't been thought of yet when the feedback was originally processed, so it's valuable to keep it around in some sort of tag based system. You probably want a way to easily search it as well when designing new features.
In my experience it's really better to keep requests in a lightweight PM tool until they have garnered enough interest to write out as a ticket. The tool I use is Dynalist, really just a glorified todo app, where you can sort/collapse things that go together but there are a million tools like it. Only when there is some certainty it will ever be built does it get a proper ticket for the devs to look at.
But if you find yourself constantly fixing things that were specified and should actually work you got a problam with code quality. And if you constantly have to add small new things there is a problem with your customers clarity and a bigger meeting might be in order.
If someone wants to save an idea for a later iteration, they can do that however they want, but they don't get to clutter the team backlog with it.
It also mirrors my best experiences with well-managed backlogs.
This necessarily means that the backlog probably grows.
Suppose the idea is likely impactful but complicated to implement. In that case, you might want to think about putting those ideas together to argue for refactoring that would enable more impactful ideas.
If the idea would change the kind of service being offered, then it should inform strategic product thinking.
If the idea is relevant but unlikely to have an impact because it's too low level and about code quality, maybe you want to think of automating or including it in the linting process.
I think the problem here is that the tool, Jira tickets, isn’t suited for the use that you make of it: communicating with clients and defining product strategy. The problem is that there isn’t a good tool for that.
And you are doing both them and yourself a favor by making this clear. You might lose a couple of customers. But you would have lost them anyway and unhappy customers can also be annoying for everybody and slow you down, give you less than favorable reviews, etc.
- It provides an obvious place to put some ideas about then that can be collected over time. Often thoughts from significantly different points in time can provide valuable perspective. Even if most of the time they are just out of date.
- It allows tracking value over time. For example adding a quick note that this would have been helpful to customer 123. If you only file tickets when you are ready to implement them it is easy to miss the common friction problems.
So basically it is a way to log interest over time. But they are also easy to filter out so low cost to keep them around.
But I'm sure that you could also manage these "feature requests" in a separate system. But that often adds friction.
Therefore the giant "icebox" is out-of-sight but the social factor of "there is a ticket for my idea" across the company is also fulfilled. works pretty well so far!
When your company has 5 projects, do you count Project Z's backlog against Project X's backlog? No you don't, even though they are both in the same database. The reason you're OK with this is because your teams' views have been adjusted so that they only see their own project. So they each see what they consider to be their own backlog. Use the same approach for low-priority requests: put them in the same database, but don't elevate them to the team's backlog view.
If someone has an idea or a request you should not suppress it entirely. That will only encourage people to add yet another system of logging to your organization. Just because a request is not urgent or can't be put on the roadmap yet does not mean it's not important.
And why throw away what can be logged for later archeology? "Oh hey the answer to this new problem is right here in this old request we never got around to."
This gives us a natural filtering mechanism for community input. We regularly sort this by number of upvotes. It also lets our users submit some off the wall ideas, and gives a way for low friction community feedback to be captured. Finally, it lets community members easily be notified when a feature is delivered by subscribing to the issue.
We also have a separate, private list of commits to customers. (The commit is public and is added to a milestone, but the customer is private.)
We also group issues by theme[1]. It's not perfect but it's an attempt to make sure we don't run into the duplicates issue you mention. It allows the eng team to address multiple issues in the same area of the code at once.
I understand what you are saying about clutter, but the low cost public feedback and tight loop between issue and code is worth some issue creep, IMO.
0: https://github.com/FusionAuth/fusionauth-issues/issues
1: https://github.com/FusionAuth/fusionauth-issues/issues?q=is%...
Still think there's value in having an open roadmap and feature list that customers and users can submit too, regardless of industry. I wouldn't recommend you use GitHub, though :).
(/S this isnt actually a good idea but may be practical depending on the org)
As for my first attempt to guess the power structure: vote = 1 + sum(direct_reports.vote)
You could have a suite i guess.. maybe look for overlap?
Satisfaction? Vote = vote * staff turnover for voters role.
Greed? Vote = vote * voters team profit
Top down control? Vote = vote * voters grade
Reverse disfunction? Vote = vote * number of complaints raised by voter
Cross functional impact: vote = vote * num departments voting for this
My question marks reflect i have no idea what the real optimisation is when you select a defined metric / score.
In reality (as someone who wants to make things hollisticially better in a sustainable way) i look for the overlap of several things:
Who do people have on speed dial to fix issues? Will this reduce how many calls they get? Ignoring what official processes say.
Will this impact the bottom line?
Will it increase customer satisfaction?
What will be the impact on staff turnover? I prefer to reduce this but at least there needs to be a mitigation if its negative. Key questions are: will people better understand personal their impact on Cost and quality? Will this make success and failure clearer outcomes for the individual?
Then finally will this be a step towards or away from governance principals of org? E.g. does this cause party A to have needless influence or judgement over party B (at all levels).. basically will this enable individual agency at all levels.
I always justify it on paper in terms of governace efficiency/efficacy, profit and quality.
They are not actual features, they are a information collection on how a idea might be not possible or a placeholder for a better solution not yet in the making.
Not all tickets have to become a feature in software- some can become wikipedia pages on requirements/conditions of the project.
This was part of the wisdom of the ancient agile way: a box of index cards for your backlog. The physicality of it gave clear indication when it was getting silly. Furthermore, regular backlog pruning was a necessary activity because the box would get full!
I do think it's important to organize all feature requests, pain points, feedback etc. though but it needs to be separate of delivery management and it should be thematic (assuming there's a lot of feedback). That's the point of CustomerIQ (I'm a founder), to give that a home but also quantify themes over time. These would inform the backlog/possible make it in, but keeps delivery tools cleans.
I hate the strategy of just taking every idea you hear and throwing it into a ticket. You just end up with this giant icebox of stuff you'll never do. If a big new prospect demands one of the ideas that's in the icebox be implemented immediately in order to close a deal, you're probably still not going to pull it out of the icebox, because you don't remember that it's there. Instead, you'll just create a new ticket for it, and eventually when going through the icebox, someone will go "hey, I think we built this already" and close as dupe.
Instead, I strongly prefer to have tickets that at least have some possibility of getting done in the short to medium term, and store other ideas elsewhere. Engineering keeps a list of tech debt that they'd like to address. PMs keep one list per project of possible improvements. For potential new features/products, they write PRDs but don't immediately turn them into a bunch of tickets.
Ultimately I think the giant backlog of stuff that mostly won't get addressed is a sign of weak PMs who are afraid to say no and like to fall back to the comfortable answer that is, "sounds interesting, I'll write a ticket for it."