3 Flares 3 Flares ×

One of the most common questions new product managers wind up asking themselves is how they can work most effectively with their development teams. In many companies, the development teams are isolated from the “business” and seen as some sort of ethereal group who works their magic in dark rooms, emerging once every two weeks to share their creations with the outside world.

The reality, though, is that integrating the technology side of the business with the “business” side of the business is essential to success, no matter what market you’re working in. And, as product managers, we are often  called on to be that bridge and to make those connections.

The Key to Effective Teamwork: Empathy
empathy is key to working with engineers

The first thing to remember is that the key to building good relationships with any group in your company is to engage directly with that group’s members and to build empathy with them; engineering teams are no different in this way. We need to talk with the teams and team members, on both a group and individual basis, and to work with them to understand what it is that keeps them going and makes them engage. I suggest asking a few key questions:

Knowing the answers to these questions allows you to understand what motivates — or what doesn’t motivate — your engineering teams. And the direct corollary to this is that you now know what levers you need to pull in order to guide them in one direction or another — and what feedback you need to take back to their managers to ensure that they get the recognition they deserve. As the Center for Creative Leadership put it in their white paper “Empathy in the workplace:”

“The ability to understand what others are feeling is a skill that clearly contributes to effective leadership.”

Understand the Challenges Your Development Team Faces

Once we have built some level of empathy for our software engineers, we can start to approach our relationship with them just like we would any form of product development. Without grilling them like we might a potential customer or client, we want to dig in and discover what their needs really are, below the surface concerns of their day-to-day work. In order to bring these needs to light, consider doing the following:

Most importantly, though, we want to try to figure out what the things are that we’re currently doing that are complicating their lives — and work with them to devise potential improvements to processes or tools to address these. The easier you can make their lives, the easier your life will be! Minda Zetlin writes:

“You must show your commitment to helping them develop and gain their trust before they invest their hours into helping the company grow.”

Communicate the Envisioned Outcome

Another key thing that we can do to improve our relationships with our software engineers is to ensure that they’re involved in the business decisions that are affecting them.

There’s a tendency in many companies to “insulate” the development teams from “the business” — usually in the name of trying to reduce randomization and to ensure execution overall. This is a very sideways way of thinking, which usually results in expecting people to execute without context — without understanding the vision, the strategy, the tactics, or especially the customer. And therein lies the problem — people are motivated most when they share a vision of what the future might be, and can see themselves and their contributions in that picture.

We want software engineers to see themselves as part of that future. We want software engineers to understand how what they’re doing contributes to success. We want software engineers to be actively engaged in helping to define that future. That’s what leads to success — creating and communicating a vision of what that possible future could be, and helping others to reach that goal. Says Carmine Gallo in his article on inspirational leadership: “If they can’t see themselves in the picture, then they can’t imagine that it’s a possibility for them.”

Common Struggles Between Product and Engineering Teams
how to work effectively with software engineers

Once we’ve established this initial relationship, and achieved some shared vision of the possible future, we need to get to work executing. And here is where many product managers wind up struggling in their burgeoning relationship.

There are three primary areas in which product managers may make decisions that adversely affect their relationship with the development and testing teams:

  1. Communicating requirements
  2. Micromanaging
  3. Protecting them from business-driven randomization

Effectively Communicate Requirements to Engineers

The most important thing to remember about communicating requirements is that software engineers are problem-solvers, not order-takers. A great many companies fail at this, writing detailed, checklist-oriented market, product, and technical requirements documents rather than allowing their engineers to do what they’ve been trained to do — come up with creative solutions to customer problems by leveraging their technical expertise.

Just as product managers struggle with dictates that come from on high, software engineers struggle when their creative efforts are stymied by overly-specific product requirements. This is why most Agile organizations have adopted user stories (of the “As an [x] I need to [y] so that I can [z].” variety) — because it allows us to clearly state the problem that we’re trying to solve, and engage in discussions with the engineers about what solutions they can build to solve that problem

Product managers need to own the “what” and the “why” — but it’s up to the software engineers to own the “how” and even the “when.”

Ultimately, though, we want to deliver our requirements and specifications in the format that the engineers want to use and find valuable — and this might vary even within an organization. Some teams might want very specific, detailed technical specifications; others might prefer open-ended problem statements with high-level mockups. Knowing what your team wants and what they find most useful goes a long way toward ensuring that they’re getting what they need from us as product managers. Atlassian echoed this sentiment in their article “Creating a Lean, Mean Requirements Machine,” “Agile requirements…depend on a shared understanding of the customer…between the product owner, designer, and the development team.”

Don’t Micromanage the Development Team

Once we’ve communicated the requirements, and we’ve had deep conversations about who the user is, what their goals are, any technical impediments or dependencies that might exist, and have generally driven down to a sprint-level commitment to execute… we need to step away.

