This week at Agile Austin the conversation veered toward a familiar topic: *each problem is different therefore we cannot apply the same process to them*. We, software developers, want to believe this. Why? Because this can be used as a convenient excuse: we *don't have to follow a process* if all problems are different. After all, we are on a quest to find the one true process that fits all programming problems, right?

Reality is more nuanced: when we look at each problem in its entirety, then indeed each problem is quite unique. When we divide a big problem into a series of smaller problems, then many of the smaller problems turn out to be run-of-the-mill everyday problems. We have seen them, and we have processes (not necessarily written processes) for solving them. Maybe we need to tweak a processes slightly because of a minor variation, but we can comfortably identify the pattern and follow the associated process.

A few of the constituent sub-problems, mostly *the ones that provide the unique value proposition* of the application, require unique treatment and attention. For these we need to create new processes. These are processes that are custom fitted to the new problem. These, however, are a small fraction of the overall problem.

It might help if we think in terms of process building blocks. Some of these building blocks are already available. We only need to create some new processes to custom fit a the new parts of the problem. As early as 2002, in my talks I have been proposing the following:

- The problem needs to determine the process required to solve it.
- A team that worked on a few problems together already has some processes that they used more then once. Let's call these software process building blocks.
- When faced with a new problem, the project team assembles the exact process that solves the overall problem.
- For the brand new parts of the problem, the team creates new processes.

The "One Right Process" that solves all problems doesn't exist. A "process framework" that contains concrete processes for "smallish" problems can be useful. Based on the framework we can create an *instance* of a process that fits the problem we have to solve. Then, we have to follow the process that we just created to solve the problem on hand.