Tag Archives: product teams

“Healthy tension” between Product and Engineering? No thanks, I’d prefer alignment.


I remember the situation like it was yesterday. I was leading the Product and eCommerce team for a large retailer, and Black Friday was only four weeks away. At our October check-in with the executive team, I’d told the CEO we’d be delivering several features to improve checkout conversion, which would increase revenue by as much as a million dollars.

I wasn’t just trying to make myself look good. Like any competent leader, I’d made the commitment only after discussing the situation with the appropriate teams, and my partners in Engineering were in lock step. Within a week of my meeting with the CEO, though, things had changed. During a load test, a scalability issue had been discovered, and it would require the full focus of our Engineering team.

The Engineering leader asked what I wanted to do. Should we continue to focus on the features we’d promised, or pull the team off of feature development to focus on system stability? I don’t remember it being a hard decision. “Those features aren’t going to do a lot of good if the system is down,” I said, “let’s shore it up.”

Healthy Tension?

A lot has been written about the importance of “healthy tension” between Product and Engineering teams, and on the surface, it makes good sense: if one team is focused on building new features and the other is focused on code quality and stability, the tension between them might encourage discussion and debate, and neither team will lead the company off a cliff. In fact, the theory goes, this “healthy tension” might lead to compromise, somehow delivering the best of both worlds. I disagree.

The problem, I think, is in the assumption that Product and Engineering teams inherently have different goals. They don’t – or at least they shouldn’t. Both teams are responsible for the growth and stability of the company, for revenue and scalability. Neither can succeed without the other.

When we assume otherwise, we sell each side short. Any good Product Manager will tell you there are times when addressing technical debt is the smartest use of development resources, that the push for new features needs to be balanced with a view towards system health. And any good software engineer will tell you that the world’s most performant system is useless unless it drives business results, that sometimes it’s worth taking on tech debt to take advantage of a market opportunity.

Think of it this way: if you were building a house, you wouldn’t expect your architect and your builder to simply hand off their work, you’d want them to collaborate around shared goals to make sure they were in agreement. A good architect would never design a house that couldn’t be built, and a good builder wouldn’t build a house that was poorly designed. We should expect the same from Product and Engineering teams.

A smart and logical group

“At a basic level,” according to this AHA.io blog post (and many others), “product managers should tackle the ‘why’ (product strategy) and ‘what’ (features) for the product. Engineers should determine the ‘how’ — the technical implementation of features.” While this may be true at a basic level, it’s not the way great Product Development teams work.  In my experience, great teams – the ones that are most engaged and produce the best work – are the ones where Engineers are involved in defining the “what” and Product Managers weigh in on the “how.”

This is because Product Managers and Software Engineers are often among the smartest, most logical employees a company has, and they tend to be very capable of both understanding business goals and coming up with creative ways to achieve them. When we neglect to give our teams the full context of what we’re trying to achieve, we make it harder to solve the problem, and also to commit to the solution.

This takes time up front, of course, but when a Product Development team has conviction that they’re solving the right problem in the right way, they can move fast with trust and confidence. And when something goes wrong, as it inevitably will, the team members have the context they need to address the issue in a way that still meets the goal of the project.

Product Development teams

I’m not saying there’s no place for “healthy tension” at a company. As this Product Plan article points out, “there’s a reason you don’t see titles like Vice President of Innovation and Compliance. A little tension is good.” For a company to be successful, it needs to have people with different perspectives, and there needs to be lively debate.

But tension between departments is different. I prefer to think of Product and Engineering teams as combined Product Development teams, making sure they’re in lock step as it relates to goals, strategies, and priorities. As this Martin Fowler article points out, “aligning these two disparate organizations [Product and Engineering] into cohesive team units removes organizational friction and improves time to value.”

I’d encourage all of us to adopt more of a Product Development mindset, acknowledging that Product and Engineering teams cannot thrive unless they’re joined at the hip.

A note on org structure

In my current role (as in my last few), I’m responsible for Product Development, which includes Product, Engineering, and Product Design. Despite my own experience, I don’t have a strong bias for all of these functions reporting to a single leader – I’ve worked with great CTOs and VPs of Engineering, and without the right leader, combining teams can be a mistake. My point in writing this post is not about having the right org structure, it’s about having the right mindset, which can exist in any structure.

Why is it so hard to stop the line?

