The right amount of process to keep delivery speed up and annoying meetings down
I remember when I was looking for jobs as a software product manager (a while back) all of them were requesting experience in “Agile”. At NVIDIA we were following a strict waterfall process (more on that soon) so I had no idea what agile was. Fortunately this trend of “agile in job posts” is now disappearing (as far as I can tell), but nevertheless at the time I had studied the methodology extensively, in order to be ready if any questions were to come up during interviews. Not surprisingly, no question ever came.
Both agile and waterfall are methodologies and processes with which to manage an engineering team. I say “processes” though I’ve definitely met people in my professional career that actually see each of them more as a philosophy. In the sense that they become very polarized and dogmatic about which one is better, forgetting that the ultimate objective is to get your team to deliver products, not to have the team follow a process to the dot for the sake of organization and cleanliness.
Just like there are clean freaks, that like cleaning their house beyond what is reasonable, in technology companies there are agile or waterfall freaks, which take an innate sense of pride and pleasure by making teams follow those processes to the dot, usually beyond what is helpful (and significantly hurting the mental health of everyone else involved). Hopefully by the end of this article you will squarely NOT be one of them. If you are one of them, then by the end of this article you will most likely want to cancel me.
If at this point you don't know what Agile is and you're thinking of reading up on it, save yourself some time and don't. In this article I should cover all that you need to know about it. Most importantly though, I'll cover all the things you do not want to know about and hopefully convey all the learnings that I've had in the space.
Throughout the years, I've tried different methods of Agile and Waterfall and I now believe that I have found a good tradeoff of them. As for all processes, there isn't a one size fits all, but the blueprint outlined here should be fairly adaptable to most software teams. For hardware though, waterfall is still the way to go given there are a lot of dependencies on builds and cross functional teams.
Let's start to cover what the general knowledge about Agile versus Waterfall is.
Agile vs Waterfall: a choice or a spectrum?
I'll start with a summary of my understanding of each.
Agile: This methodology is focused on rapid interaction, only planning out the next few weeks and shifting the plan as things go. The idea is to have a prioritized list (backlog) of tasks (usually known as “tickets”) and, every few weeks (sprint - usually 2 weeks long) get together with the team, define what tickets will be done in the sprint and then do them. Each sprint should result in features getting shipped, then, based on the feedback from customers and the impact on pre-defined metrics, the next set of tickets is decided. Things are continuously added, removed and reordered in the backlog then, when they get added to sprints, they get delivered
Waterfall: This is the traditional project management framework where you define the output you want to get to, you create all the tasks that are needed to get there, you sequence them in parallel or sequential format and then you work through the Gantt chart in order to get to a ship date. Unlike agile sprints, which take a few weeks, usually waterfall plans take months and, in some cases, even years.
There are some product use cases and themes which definitely would lean more towards one or the other, but the truth is that there is no team which is only waterfall or only agile. So I see it as a spectrum. You need to decide where on the spectrum of agile to waterfall your team lies. And I can tell you for sure that your team will not be at any of the extremes.
Why don’t pure agile or pure waterfall work?
- Agile: You effectively can't set any launch dates. The dynamic nature of agile means that you only know what's happening in the next sprint and it's very hard to plan for things that may happen months out. Whether you like it or not, you do have to set some target release dates at some point and can’t just rely on things “happening” and pivoting your way to releases. See the urgency and tight deadlines article.
- Waterfall: Situations change over time and things don’t always go to plan. Unless you pad the schedule aggressively (which is bad, see the urgency article), it is impossible to set out a plan for months out and respect it to the dot. For waterfall, every time the plan changes, you are supposed to redesign the whole plan. As a result, if you follow waterfall aggressively then you will spend more time planning than actually delivering
Agile terminology: what is what
If there is one thing that is persistent across the technology industry though is the terminology of Agile. A lot of teams and companies still use them even outside of a strict agile framework.
- Ticket: This is a task, usually assigned to a single person and usually completable within a fairly small amount of time (one week max). We’ll cover later how to effectively define a ticket
- Epic: This is a collection of tickets, usually linked to a specific deliverable or theme
- Sprint: this is the unit of time in which work gets scheduled. Tickets get assigned to a sprint and the assumption is that they should be completed during that duration (more on that later). In most cases I’ve seen and heard, these last 2 weeks
- Sprint Planning: the meeting in which you decide (with the team) which tickets end up in the sprint
- Standup: supposedly (but rarely so) meeting in which each individual in the team shares what they did since last standup, what they’re going to do until next standup and any blockers they need help with
- Retro: Meeting in which you look back and discuss what went well, what didn't and what are the learnings that the team can improve on
- Backlog: the prioritized list of tickets which are NOT in the current sprint
- Board: visualization where you look at the tickets in the current sprint divided by their statuses (usually to do, in progress, in testing, done)
The curse of Jira
Historically, Jira has been the software that everyone was using to do project management in software teams. Because of that it elicits a lot of extreme love / hate from people in the industry. It is embarrassing to admit, though I don’t even know which of the terminology above comes from Agile vs what was popularized by Jira. It actually doesn't matter. Jira, just like any other tool, is a tool. You can use it effectively or not. Whether it helps you or not depends on you (and your ability to convince the team to follow your process). Don’t get caught up in factionalisms supporting software A vs software B. They are a commodity and all offer the same functionality. You can probably build your own with GenAI anyway if you can’t find a project management software that you like.
These are the terms that are most widely used across companies and people in the technology industry. Lately there are a lot of other similar tools like Linear and monday.com. I have never used them though from what I understand, they are very similar or anyway have very similar concepts, so regardless of the tool that you're using you should be able to try out this process.
A team management process that works
Forgot the caveat:... that works for me.
As other things, processes are very subjective and depend team by team and case by case. I found that this process has been fairly helpful to me across my experiences at Mythical and Lyft. Because of that, I think that it applies to most of the cases out there. So, even though I'm not prescribing this for your team, there's a very high chance that this is going to work for your case. There's going to be a paragraph at the end where I’ll point out the cases in which it doesn't.
This is the summary and I will go in detail of each step right after
- An epic is a key customer impacting deliverable with a deadline
- A ticket is a key feature or functionality deliverable
- You do sprint planning on the first day of the sprint - Monday
- You do standup EVERY DAY, but you do it efficiently. You get a lot of hate points from engineering for setting this up daily but help keeps everything on track
- The PM is responsible to actually keep the backlog prioritized and you WIPE IT COMPLETELY at least a few times a year (after major releases)
- Retros are useless and you do them on a need-to only basis when people need to vent and the team is not co-located and can’t take that to the bar
Let’s dive into each of these, in this order (there’s a reason for the order)
Epics: defining them correctly
You can jeopardize your product from day 1 if you don’t define your epics properly.
An epic is a key shippable deliverable, with a clear delivery date, that has a direct impact on your customers
This outlines the must haves of an epic:
- A delivery date in the form of a day (and a start date)
- Something that is clearly either shipped to production or not shipped to production
- Something that either directly or indirectly affects your customers and hence your business
- Customers can be either internal or external
- Something that, from the offset, has a defined and clear (to the team) scope
This also rules out the following from being epics:
- General open ended projects
- Containers for “will do in the future” or “when I have time” improvements
Why is all of the above important?
Remember the article on delivery dates? Without delivery dates nothing gets done. Tying the concept of epics to delivery dates is specifically because: (1) you want the epic to be done at some point, preferably soon (2) you want any work that is not tied to an important goal or delivery objective to NOT get worked on.
By forcing epics to be a specific deliverable and forcing each ticket to belong to an epic (we’ll cover this in sprint planning) it will be immediately clear to the product manager when some work, which is not fundamental and tied to the goals, is being added to the sprint (which means it will be scheduled and worked on). A product manager has to sniff that out and determine with the team whether that is actually worth working on as soon as possible.
Often teams will want to create epics as “containers” for ongoing maintenance work and future improvements they think of. I suggest against that. As a product manager, when you will be reviewing your strategic roadmap, you will be looking at all the epics and deciding how to sequence and prioritize them. If there are a bunch of “filler” always open epics, the strategic prioritization is going to be harder and more distracting because of all the filler epics that can’t realistically be prioritized. The team will push to include them in the roadmap and in the plan to work on them “when there is time”, which is going to add a bunch of projects to your planned month / quarter etc (depending on your planning horizon). You want to avoid it since:
- Given these are “always open” epics, by definition you will never finish them
- If you never finish those, then it sets a precedent for not finishing any epic in the allotted planning time, which results in project delays
- If they are in the plan, it justifies engineers working on those instead of the higher impactful epics
- If an engineer gets an idea, then they can just add it to the always on epic which is scheduled for the quarter and start working on it, often without the rest of the team being aware of it (until the next standup, which may be too late)
I’m not saying that maintenance / filler work is not important. Sometimes it is. However it should be consciously added to the plan, when needed, when time allows for it and with a clear deadline or timebox.
The importance of having epics be clearly time bound is that you want to avoid scope creep. If something you’re working on is enlarging in scope, the team will have to ask the PM to postpone the target completion date of the epic, which will force the very important trade off (see article on golden tradeoff) regarding scope vs time. As a product manager, when dates are important and the team discovers that the project is going to take longer, you want to de-scope and remove features. If an epic is not time bound, the scope creep tickets will continue to be added to it and it will be hard to understand how far along you are. If the epic is time bound though, then any additional duration of work can be balanced by either:
- pushing something out of the epic into the next one
- creating a follow up epic with another timeline to house that work and setting the expectation with the team (and beyond) for another milestone
If more work needs to be added to a time bound epic, I usually suggest creating a new follow up epic after that, so it is still clear to the team what is important now vs what can be done later. And also gives the PM the details needed to explain to leadership what extra part of the work needs to be done and why a follow up is needed.
Let’s now cover why epics need to have a “customer impact”.
You want the completion of an epic to be an important deliverable for the team, something that can be celebrated and broadcasted out. The team should feel accomplished and externally validated by shipping the outcome of the epic. Tickets often are too granular and, usually, no one outside of the team should care about a specific ticket getting done. Finishing an epic instead should be a big deal and something that the team can be rallied around.
From my experience, anything that doesn’t affect customer outcomes is not really appreciated by executives, customers and other teams at large. Refactors, simplifications, re-architectures… if they don’t bring meaningful changes to metrics, then they are not appreciated. So you should work on them, though not as an individual epic. Better to trickle them across different epics, with each epic driving customer outcomes.
Ultimately your roadmap should be made up of epics, so when you’re presenting your roadmap you want to have the epics represent the main work of your team, which should be customer outcome focused. Any “filler” work needs to be exactly that. No need to be represented at an epic and externally (to the team) shareable format. That will also ensure the individual team members don’t over assign importance to the work (and then get disappointed if it is not appreciated).
Tickets: how to write a ticket and avoid misdeliveries
Whereas getting an epic wrong usually results in delays to deliveries, getting a ticket wrong usually results in building the wrong thing.
Aren’t product documents enough to define requirements?
Beyond product documents, a ticket is the most granular way that a product manager can express a requirement. And, unlike documents, engineers usually do read the ticket. You'd be surprised at how many times I or a fellow product manager have written a document and, halfway through the project execution, realized that barely half of the team had actually read it.
There is another article on writing documents, but it's worth pointing out here what usually happens when a product manager shares a document, either offline or during a meeting.
If a document is very high level, then people read it and think they understand it and start building in their mind a detailed representation of a product. A lot of the details are not actually expressed in the product document and would be good to have them discussed by the team. However, every person (especially engineers) thinks they got it and so they build according to their mental model of the product, which is shaped by the document but not exactly the same.
If a document is very detailed instead, usually people focus on the initial high level view and gloss over the details (because long documents are hard to read), ending in a similar situation as a non-detailed product doc. I still advocate for writing detailed product documents, since they can inform writing the tickets. Actually, it is very effective to write tickets while going through the detailed product document, ensuring each detail in the doc is then captured in a ticket.
Responsibilities around tickets, who writes them?
This is a common point of debate between engineering managers and product managers. And, unfortunately, the debate is different for each PM-EM pair I can think of. Most of my experience in these debates come from my time at Mythical, since I had the chance to work with engineering and project managers that had very different styles. I tried out each of these during my time there. I don't think that there is a one size fits all, so you should consider each of these in the context of your team.
1 - Product manager writes the epic and the main tickets
In this format, the product manager writes the epic and the main tickets for the features. This works very well for things such as the endpoint of an API, where shipping the API is the epic and the endpoints are tickets. The PM specifies what each endpoint needs to do and the business level parameters for the request and the response. Another example are websites with forms, where the epic is shipping the website experience and tickets are for each part of the form / interaction element of the website. Another example is when integrating with external services. The epic is the customer outcome obtained by integrating with the third party and the tickets are specific functionalities of the integration with the third party.
The product manager should discuss specific requirements with tech leads, ideally before writing the tickets.
Engineers then may add tickets to the epic if they identify engineering specific requirements as part of the epic (usually for shared infrastructure or for the platformization of features that could then be reused for other projects).
This works well with technical product managers that have a very good understanding of the system and software architecture. Product managers who can clearly see the customer outcome and break it down into components do very well at this. If they are good and follow the ticket format specified below, this is usually the fastest way to launch a high quality product.
The downside of this approach is that usually engineering feels neglected and not important; relegated to a role of executioner and technical details. Software engineers usually resent this since they want to be in charge of design and not just implementation, since career ladders at most tech companies reward that. I have been called out by a few different engineering managers by being too prescriptive with my tickets, so I adopt this approach only when there are high stakes projects that I understand well. The other downside is that this takes a lot of time from the product manager. It works if a product manager owns a single team of engineers. Beyond that it becomes a lot of ticket writing. During my time at Mythical, I do remember entire days spent writing tickets for an urgent project (a complex integration with a payment & payout & wallet provider) from 8am to 8pm.
2 - Product manager writes epic, engineering manager writes the ticket
In this format, the product manager discusses most of the project with the engineering manager. The product manager writes the epic and then the engineering manager engages the team to understand the architecture and the execution of it. Then the engineering manager writes the tickets for the epic. During sprint planning, the tickets are then assigned to engineers for execution.
I've seen this work very well with engineering managers who are very hands-on. Given they will be responsible for tracking the work day to day, dividing the work in a way that they see optimal helps them to track and drive the team. An engineering manager should also know the team members they have and hence can keep the granularity of the ticket at an appropriate level for the team members, potentially thinking ahead of time which team member is the most ideal for specific tickets and sizing the ticket appropriately.
Whereas option one was very time intensive for the product manager, this one is very time intensive for the engineering manager. So it works best for small teams where the engineering manager is also the main project manager of the team. It also helps if the engineering manager is very product-minded, so that the tickets can be kept outcome focused.
At Mythical, I started out with approach one. When I then was assigned multiple teams and we were hiring aggressively (meaning that each SW Eng team was still small, enabling the eng managers to manage them tactically), we shifted to this with good results.
3 - Product manager writes epic, engineers write the tickets
This tends to be the approach that engineering managers like most, but it is also the one I like least. It results in tickets which are very poorly described, very vague and make everyone look like they’re working on important things. Engineers essentially write placeholders for themselves for a broad set of tasks, which for an outsider are usually completely not understandable. It also loses one of the major benefits of tickets: tickets should be portable person to person. If a random person is assigned a ticket, they should be able to read it and understand what they're supposed to be doing. If instead you are writing a ticket for yourself, you most likely only need to write enough to remember what you're supposed to do.
It is very light on the workload of engineering managers, so managers that have a lot of reports tend to prefer this.
For a product manager, the biggest benefit of a process where all epics and tickets are described well is that, without needing the help of engineering or anyone else, the product manager can look at the sprint board and see what is happening and what is the status toward specific objectives. Usually, when an engineer writes tickets for themselves, that is not the case.
How to write a ticket
There are different philosophies on how a ticket should be written and I have had some amazing discussions with engineering managers around them. Based on what I‘ve experienced, this is the one that works best:
A ticket should be defined based on what the system / product is going to look like after the ticket is completed
Another way this is usually described is by defining the “acceptance criteria”.
Acceptance criteria should be a series of conditions that an outsider should be able to evaluate after the work of the ticket has been completed in order to effectively verify that the work was done properly.
That's why it is helpful to define them based on the end state after the ticket is completed: that state can be tried out and verified. In teams that are supported by QA teams, this provides a clear list of test cases to evaluate (very helpful before major releases to get the QA team to run all the acceptance criteria in all the tickets that were completed for that release).
Examples of acceptance criteria are:
- After button X is clicked, any settings of the user that were changed on the page are saved to the user database
- Every day at 11:59 PM, the user record in the user database is updated with the latest payment method they used, with the value null in case they didn’t do any payments that day
- All the pins of component X are routed on the board without any errors
- Present the triage results of the crash that happened on April 22nd at the engineering excellence council
All of these are very actionable and they either happened or did not happen.
A ticket overall should include:
- A one sentence title, small enough to be seen in whatever board you use
- A one to two line description of what the ticket is about
- Acceptance criteria (this is what the majority of the ticket body is made up of)
- Any links to relevant files or designs.
- The link to the epic, as mentioned in the epic section, ALL TICKETS SHOULD HAVE AN EPIC
- Links to any tickets which are blocking the progress of this one
- An assignee if the ticket is assigned to a sprint or no assignee if the ticket is not assigned to a sprint
- The creation date and last edit date of the ticket (fortunately, all program management softwares that I know of do this automatically)
Program management softwares have all kinds of attributes and tags. I find them mostly useless and extremely hard to keep up to date. All the filtering and search metadata (the information that might help you or others find the epic through search bars or query languages) should be at the epic level, so it makes sense to have those there (given there’s less of them so it’s easier to keep epics organized). Tickets should always be searched as children of an epic.
Releases should also be tracked at the epic level. Any ticket that is under an Epic but not part of a code / production release, even though the epic is part of that release, should be moved to another Epic.
What about story points?
At the origins of project management, after people created tickets and grouped them into stories, they needed a gauge on how long an epic would take compared to another. So they invented story points! A story point is an equivalent of a unit of time needed to complete the ticket. The more story points a ticket has, the longer it is supposed to take.
You probably already figured out the issue.
Everyone interprets story points differently. It is a miracle if there is a company level standard (that is also followed) on how long a story point should take. Even that would be an issue given people are changing companies all the time. What I've noticed is that usually not even in the same team there is a single standard on how many story points a ticket should have. Hence I’ve found story points to be fairly useless, due to their non-interoperability across the team.
Being able to estimate how much a ticket will take though is an important feature of project management. I’ve found that aiming to size all tickets the same is usually the best approach. You want all tickets to be approximately the same size (and I would aim for 1 - 2 days per ticket, which leads to 5 - 10 tickets for every 2 week sprint per person). This way, in order to estimate the duration of an epic, you just count the tickets.
The other important thing that this unlocks is the ability to see how “close” you are to completing an epic by just looking at the ratio of tickets completed over number of tickets of an epic, which is a lot more interpretable compared to how many story points are completed, especially given story points are usually defined only for the sprint ahead.
Why not user stories?
Common knowledge is that tickets should be written as user stories. “As a user of project management software I want to have a automatic way to check if tickets are written properly at inception so that I don’t have to chase engineers or designers to ask them what the ticket is about after the fact”. That’s an example of a user story.
I see user stories belonging at the epic level, since they represent the voice of the customers. Usually there are a variety of steps that the system needs to be improved on in order to hit a particular user story. Each of the steps should be a ticket.
I’ve also noticed that some “user story” ticket framings are sometimes forced, starting from what the ticket wants to achieve and then creating a user story around it. Might as well just write the ticket with acceptance criteria at that point. More clear to the team and clearer for QA. Keep the user stories for the epics.
I’ve tested out both approaches and found that acceptance criteria tickets are a lot better to identify any gaps in understanding between product and engineering / design.
Sprints: do you really need them?
Sprints are the main difference between an “agile” approach and a “kanban” approach. In short, agile with sprints schedules the work to be done in advance and establishes that with the team. Kanban instead has just an infinite dynamic prioritized backlog and the team is always supposed to take tickets from the top when they have capacity.
The theory is that sprints are better for product organizations, since they have specific development goals, whereas kanban is better for service organizations, who have to respond to a continuous stream of customer inbounds, that need to be individually prioritized every time a new request comes in.
In practice though, I haven’t noticed many differences. Seldom all the tickets in a sprint are completed, so then the remaining roll over, which ultimately is like a kanban. A sprint setup just establishes the cadences for the reviews. If the PM is exclusively dedicated to the team and adopts a ticket writing approach of (1) above (PM writes the tickets) then I’d say that Kanban is more efficient, given PM continuously refreshes the backlog and engineering manager ensures that team output is up, without needing excessive meetings.
If the ticket writing instead is (2) or (3), then sprints are better since they establish a cadence for the engineering manager and engineers to review their sprint and create / add tickets to it.
Sprint planning: how to make it effective
In case you do have sprints, sprint planning becomes a critical meeting.
The major errors I see in sprint planning:
- No one evaluates whether there was enough progress in the previous sprint
- The sprint tickets are not actually finalized before the end of sprint planning
- Sprint planning becomes a standup, with people just saying what they did
- It is not clear what the next major milestones are, whether the past sprint got the team closer to them and how the next sprint will bring the team closer to them
The key to a successful sprint planning is really for the PM to do work ahead of it. Ahead of sprint planning, a PM has to:
- Review all the work done, but especially the work not done - that’s what you want to talk about during the meeting. You want to highlight if the team is not doing enough and identify why. You also want to see if any “creep” projects made it in the sprint somehow (for example, if an eng added them after the past planning or if a customer team added them directly) so that you can deal with them (usually remove them if they are not really important or part of the plan for the team)
- Set up the next sprint ahead of time and have a high level idea of what you want each person to work on. That will help you identify if someone is planning to work on the wrong things
- In the case of (1 - PM writes tickets) write the tickets. In the case of (2 - EM writes tickets) or (3 - eng write tickets) remind people ahead of time to write the tickets and put them in the next sprint
I’ve seen sprint planning just become a ticket writing session. That’s not helpful, you don’t need people to sit in a meeting writing tickets. If you need that to force the team to focus on it, then set up a calendar block right before the meeting to remind people to do that before the meeting.
You want to spend time in the meeting to review the past and future work, especially what is not obvious.
In order to squeeze all of that in, I’ve seen that successful sprint plannings require 1h (unless the team is 3 ppl or below, though at that number you don’t even need cadences and can just handle everything through messaging and ad hoc communication). I wouldn’t go beyond 1h, since people's attention drops dramatically after that. The target is for a 1h meeting that ends 10 min early. Having some buffer at the end allows discussion times for important topics or disagreements in the team that usually do arise from plannings.
I would suggest against chaining sprint plannings with retros or standups. That is usually just too much “team time” together and makes people feel frustrated (long calendar blocks usually frustrate engineers and designers).
Demos
The best way to finish a sprint is with a demo session. These are sessions where engineers or designers showcase the work that they completed in the sprint. They are amazing since it means that someone has necessarily completed some work during the sprint. Demos demystify the level of progress on a particular milestone, since the progress is showcased live.
Even as a non technical product manager, with a demo you can get a sense of how far along the product is coming.
Always record demos, since they are great artifacts to show leadership or even potential customers about the progress of a product.
Having recurring demos set up is also a great way to set expectations with the team around when you expect to see certain progress. “Show it at the demo on Friday” is a great phrase to use during a standup.
Demos are usually on Fridays, right before the next sprint starts on Monday. Given there isn’t usually time to review the work of every single person on the team, people take turns every week, going through 1 to 2 people per session (as for other sessions, keep duration to max 1h, though 30 min for 2 people is usually best).
Unfortunately, I’ve experienced that demo cadences don’t usually last very long. At the start of a project, people are excited and progress quickly, always having something to show. There isn’t enough time to show everyone’s work. As the project gets to the midway point, there are less and less things to show, as the team starts hitting issues and spending longer time on smaller details. At this point demo sessions start being cancelled since there isn’t enough content and the demo is the same week over week. Towards the end of the project, as teams are busy tackling all the latest bugs, there are effectively no demos week over week and people don’t even make time to attend once the session is held. If they do attend, engagement is minimal.
Once the steam behind demo days fades, it is extremely hard to get it back. Try to keep them going and continuously highlight their importance to the team. Inviting cross functional stakeholders is a great way to keep them relevant. You also want to ensure that the team is present and doesn’t start booking meetings over that time. Protect it at all costs and ensure that you are engaged during the sessions.
Backlog: make it your friend
The backlog is often considered as an insurmountable amount of tickets that no one ever really looks at. I have used the backlog as a very powerful tool, though it does require time, else it does become useless.
Let’s assume that you start from scratch with a team, the backlog is the place where you put any tickets that you or the team comes up with and that don’t belong in the current sprint (since you are not in sprint planning and don’t want to inject in a sprint). Likely the reason for adding a ticket to the backlog are the following:
- You have scoped and defined all the work of an epic and, due to capacity, you have to complete other tasks before the ticket, requiring the ticket to wait for another sprint as prior work gets done
- It is a request from another team / customer, and you want to show that the work is in the plans for your team, so you create a ticket and put it in backlog, to be scheduled for when the team has capacity
- It is an idea from a teammate. You want to show the teammate that the proposal is taken seriously, though it is not more important than current priorities
- An epic has shipped but there are leftover cleanup or nice to have tickets that are left in the backlog as follow ups, since the priority after shipping the epic has shifted
(2) is by far the most important function of the backlog, since it can “calm down” any team which is very dependent on the work, showing that you have “heard” them and are not ignoring them. It also clearly shows that the current priorities of the team are others, allowing any requesting team to appropriately start an escalation with higher leadership in case they don’t agree with the PM’s priorities. In general PMs should welcome that. Especially in large companies, PMs may not have all the context and it is helpful to allow other teams to “appeal” a prioritization decision. Having tickets in backlogs makes it clear who a requesting team is appealing “against”, such that the tickets and epics in the backlog can be compared directly vs the ones in the sprint.
(3) is something that you can use sparingly to appease teammates, especially key people directly on the team. In general when someone has an idea that just doesn’t fit in the roadmap, you should just explain to them why and move on. However, when having ideas, there is a recency bias, so a teammate will likely think strongly about their idea right after they come up with it. Having an idea turned down by your PM is just not amazing and might build resentment in some individuals. Putting the idea in the backlog shows good will and establishes that the team will work on it when the team is right (see section right below on backlog cleanup). Likely then time can pass, the team member can grow less attached to the idea and the idea can be removed as part of a backlog cleanup.
Backlog hygiene
As a product manager, the responsibility to keep the backlog tidy is entirely yours. Ideally once a sprint you should, individually, go through at least the latest additions to the backlog and order them, such that the most important tickets are always on top and such that you don’t forget about the opportunities or promises to other teams that are in it.
When “scanning” the backlog for work to do, in case there is “room” for more in the sprint, always start from the top, since that’s where all the important tickets should be. When scanning the backlog, you also want to update any priorities that were assigned to tickets (if you are noting down the priority of tickets). Given that priorities change over time, it is ok to change priorities of tickets in the backlog to make sure that you focus on the highest priority items the next time that you scan the backlog.
Should tickets with the highest priority always be those on the top of the backlog? Likely but not necessarily, given there could be some sequencing that means that lower priority tickets do need to get done before other higher priority ones.
Spring and winter cleaning: why it is important to clean up the backlog
I can guarantee you that the backlog will start to grow and grow into a very long list. Likely, when you start to PM a team, the backlog is already too long and meaningless. A backlog that takes more than a few hours to scan is useless, since you won’t realistically ever look at it or scan it properly.
Hence why it is important to periodically do a cleanup!
How do you do a cleanup? You go through it and close down / delete all tickets that ended up on it and that either don’t make sense anymore or that you won’t likely get worked on in the next 3 - 6 months. The best way to do a cleanup is the following:
- The PM individually goes through the backlog and:
- Deletes a ticket if it is clearly not going to be worked on or malformed (not properly described and written, as specified earlier in this article)
- If unsure about what the ticket is and whether it is still important, tags a ticket with a label or a tag, marking it for upcoming deletion
- The PM then sets up a session with the team in which, starting from the top, reviews every ticket with the deletion tag. Team members can point out if the deletion tag is wrong and, in agreement with PM, remove the tag. Else the tag stays there
- Setup a batch deletion of the tickets which are left with the tag
When I have done this process, usually 50% to 80% of tickets get deleted. Yes, that is a very big amount of tickets and it is ok. You’re probably thinking that it would be better to pay more attention when adding tickets to the backlog, in order to make sure to only add things that will be worked on. Depending on your team, priorities do change very often so it is fairly common for my teams to ultimately not do a bunch of work that was planned for. Technology moves fast, so that is ok and it is also why the backlog cleanup is an important part of the process.
I’ve found that twice a year is a good cadence for a backlog cleanup, with one time being in the winter holiday period, right around New Year. A clean backlog is a great way to start the year!
The second time would then be somewhere around spring / start of summer (for Northern hemisphere, so May to July). There are “seasonalities” in ticket creation. Usually most tickets are added in the start of the year (Q1), given often companies do some sort of planning then, and most reprioritizations happen towards the second half of the year, since the original plans grow outdated (Q3).
Retros: the bar of the remote workforce
It is still a mystery to me why engineers love retros. Or rather, most engineers think they love retros.
Retros are a team meeting where the team gets together and thinks about the past and identifies ways to improve. Usually it is framed as a team discussion, with an anonymous board where people can anonymously add comments, questions or observations, usually divided into some kind of “start doing”, “stop doing”, “continue doing” framework. There are many ways to run retros though I won’t get into those, since I just don’t think that retros are a good use of time. I’ll get into why.
As part of the agile process, you are supposed to hold a retro every 1 to 2 sprints. I try not to schedule recurring retros for my teams though, since I have never found a tangible benefit from them. Usually retros follow this pattern:
- Team brings up or highlights issues that are well known and that everybody is aware of, especially the product manager and the engineering manager
- The team brainstorms and captures action items, usually related to changes in process or particular cleanup work to do. It might result in some tickets getting added to backlog or some meetings added for process
- Nothing changes, given there was a reason behind why the team processes and work to do was setup that way before the retro
I would like to stress number 3. Given the issues are already known, if there was a way to solve them, they would have been solved already before the retro. The issues that people usually want to cover in the retros are things such as:
- Too much workload
- Too many changes of priority
- Too much process
- Not enough process
Which unfortunately can’t be solved easily and especially can’t be solved democratically. Usually most of the complaints highlighted in retros would be solved by working harder (less laziness). If the problem is too many reprioritizations, then it means that the team is either not working hard enough (delivering too slow such that priorities change) or that there is too much work, which is good, and the PM is reprioritizing accordingly to always do the most important thing first.
Given I don’t find retros particularly helpful, I tended to avoid scheduling them unless there was a mounting request from the team, or a particular issue that has to be discussed.
In time though, I realized that that is one important reason why retros exists: they allow the team to vent.
In the past and especially before COVID, teams used to be in presence and could, after work, hang out and complain about work. That is not a bad thing. We all have our grievances at work and we all complain about manager X, leader Y or decision Z with our friends outside of work. It is part of being human. When talking to a former colleague in gaming who has more experience than me, he specifically called out how, when most of the work was in office, everyone would get together after work, especially after days when bad things happened such as layoffs, to have a communal complaint session. He mentioned that teams would process all the stress and worries of the day, coming back stronger the next day.
Especially for remote teams and for teams that partially work from home, people don’t get the chance to get together in an informal session to complain anymore. That does risk building resentment towards the company as a whole in the long run and accentuates the feelings of loneliness. Retros and offsites are a great antidote to that.
Since I realized this I do tend to ensure there are retros scheduled every once in a while. There are no expectations out of them, just allowing people on the team to talk about what they want. Since I’ve had no expectations going in, I’m also more relaxed and better understand the nuance and the stand of people on certain subjects. Treat it more like a bar conversation!
Team morale is something that the PM should care about, so I aim for retros to be good for that. I also try to get together in person with people in my team once a year (not necessarily all together), aiming to visit company offices where I have team members at least once a year.
As a PM, aim to figure out how to solve the “bar” setting for your team and to ensure that people do have an avenue where to vent. Retros might not be the answer for your team, though do make sure that the need is met.
How this fits in with AI
AI tools and capabilities are continuously changing. I’m writing this in May 2026, so very likely things would have changed by the time you read this.
The discussions are process mostly focus on the fact that:
- Work (in the form of what is specified in the tickets) will increasingly be done by AI agents
- Tickets will be increasingly be written by AI agents (starting from documents or specifications)
This doesn’t entirely change most things mentioned above. I’ve seen workflows of both PMs and engineers where, starting from a spec doc, AI writes the tickets, adds them to a backlog and then executes them.
The limited context window means that it is helpful to still keep a “ticket” layer in the workflow, where AI can define the plan, write up all tickets, go through a first round of human review, then execute the tickets one by one, reviewing the plan based on the outcome of each ticket. This is beneficial since it allows potentially different agents or AI models to be used for different types of tasks, increasing savings (coming from not using the best frontier model for everything).
To some extent, the process becomes even more important, since what is defined in a ticket will much more likely define exactly what is being built, leaving less room for vague tickets.
Conclusion
I know that this was a lot and that likely you will not be able to follow all of this for your team. I also don’t follow all of this for my current teams. Process should be meant to work for your team and your objectives, so I would be surprised if everything mentioned here applies to your situation.
I hope that you have learned some concepts that will enhance your day to day team management and I do invite you to try out new things periodically. I certainly do. Process should not be static and should continuously evolve in time and, especially, with the times.