Stop Scaling Agile
Stop scaling agility and focus on the development of a viable product. That is my entry statement and I will guide you through all the bits and pieces necessary to get there. I am talking a lot, but I do not like to write that much. Being a lazy person, I will document the principles, so information may be a bit dense. You have to fill in all the prose for yourself.
Good. Let us get started. Two questions are to be answered first:
- What is a product?
- What is a viable product?
First things first: What is a product?
For me a product is something that one person creates and some other person uses. It could be something physical that you can touch. It could be something immaterial, such as a service. An idea that I have and somebody else uses, does not count as a product. There are strange situations possible, where one person creates something and nobody is actually using it. O.K. there was an intended user. So more complete would be “something the somebody creates for the intended use by somebody else. That should be good enough. There is no need to be mathematically correct and complete in the definition. The definition is simple and very close to what is found in wikipedia.
The second point is about a “viable product”. What makes a product a viable product? In the biological sense, something viable is able to live and to develop. This is the definition I am going to use. That means, the product needs to have a lifecycle. It needs to be able to develop, change its features and adapt to changes in the environment. It needs to respond to different needs. Worst case, it will perish in case it cannot adapt enough to the changing market requirements. The definition of the death of a product then is related to its use. In case the product is still there, but nobody is actually using it, it needs to be considered “dead”. The mere existence of a product does not make it alive.
Based on these considerations, we have some boundary conditions for our products:
- products are never static. Products adapt to the changing needs of the user or stake holder.
- they fulfill at least a subset of desires expressed by the user. They fulfill at least one job that needs to be delivered by the user or that pleases the user.
- maybe more…
This is an abstract definition of the entity product, however it excludes built-to-order deliverables. Built-to-order jobs in some cases are built on top of a product platform or are just simple configurations of a platform. The trivial example is computer hardware that is “built-to-order”, where you can select RAM size and mass storage space, and maybe the color of the housing. This is “built-to-order” in many cases just to reduce the amount of material in the storage. There might be a yacht that you order, that is built according to your specifications or large truck. Both products are products in a sense that They are built on top of a certain platform, but very customer specific. In case of the yacht, we may enter a pretty unique job at the higher end of the price range.
In most cases, things developed based on a specific order are built on top of something that had been pre-developed and are then adapted. The adaptations may be larger or smaller. that does not matter in principle. The delivered units however do not have a lifecycle. They do not have versions after they went into production. They will not be phased out and replaced with a new version.
Now it should be clear what we discuss when we talk about a “product”. If what you are doing, falls into the category of “built-to-order” items – no matter how big your item is – many things what we are discussing will not directly address your topic, but: Aspects of nearly everything we discuss can be of good use to you, so please stay with us. In an extreme case, your product might be a harbor. It will be built to order. It will be very unique, but it has a lifecycle. You very likely will not build it once and then forget it. It will be extended (hopefully for the owner), maintained, adapted, changed, modified, re-purposed, … . It for sure has a lifecycle like this. In consequence many of the practices and treats I am introducing here will be perfectly useable.
”Stop scaling agility” is the title of this post. Why should I use agility and by the way, what is “agility” at all? And why should I scale it?
Definition of terms continued: “agility”. Many people have tried to define it. There is no definition for a good reason. I believe the best thing is: Follow the agile manifesto. If you do that, then the next topic is also solved. Then there is no need for “scaling agility”. That then makes no sense. Logically. You may need to scale scrum for example. That is correct, but scrum is just a single method. Before now hell breaks loose, check the web page on the agile manifesto and read about the history. There are just principles, no recipes. There is nothing that needs scaling. Period.
Agile methods now mainly reflect on the “New New Product Development Game” article by Takeuchi and Nonaka. No discussion, there the teams need to be small, just like scrum teams for example. To build a large product in reasonable time, you need to have a large team. Here the work of Melvin Conway kicks in. –> with little interaction between the constituents of the system, you can develop a team setup that consists of units with little interaction. Scaling topic solved.
Scaling agility is a big topic and big business nowadays. Agility in its original form is used in teams to collaborate. One of the key elements is communication. Thus in consequence, the team size is limited. To the lower end at doubt three to four individuals. At this size or in even smaller teams communication and alignment is automatically build in. For larger teams, the upper limit may be discussed but lies somewhere between ten and 20 team members. If we want to organize work, delivered by coordinated actions of more people, we embark on so-called agile scaling concepts. These concepts come with more or less formal overhead.
There are commercial and non-commercial solutions available. All have one thing in common: they are more or less complex and involve coordination of different activities. Discussing complexity with system engineers shows that there are elaborated methods to manage complexity. No matter what, all of these methods slow down the value generation. In consequence complexity kills innovation and productivity. The most natural reaction then is to reduce complexity and make things simple: Always strive for simplicity to be fast. Complexity is killing speed.
This does not imply to the keep the problem we are tackling simple. Problems we are solving may be very complex. The solutions however need to be simple for the teams to develop them with high quality and little distraction.
How can we develop something complex and keep it simple for the teams? The answer is in the product, not in the way we orchestrate the project execution.
Focus on
- Architecture
- Loose coupling
- API first principles
- Data orientation
These are the big topics I will be addressing. In this order.
As Hors’d Oeuvre let me focus on the obvious thing: Do we always need agile methods (if you now come with “agile is a mindset, not a method”, please read here.)? My clear answer to that is: NO. And this is the most agile answer you can give. Do what ever gives the best results in the given context to satisfies the customer (and yourself).