This is the hardest part for many product managers, especially those who come from project management or even engineering backgrounds, but it’s also perhaps the most essential thing that we need to do. We have to trust the team to do what they said they would do. We need to trust the team to come to us when they have questions or need clarifications. We need to trust the team to do the right thing when they need to.

Certainly, we also verify that they’re making progress; we check the results to make sure that we’re all headed in the right direction, and we work with the team to do the right things the right way — but the easiest way to cause discontent with a development team is to micromanage them.

Remember, as the product manager, our developers don’t work for us, they need to work with us. Constantly haranguing them over their progress and insisting on detailed status updates that take more time to create than to discuss just isn’t doing your job. It’s trying to do theirs. And we certainly have more important things to spend our time on. As the great Princess Leia stated in Star Wars, “The more you tighten your grip, the more star systems will slip through your fingers.”

Sword and Shield: Protect Engineers from Randomization

Above delivering good requirements and allowing the team to execute in the way they deem best, the single most important thing that product managers provide for their engineering teams is, perhaps, this: the ability to be both the team’s sword and the team’s shield when engaging with the larger organization on their behalf.

We act as the team’s sword when we find out that there are external dependencies that the team needs resolved before they can move forward; when we engage in prioritization discussions by calling in our engineers to assess the technical feasibility of some proposed solution; and when we fight for more time, more resources, or changes in scope to maintain reasonable product delivery goals and deadlines.

Similarly, we act as the shield for the engineering team when we deflect incoming randomizations from customer escalations, sales promises, or the whims of the management team; when we take responsibility for the misses in requirements that might have caused a slip in schedule or an important use case; and when we translate marketing-, sales-, or support-speak into terms that the engineers can understand.

We want to protect our engineers from suffering the inevitable switching costs that are incurred when priorities change and new projects have to be started. And we also want to protect our engineers from the perception that “the business” doesn’t really know what it wants or what it’s doing — something that is an inevitable conclusion when priorities are constantly shifting and software winds up sitting on the shelf instead of being shipped out to the customer.

From Good to Great

If we do all of the above, we’ll have a good relationship with our developers — they’ll know that we understand them, are on their side and want to help, have a shared vision of the possible future, know how to communicate requirements, let them solve problems the best way they can, and shield them from randomization and distraction.

…But we still might not have a great relationship with them. Taking that relationship from good to great requires a very simple realization — software engineers are people too.

They’re not interchangeable, fungible cogs in a machine; they have strengths and weaknesses, areas of focus and disinterest, and dreams and aspirations that involve things outside the four walls of the organization. The only way to really establish a great working relationship with your engineers is to have a great personal relationship with them as well.

Meet the team after work for drinks, attend their brown bag lunch discussions, talk with them about things other than requirements and software and databases and JavaScript. Engage with them as people, and you’ll reach that next level of relationship, with all of the additional trust and support that entails. Fast Company puts it simply:

“Leaders who are able to create sustainable, high-performance cultures over the long term see their primary purpose as serving the employees on their teams”

Quick Wins: How to Improve your Relationship with your Software Engineers Today

collaborating with engineers

Finally, here is a list of three things you can do right now to improve your relationship with your software engineers (or really, any team in your organization):

Be Humble

As product managers, we’re often right up front in business discussions. But we need to remember that our success is driven as much (if not more) by the people we work with; without our sales team, we don’t make money; without the marketing team, we don’t engage with new customers; without the engineering team, we don’t have any product to sell. We shouldn’t take responsibility or credit for work others are doing.

Celebrate the Wins, Learn from the Misses

Make sure to set aside time to celebrate your successes — bring in lunch, order some pizza, have a few beers (and non-alcoholic treats for those who don’t partake), maybe even bring in a cake. People feel rewarded when their accomplishments are publicly acknowledged — and there are few people who will turn down a free lunch.

On the other hand, don’t dwell on your mistakes or mis-steps; figure out what you can learn from it, how you can avoid repeating it, and leave it behind. Dwell on your success and let go of the mistakes, and set an example for others in your organization to do the same.

Give Credit, Take the Lumps

Product Management is (or should be) a relatively thankless job. When something goes right, the team should get the recognition that they deserve — after all, even if we write the best requirements in the world, if there’s nobody to actually write the code, nothing gets built.

On the other hand, when things go wrong we need to be ready, willing, and able to step up front and take the flak — we shield the engineers from the blame and finger-pointing, because we can. Then we move on and do better, correcting in private if it’s needed. As Kirsty Lee writes in MindTheProduct:

“At the end of the day, engineers have to be able to trust their Product Managers. And part of earning that trust is proving that you are all fighting your way towards one and the same goal – together.”

Cliff Gilley

About Cliff Gilley

Cliff Gilley has been a Product Manager for nearly 12 years, working in a variety of industries and company sizes. He has assisted several of these companies in their transitions to Agile development and Scrum methods, and is a firm believer that agility is a value you must have, not something you just do. He currently blogs and consults as The Clever PM, providing providing tips, tricks, and hacks to make people better, more clever Product Managers.