The conflict you face on your team is likely due to competing priorities. Ultimately, it's on us to determine what our priorities are when pulled in different directions. In today's episode, we're talking about why priority is not a sole decision but a team decision.
If a team agrees to a set of goals and values, then our priorities should align, yet it too often falls on individuals to negotiate their priorities with the team. In today's episode we'll ask the question; how do teams decide priorities?
Should we allow individuals to negotiate their priorities or should this fall on the team to determine together what each individual's priority should be in working toward a common goal?
Visit www.abstract.com and sign your team up for a 14-day free trial.
If you're enjoying the show and want to support the content head over to iTunes and leave a review! It helps other developers discover the show and keep us focused on what matters to you.
This is a daily challenge designed help you become more self-aware and be a better developer so you can have a positive impact on the people around you. Check it out and give it a try at https://www.teabreakchallenge.com/.
I'm going to make a guess that the conflict that you face on your team is largely about competing priorities. You have a manager that's asking you to do one thing. You may have mystery voices or other developers, other managers of other teams that come in and ask you to do something else. You may have your peers that are asking for your review. And it's ultimately your job to consolidate all of this, to figure out what your priorities are. But this is really an illusion, at least in the frame of work, it's an illusion. We're going to talk about why on today's episode. My name is Jonathan Cottrell. You're listening to Developer Tea. My goal on the show is to help driven developers like you to make a difference in the world of development. Find clarity, perspective, and purpose in their careers. When you have a team of people who are working together, as long as the team has agreed on particular values and priorities, this is kind of a prerequisite. We have lots of episodes around these values and priorities. As long as a team has committed to those things, then priority is not individual. And this is the great misconception about priority. That you can have multiple competing priorities within an aligned system. Now this is a misconception because at a fundamental level, if we are all agreeing to set aside our differences, to set aside our own personal motivations, and instead, on a consensus basis, we choose to move forward and commit to particular goals and values, then our priorities should theoretically align. And yet it so often falls to the individual, the developer or the manager, to decide between competing priorities. So how can we change this pattern? How can we align on our priorities? Rather than trying to negotiate our priorities with each other? And perhaps a related question, should we? Should we allow this negotiation of priority? That's what we're going to talk about right after we talk about today's sponsor, Abstract. Today's designers spend a lot of time searching for files and consolidating feedback from all kinds of sources, ultimately never really knowing what the authoritative value of the project is. What the authoritative single source of truth, what the latest version is, and all the changes that have come before it. And that's why the former Twitter principal designer Josh Brewer co-founded Abstract. Abstract kind of acts like GitHub for designers. With GitHub, you have a single source of truth and you get feedback and then ultimately move forward with an authoritative version. Abstract is your team's version-controlled source of truth. For design work. This brings all of your design workflow into a single unified place for designers, developers, stakeholders, pretty much anyone who you need to collaborate with to move forward. Abstract is already working for companies that you've definitely heard of, like Microsoft, Spotify, Cisco, thousands of others across 75 countries that rely on Abstract to improve their design workflows and increase their collaboration. And with Abstract, you can version design files, you can present your work, you can request reviews and collect feedback, and even give developers direct access to all of your specs, all in a single place. With Abstract, you'll spend less time searching for design files and tracking down feedback, and more time focusing on the things that matter, innovation and collaboration. Sign your team up for a free 14-day trial today. By heading over to www.abstract.com. Thanks again to Abstract for sponsoring today's episode of Developer Tea. So the question that we have in front of us is how do we align on priorities? And perhaps the implicit answer here is that we don't always agree what the most important thing is. Even if we have a value alignment, and even if we have a goal alignment, we may have a disagreement between which thing is going to achieve that goal. And this is why we end up having to negotiate our different priorities. But most companies, most companies don't have that basis, the value alignment and the goal alignment. Instead, they pit teams against each other. One team has one goal, and another team has another goal. And so each team has to kind of fight for the resources that are needed to meet those goals. Additionally, individuals have an incentive to meet goals that matter to them, both at a personal level and in a more general way, if it matters to their compensation or to their career growth, they're going to naturally be more incentivized to reach those goals. So while it makes sense that theoretically, all of our priorities should be the same, in practice, we find out our priorities over the course of a lot of negotiation. And some of this can be healthy negotiation. It's how we test our theories about what is most valuable or what carries us towards our particular goals or values the best. But it can also be toxic and cause conflict between teams. For example, when one team's priority is placed above in the kind of priority queue on other teams. So while we can't necessarily solve prioritization problems across the board, what we can do is think more intentionally about priorities. The illusion that we have is that a person can have multiple priorities and that everyone can balance those priorities effectively. The truth is that if you're a team that has multiple priorities, you can't necessarily have a priority that is more important than the other team's. The truth is that we need to do more work together to determine priorities rather than putting all of that on the individual. And the reason for this is because, quite simply, we can't rely on each other if all of us are having to decide what priorities are on our own, in a vacuum. So one thing that you might do as you more intentionally engage in this process is look at the dependencies between your priorities. Can I, for example, or can my team, meet our priorities without relying on others to also prioritize what we're prioritizing? If that's not the case, then we're held back. We're either slowed down or maybe even blocked by the incentives of another team. This can cause trust issues, it can cause two teams to feel like they're adverse to each other, and ultimately, this breaks apart the culture and causes people to resent each other. This is the opposite of collaboration. If one team relies on another team to meet their priorities, then these teams need to talk about those priorities together. As a developer, a practice that you can carry forward is to talk about the things that you're trading. Whenever you discuss a priority with another stakeholder or another person, your manager, talk about the things that you're trading and where this new priority, this new request might fit in your existing priority list. We don't have multiple lists for priority. We can only truly do one thing at a time. And so what comes first should reflect our priorities. So it is the responsibility of each of us individually to dispel with the idea that we have multiple priorities and that we can manage all of them. We only have one thing at a time. We can only truly provide our focus and effort towards one thing at a time. And if we set up a list of five or six different competing priorities, at the end of the day, we have to decide which one comes first. This kind of conversation is one that makes people uncomfortable because deciding which department is more important than the other seems difficult. It seems like it might even be personally offensive. But it makes more sense to make this prioritization process out in the open and more explicit rather than allowing both of those teams to continue with the same process and with the illusion, continue under the illusion, that both of them are equal priority. They simply can't be. Within the company politics, this is a risky conversation to have, but at the same time, setting expectations so that you can meet and hopefully exceed them is a much better position to put yourself in in the long run. Thank you so much for listening to today's episode of Developer Tea. This is a difficult topic, for people to talk about, so hopefully this was helpful to you. Thank you again to today's sponsor, Abstract. Start your team's 14-day free trial by heading over to www.abstract.com. Today's episode is a part of the SPEC Network. Head over to spec.fm to find other shows like Developer Tea designed for you. Today's episode was produced by Sarah Jackson. My name is Jonathan Cottrell, and until next time, enjoy your tea.!