taiichi-ohno-lean-manufacturing-1

Those of us who’ve adopted (and adapted) Lean software techniques owe a debt to Eiji Toyoda, and especially to Taiichi Ohno, who developed the Toyota Production System (TPS) and forever changed the way manufacturing – and eventually much of software development – works. According to Wikipedia:

TPS is grounded on two main conceptual pillars:

  1. Just-in-time – meaning “Making only what is needed, only when it is needed, and only in the amount that is needed”
  2. Jidoka – meaning “Automation with a human touch”

Core to jidoka is the concept of “stopping the line,” which means that when someone at Toyota identifies a problem, they’re required to stop production and resolve the issue. This ensures problems are addressed immediately, when they’re easier, less expensive, and less frustrating to fix.

Our eCommerce team has embraced this way of thinking. Our agile product teams are familiar with the Toyota story, and they understand the importance of identifying problems early. They sit together at tables, which makes collaboration easy, and they have daily stand-up meetings to make sure everyone’s on the same page. Best of all, they’re aligned around common goals, so they have the same motivation to improve the customer experience and their KPIs.

So why won’t they stop the line when they see an issue?

Stopping the line is really, really hard

Recently, my team released a couple of new features that weren’t up to our usual standard – experiences that were a little bit clunky. In both cases, after the projects were complete and the new functionality was deployed into production, we removed the new functionality from our site, sending the teams back to the drawing board. Weeks later, we’re still in the process of rebuilding these features, and we’re going through the work in great detail as a team to make sure we get it right.

Every single member of the team knew – weeks before launch – that the experience was less-than-perfect. And every single member of the team had been coached multiple times to stop the line. Even further, if you asked any member of my team if they understood the importance of stopping the line – if they agreed with it conceptually – every one of them would have said yes. And yet, nobody did it.

I asked three people why, and they all said some version of this:

Our team is working on becoming a well-oiled machine, and I don’t feel comfortable slowing things down.

The machine

Earlier this week I attended DevJam’s excellent Product Conference, and I was glad to hear its founder David Hussman discuss how product and agile are evolving. “We’ve gotten really good at building the wrong thing faster,” he said, and I couldn’t agree more.

My team was built for speed, and although I kept telling them to stop the line, I also told them a lot of other things:

  • “This new functionality is going to add a lot of revenue for our business.”
  • “You’ve got a long backlog.”
  • “If we get this done pre-holiday, it’ll be great for the bottom line.”
  • “Our Marketing team really, really wants this now.”
  • “It’d be great to get both of these projects done next quarter.”

By now you get the idea, and hopefully you see the problem. And it wasn’t just me. My team supports a lot of brands, and the brand owners, marketers, merchandisers, technology teams, senior executives – everyone, really, was in some way or other telling our product team to do more, faster.

In response, we became a machine built for speed. We got good at getting a lot of projects done, and we found a way to set and meet the goals we had before us. We implemented Test Driven Development (TDD), built automated tests, and found ways to get closer and closer to continuous delivery. And I’m convinced that every one of these things was – and is – the right thing to do.

The problem is that we did them at the expense of building great things.

In my next post, Encouraging people to stop the line with both carrots and sticks, I’ll describe what we’re doing about it.

8 reasons my team is great (and keeps getting better)

quote-you-cannot-make-an-omelette-without-breaking-eggs-proverbs-309526

My current eCommerce team is among the best I’ve ever worked with. In the past year, we’ve launched four mobile apps, re-platformed three eCommerce sites without any downtime at all, made major strides towards continuous deployment, and much, much more. (Even if you don’t know what any of these things are, you’re impressed by now, right?) Much has been written about building great teams, of course, and this is in no way meant to be definitive. Still, I want to share a few of the reasons my team has succeed so far (in no particular order), and why we’ll continue to get better:

1: Everyone on the team is a business owner

It would be an exaggeration to say that everyone on the team is motivated by our KPIs in the same way, or that each developer, user experience engineer, and Product Owner feels the same passion for driving revenue. Still, we do a lot of work to make sure each person on our team understands what drives our business, and the items on our product roadmap can come from any person or team. We understand both what we have to do and why.

2: We define our own priorities

Continuing on the above theme, our product roadmap is largely driven by the team. Because we understand what drives the business, we have the flexibility to work on the projects that are most impactful, in the order that makes the most sense. There are times we have to justify our priorities – and we review them with our senior executives each month – but we own the roadmap, no question about it.

