Prioritize for Long-Term Success Within Your Cross-Functional Product Team

This radical approach puts the ownership of engineering work in the hands of engineers and takes a long-term, strategic approach to craft solutions that can change for a long time going forward. Your investment pays off with the culture you end up building.

During a talk at Google, Prof. John Ousterhout describes two to approach software design based on his book A Philosophy of Software Design. A tactical approach focuses solely on getting something working. A strategic approach goes beyond the tactical, removing complexity and producing a great design.

Why do we want a great design? So that we can develop fast in the future. It’s really all about investing. Invest in good design today because most of the code we develop is going to be in the future. If we mess things up today, we’re slowing ourselves down in the future.

— Prof. John Ousterhout.

Background

Ousterhout makes the case that an investment in software design pays off through the ability to move quickly over time.

I have worked at companies that have chosen to be tactical. Unfortunately, this choice resulted in many unwanted side effects. They end up with parts of the system nobody wants to touch. As a result, they try a different approach, writing new code “off to the side.” These efforts lead to multiple patterns in the code. Even worse, it leaves the user with a fractured experience in the software.

Ousterhout claims that teams should invest 20% of their time in design. This strategic investment produces maintainable code, resulting in less complexity, leading to faster results over time.

The teams I’ve seen focus only on tactical wins end up with a codebase that can’t handle the changes necessary in their current system to improve the product for users.

You can be successful with crappy code. You can be tactical and build companies that succeed. You can also succeed with the other approach.”

— Prof. John Ousterhout.

By investing in software design — both the code design under the hood and the UX and visual design that customers experience — even an underwater team can quickly reach a point where the investment provides returns through a better user experience and a better developer experience.

The team moves faster in the future and truly delivers more value to more customers.

In Practice

Engineering Managers should handle prioritization. They will be able to make the trade-offs between investments in functionality that deliver value to their users and advances in the code, which pay back in decreased complexity and long-term maintainability.

Developers can digest the impact of financial trade-offs. ROI decisions are similar to home-economics choices that we all make. You spend less than you earn, take on debt strategically, invest some amount towards the future, and accumulate increasing gains over time.

Engineers also understand users and their use-cases. Next, they analyze the problem they are solving. Finally, they turn that knowledge into working code.

Readability, maintainability, sustainability, operability, and others result in long-term value in the code. Unfortunately, non-engineers do not understand software design trade-offs and priorities. It’s difficult, if not impossible, for someone non-technical to appreciate engineering concerns. The Software Engineering literature names them “non-functional” requirements.

Tactical approaches focus solely on the functional requirements. Strategic approaches, as Ousterhout explains, consider the full engineering spectrum.

Product Managers should advocate for the users. They should make their case for what they think the product needs to evolve. They should back their claims with analysis.

Within an empowered team, those performing the work prioritize and manage the workload. In this case, engineering workload is prioritized and managed by Engineering Managers. However, a significant part of that workload serves the users through the product. Therefore, the Product Manager prioritizes the user-facing part of the workload.

Product Managers handle product prioritization. The team folds those priorities into their overall workload. The team prioritizes, manages, and executes the work with the Engineering Manager.

A strategic approach becomes an engineering-driven approach, where engineering drives the workload priorities. The overall engineering workload includes the product work, which is worked and managed by engineering, and shared with all stakeholders. The team balances short-term wins with working software and long-term investments resulting in a product that can evolve.

Addressing Concerns

When prioritizing technical debt, a frequent consideration comes up:

“What is that worth to our users?”

Product Managers prioritize based on value to the user. Exclusive prioritization of user-facing value, at the expense of the codebase’s long-term sustainability, leads the team to take a tactical approach. The code gets to a point where the developers cannot bend the software towards the next iteration.

The term software itself has the root soft, which means malleable or changeable.

Added time pressures, real or imagined, contribute to teams taking tactical shortcuts. Unfortunately, these shortcuts result in struggling to move the current product forward. Except in some instances of “Golden Tickets,” Google has developers set timelines for software delivery, allowing for the time needed for investments in design.

There could be doubts that engineers would solely focus on technical improvements, but that has not proven the case in much of the industry. Instead, engineers are in it for building meaningful features that get used. This radical approach, putting the ownership of engineering work in the hands of engineering, lets the team take a long-term, strategic approach to craft solutions that they can work with and change for a long time going forward.

The Payoff

Where the really good software developers go, they really care about design, and they do good coding. If you have that culture, you’re in a much better position to recruit the best programmers. The best way to get great products out fast is to get the best programmers. The strongest argument in favor of good design culture is it allows you to hire top people, and that will give you an advantage.

— Prof. John Ousterhout.

Your investment pays off with the culture you end up building. For example, a company that values software design attracts great developers. Those developers will, in turn, create the next generation of great products fast.