# Shape Up

## Chapter 9: Place Your Bets

## Look where you are

Depending on whether we’re improving an existing product or building a new product, we’re going to set different expectations about what happens during the six-week cycle. This invites us to reflect on where we are in the arc of our product’s development and bet accordingly.

## Existing products

When we add features to an existing product, we follow the standard Shape Up process: shape the work, bet on it, and give it to a team to build. We expect the team to finish and ship some version of the shaped work by the end of the cycle. On an existing product, all of the existing code and design that _isn’t_ going to change defines a kind of empty space that the new feature will fit into. Shaping and building is like crafting a piece of furniture for a house that is already built.

## New products

New products are different. Whereas adding to an existing product is like buying a couch for a room with fixed dimensions, new product development is like figuring out where the walls and the foundation should go so the building will stand. We’ve noticed three phases of work when we build a new product from scratch. In each phase, the way that we shape and our expectations for how the team will work together during the cycle are different. These phases unfold over the course of multiple cycles, but we still only bet one cycle at a time.

## R&D mode

At the very earliest stages of a new product, our idea is just a theory or a glimmer. We don’t know if the bundle of features we imagine will hold together in reality, and the technical decisions about how to model them in code are even less clear. This means there is a lot of scrapwork. We might decide half-way to standing up a feature that it’s not what we want and try another approach instead. In other words, we can’t reliably shape what we want in advance and say: “This is what we want. We expect to ship it after six weeks.” We have to learn what we want by building it. We call this stage `R&D mode` and adjust for it in three ways.

1. Instead of betting on a well-shaped pitch, we mainly bet the _time_ on spiking some key pieces of the new product idea. The shaping is much fuzzier because we expect to learn by building.
2. Rather than delegating to a separate build team, our senior people make up the team. David (CTO) takes the programming role and works with Jason (CEO and designer) or a senior designer with Jason’s guidance. This is necessary for two reasons. First, you can’t delegate to other people when you don’t know what you want yourself. Second, the architectural decisions will determine what’s possible in the product’s future — they define the “holes” that future features fit into. At this phase the team needs to hold the vision of the product and be able to judge the long-term effects of design decisions.
3. Lastly, we don’t expect to ship anything at the end of an R&D cycle. The aim is to spike, not to ship. In the best case we’ll have some UI and code committed to serve as the foundation for subsequent work. The goal is to learn what works so we can commit to some load-bearing structure: the main code and UI decisions that will define the form of the product going forward.

## Production mode

If we continue to get warmer after some R&D cycles, we’ll eventually reach a point where the most important architectural decisions are settled. The product does those few essential things that define it, and the foundation is laid for the dozens of other things we’ll have to do before we can ship to customers. With this structure in place, the senior team can bring in other people to contribute. This is the flip to `production mode`, where we work in formal cycles with clear-cut shaping, betting, and building phases. Production mode is like working on an existing product: the precedent set by the R&D work enables new contributors to identify where new functionality belongs and how it fits into the whole.

In production mode:

1. Shaping is deliberate again. The shaped work describes what we expect to see at the end of the cycle.
2. The team that builds the projects is no longer limited to the senior group. It becomes possible to bet multiple teams in parallel (if you have them) and cover more ground.
3. Shipping is the goal, not spiking. But because the product isn’t publicly available to customers yet, we define ‘shipping’ differently. Shipping means merging into the main codebase and expecting not to touch it again.

## Cleanup mode

In the final phase before launching the new product, we throw all structure out the window. We call this `cleanup mode`. It’s a free-for-all. We’ve built enough new products to learn that there are always things we forget, things we miss, details that aren’t right, and bugs that creep in over the course of the R&D and production mode cycles. There’s something about putting your finger near the launch button that makes your hair stand up. Everything suddenly gets “real.” Things we dismissed before pop out at us with new importance. That’s why we reserve some capacity at the end for the unexpected. In cleanup mode:

1. There’s no shaping. The cycle is closer in spirit to the “bug smash” mentioned in the previous chapter. Leadership stands at the helm throughout the cycle, calling attention to what’s important and cutting away distractions.
2. There aren’t clear team boundaries. Everyone jumps in to help however they can.
3. Work is “shipped” (merged to the main codebase) continuously in as small bites as possible.

## Examples

### The Dot Grid Calendar

We built the Dot Grid Calendar for Basecamp, an existing product. We shaped the project, bet six weeks on it, a team built it, and then we shipped it straight to customers.

### A new product: HEY

In 2020, after two years of development, we launched a new email app and service called HEY. HEY was in `R&D mode` for the first year of its development. A team of three, Jason (CEO), David (CTO), and Jonas (senior designer) explored a wide variety of ideas before settling on the core. Nearly a year of `production mode` cycles followed, where all of Basecamp’s teams fleshed out HEY’s feature set. We ended with two cycles of `cleanup` and significantly cut back the feature set to launch in July 2020.

### An experimental feature: Hill Charts

A third example shows some grey area. When we built the Hill Charts feature in Basecamp, we had no idea if it was going to work out or not. Basecamp was an existing product, and it felt too risky to bet on releasing this experimental feature to customers. So we framed the project more like a production mode bet on a new product. We shaped a first version that was just functional enough to use ourselves. We didn’t expect to ship it to customers without doing an additional cycle on it. This was a risk: we bet one cycle, not two. If it didn’t work out, we’d scrap it. If something more important came up, we might not ever schedule the second cycle. But we ended up feeling confident after the first cycle. We shaped a project to round it out, decided to bet another cycle, and then shipped it to customers.

## Questions to ask

### Does the problem matter?

Just like in pitch write-ups, we always take care to separate problem and solution. The solution doesn’t matter if the problem isn’t worth solving. Of course, any problem that affects customers matters. But we have to make choices because there will always be more problems than time to solve them. So we weigh problems against each other. Is _this_ problem more important than _that_ problem right now?

### Is the appetite right?

It’s good when we have a solution shaped to a reasonable time frame, like two or six weeks. But we might still debate whether it’s worth the time. Suppose a stakeholder says they aren’t interested in spending six weeks on a given pitch.

### Is the solution attractive?

The problem may be important and the appetite fair, but there can be differences about the solution.

### Is this the right time?

The kind of project we want to do next can depend on which projects we’ve done recently. Maybe it’s been too long since we’ve made a splash of news with a new feature.

### Are the right people available?

As part of the betting process we choose who specifically will play which role on each team. That is, we’ll pair a project with a specific small team of a designer and one or two programmers.

## Post the kick-off message

After the bets are made, someone from the betting table will write a message that tells everyone which projects we’re betting on for the next cycle and who will be working on them.