3: We like to solve hard problems

Being intellectually curious is a big deal. Our team is smart, and intensely focused when it comes to finding sustainable solutions to big, hairy business and/or technical problems. Sometimes this leads to frustration – we don’t always have time to do things right, and we all despise increasing technical debt – but, by and large, our team strives to do things right, and we’re up for any challenge that comes our way.

4: We persist!

We like solving hard problems, and we don’t give up. When we can’t figure something out, we keep at it. Sometimes we wrestle with a problem for weeks – or months – before finding the answer we were looking for. Sometimes we need to try a lot of things before getting something right.

5: Our leaders push us in the right ways

When we need a kick in the pants, we get one. When we need some space, we get that too. From top to bottom, our company and team leaders understand that empowering the teams to do our best work is critical to our success.

6: We test and measure everything we do

Measuring allows everyone to see where we meet expectations and where we don’t. New functionality is AB tested until it “wins” and we’re confident we haven’t introduced new problems into the system. We’ve got dedicated testing and analytics teams, and our Agile development teams wouldn’t even think of introducing new functionality without their involvement. Of course, we still make mistakes, but when we do…

7: We learn from our mistakes

You can’t make an omelette without breaking a few eggs. Building and running our own web platform is hard, and despite all the great testing and measuring we do, mistakes are inevitable. Because we encourage continuous improvement and innovation, we also favor blameless post-mortems and retrospectives during and after all projects. These allow us to truly understand where we’re most effective and where we still have opportunity to improve. We’re going to make mistakes, but we really don’t want to make the same ones twice.

8: We genuinely like each other

Who wants to spend all week, every week, with people they don’t know or like? Not me. Work is a big part of our lives, but it’s not everything. People go on vacations, have babies, experience loss, and root for baseball teams (they often do those last two at the same time). And people who like each other are there for each other when they need support – in their work and in their lives.

We’re not perfect

If some of this sounds a bit aspirational, it is. My team is far from perfect, and we don’t always get these things right. We get crabby, and frustrated, and annoyed by each other. We argue, we have egos, and we break more things than we’d like. Sometimes we focus on the wrong things, and we’ve been accused of moving too fast. But the foundation of our team is strong, and our core philosophies don’t change.

Do any of these ideas resonate with you? Are you part of a high performing team? If so, what makes your team great? If not, how can you get there? I’d love to hear from you.

Shiny new objects rust over time

Many of us have worked in companies that prioritize work on an annual basis. In these organizations, it’s common to invest in a few things each year at the expense of everything else. “This is the year of search,” you might say, because “last year was the year of mobile.” On the surface, this makes total sense – you can’t make big investments in the same capabilities each year. Eventually, everything will have its day in the sun.

In reality, this is a terrible way of prioritizing work, completely ineffective, because it means that – until each program has its day in the sun – it’s essentially left to wither and die. Or to almost die, which is even worse. Don’t you see it? Look there in the corner – there’s site search, begging to be put out of its misery. It had its last big investment two years ago. It knows it’ll be the golden child again next year, but in the meantime, customers are mocking its uselessness, laughing at its broken experience. Poor thing. 

A few years ago, my company addressed this by implementing an Agile, product-focused approach. Within our organization, each product area receives some amount of ongoing funding, which allows the team to make consistent progress throughout the year. The amount of funding may change according to business needs, but the idea of making consistent progress across the business doesn’t.

Take the Search product for example. Several years ago, Search had its day in the sun. Replacing our old system was one of the company’s top priorities, and the project got all the people and money it needed to be successful. Once our new Search was implemented, the big project was over, but the need to make continual progress – to optimize the experience – was still there. (It will always be there.) So although the Search team got smaller and some resources were moved to new strategic priorities, the capability continued to exist – we continued to make it better.

Search is, of course, just one example of a large company initiative – a shiny object – that needs ongoing care and feeding. (I can’t think of a product that doesn’t.) Organizations built on a product management model get this. Before they build new functionality, they’re thinking about how to support it and what the long-term roadmap looks like. Organizations that are entirely project focused, on the other hand, are likely to face poor support and unexpected costs. That’s because they haven’t planned for the inevitable, and because rust never sleeps.

Related: How much of a problem can you buy away?