In my previous article, “Designing an Accountable Software Development Organization Part 2: Vision, Levers, and Tensions,” I discuss the tension that exists between requirements, governance, and technical delivery activities within a software development organization. The tension between these activities is a necessary part of developing truly great software since they provide checks and balances between sometimes competing agendas. In that article, I illustrate the effects that tension on misaligned organizations and discuss how better organizational alignment helps the software development leader manage those tensions and keep them healthy.
Even after achieving the best organizational alignment which allows tensions to bubble up to the right level where they can be managed, the requirements, governance, and technical delivery folks will occasionally go toe-to-toe over issues that arise. The question is when things get heated between disagreeing parties, how do we ensure that tensions stay healthy or more importantly, how do we restore health to an already unhealthy tension? The answer is both simple and complex and comes down to a single word: Intention.
The Right-Wrong Game
The need to be right and to avoid being wrong is hardwired into people. Unhealthy conflict is defined in terms of what I call right-wrong games. Right-wrong games are usually characterized by zero-sum thinking where one party believes that to be right; the other person has to be wrong and vice versa. Also by definition, there is no middle ground and no giving ground. When I see people engaging in these conflicts whether, through email, text messages, or other means, I imagine them sitting opposite one another at a table doing verbal battle face-to-face. When you dig deeper into these conflicts, there is usually a single root cause: each party has attributed a contrary intention to the other party and is allowing that preconception to drive their actions and emotions.
Let me give you an example. A product manager and software architect are locked in a battle over software requirements and how to implement them. The product manager insists that the requirements must be accepted in their entirety in order to meet the customer’s needs while the architect is looking for requirements flexibility in order to make a more maintainable implementation. The product manager believes they have the customer’s best interest at heart because requirements are paramount and that the architect wants to take shortcuts to make their job easier. The architect believes that making a more maintainable solution will benefit the client by ensuring higher quality and that the product manager is taking a short term view and being inflexible.
So what’s happened to make the relationship fail? The product manager and architect have attributed bad intentions to their opponent and then allowed their perception to drive behavior and emotion. In short, each party believes that that other is out to thwart their best intentions, and each party is hell-bent on stopping the other because each party is convinced of the virtue of their position.
Breaking the Right-Wrong Game
When faced with these conflicts, the best outcome is to get both people on the same side argument working toward a mutually beneficial solution. In short, they end up side by side on the same side of the table looking out together toward a common solution.
So, how is this accomplished? The parties in conflict need to come to the understanding that they both share the same intention. Namely, to provide the best solution for the customer. They will come to realize that they both want the same outcome and only differ on the means to achieving that outcome. They must realign on their intention and acknowledge that the other party shares that intention. This does not usually happen in the heat of a right-wrong battle and requires a cooling down period first. Even then one party or the other may not what to give ground. It’s the job of the software development leader to bring the warring parties together and get them to reveal their own intentions and acknowledge the good intentions of the other person. With a little guidance from the software development leader as the a third-party, the two parties will come to realize that they both have the same intention at heart. The goal is for two parties to become allies in finding a solution that aligns on their common intention.
Reducing the Occurrence of Right-Wrong Games
The key to reducing the occurrence of conflict in software development organizations caused by intention misalignment issues is to prevent such conflicts from starting in the first place. To do this, the software development leader must define the intention in collaboration with their team, seek alignment on the intention, and constantly reinforce it. In my own software development organization, we have three primary intentions: Delivery software that is the best fit for the business, deliver high-quality software, and deliver it when we promise we will. These three intentions may seem intuitively obvious for a software development organization but, often, they are assumed rather than made explicit and are spoken about in a trite manner.
Recently, our team delivered a major software release designed to allow more customers to migrate to our new platform. The team pushed extra hard to meet a deadline and succeeded in delivering on time despite numerous obstacles. At the weekly status meeting near software delivery time, I made sure to reinforce with the team how they supported the business by delivering the right functionality, with high quality, and on time. All throughout the effort, the team was focused on the goals and aligned on our common intentions. When obstacles occurred, they came together and found ways to overcome them…usually on their own and without management intervention. They made a hard task look easy all because they worked together. I couldn’t have been prouder of the team for their commitment and the results.
Be Easy on Yourself
As a software development leader, it’s all too easy to get frustrated and annoyed when inter-team conflicts arise. I know this first-hand because I sometimes feel this myself. When I have a moment to step back and reflect, I remember that software development is the art of balancing tensions to get the best results. Software development is a human endeavor involving high-performing people who sometimes see their peers as obstacles to meeting their intentions. When you want to jump out a window out of frustration born of interpersonal conflict caused by misattribution of intention, remind yourself that your software development staff is well-intentioned and wants to do the right thing whenever possible. In short, be easy on yourself for not being able to avoid these conflicts and be easy on your team since we all share the same virtues and vices when it comes to relationships. Your team needs a periodic and gentle reminder that they all aligned with the same intentions. Rather than forcing a result, more likely than not, you will find that your team will come together and find their own solutions and get a sense of satisfaction in doing so.