Over a million developers have joined DZone.

How Should We Organize Our Teams?

DZone's Guide to

How Should We Organize Our Teams?

Q1: How should we organize our teams? My team is owner of different trading platforms and the core services around it. But we depend heavily on other product...

· Agile Zone ·
Free Resource

Download the whitepaper on Product Centric Agile Delivery. Brought to you in partnership with Jile.

My team is the owner of different trading platforms and the core services around it. But we depend heavily on other products (e.g. financial feeds, client identification, services to send orders to stock markets, etc.). And of course, each of the team managing these services have other platforms that are their clients.

When Vasco Duarte and I ran the #NoEstimates/#NoProjects workshop (or #NoNoWorkshop as I think of it) in Switzerland last month, the attendees asked some good questions. With Project Myopia done and published, and Continuous Digital almost done, it seemed like a good time to repeat, and elaborate, the answers publicly. This will take a few blog posts to work through.

(I now have several Continuous Digital workshops and briefings available, please let me know what you think. Vasco and I are looking at repeating the workshop in London later this year, please get in touch if you are interested.)

The picture above is the way I see the question; if you have another interpretation or another scenario, please let me know.

The Continuous Digital model is for stable, long-standing, autonomous, value-seeking teams staffed with all the skills they need. Much of my thinking derives from Amoeba Management. Importantly, each team needs to see how it adds value. In this case, the business facing teams can see this — they enable the business to make money. But the back office teams find it hard to see how they add value.

Now there are several possible answers to this question, most of which involve some sort of re-organizations.

Option 1: Share the Value

This solution does not involve reorganization and comes straight from the pages of Amoeba management: allocate some portion of the value earned by the business facing teams to the teams they depend on. For example, the trading platforms team might generate $10m each year. It could not do this without the services of the other three teams. Therefore, some portion of the trading team's earned value is passed to those teams.

Think about it, trading platforms effectively buy the services of three other teams. If those teams did not exist, the trading platforms would need to do that work themselves. Therefore, those teams are contributing and deserve some credit.

This requires a serious conversation and probably needs more senior managers to intervene. Indeed, in Amoeba Management, Kazuo Inamori says that such decisions were among the most difficult ones facing Kyocera and often required more senior managers to make the final decision.

Nor is it always clear who buys from whom. Does a Sales Amoeba earn the value and pass part of it to the manufacturing team who build the product? Or does the Manufacturing Amoeba hire the Sales Amoeba to get their product to customers and therefore book the revenue and pass some to sales?

In the case above one might find it better to consider the value of the whole trading team including both the traders and the programmers who make the platform. Or perhaps the traders rent the platform from the technologists.

According to Inamori Kyocera, standing allocations are set between teams. Alternatively, one might create an internal market in which teams buy services from others on a piecemeal basis. On the one hand, I like that idea model because it would allow for negotiation and trade-offs. On the other hand, I imagine it creating a whole new set of bureaucracy, politics, and internal sales. On balance, I'd fix the allocations and review periodically.

Option 2: Vertical Slice

If you look at the picture above you might replace the word "team" with "library" or "services" and you would have a module dependency chart. Conway's Law is at work — the organization and system reflect each other. (Although without knowing the history here, it is difficult to say whether this was Conway's Law or Reverse Conway's Law at work.)

The services can stay as they are but we just disband the back-office teams and pass their responsibilities to the (enlarged) business teams.

The three teams will need to co-operate and co-ordinate with each other as they now have shared responsibilities. This itself can be a problem — two developers changing the same code anyone? But the world has moved on. Technology has improved.

In the days of SCCS, Visual Source-Unsafe, manual testing, and monthly deployments, it was a pain to have two teams working on the same code. But distributed source code control, automated testing, and continuous delivery make this option far more viable than it once was.

On the plus side, each team can work at their own pace on their own priorities and knowledge is spread around. On the downside, teams can still trip up each other, and they may duplicate work and specialist knowledge can get lost. (Note I am not saying "nobody has overall design authority" is a downside because while a single Linus can be an advantage, it can also be a liability.)

One more problem here: this solution directly breaks Conway's Law. In theory, it could work but quite possibly the homomorphic force behind Conway's Law might reassert itself. This might create some problems further down the line so needs monitoring.

Option 3: Independence

Taking option 2 to the extreme you might even separate the teams completely. Again, there are plus and minuses.

On the one hand, the teams are completely independent, they can move at their own pace, with their own priorities, value is clearly attributed, and there is now resilience in the system and risk is reduced.

However, there is duplication. Not only does this mean more work it means that there may be inconsistencies, a client recognized by trading might not be recognized by Yet Another.

Both options 2 and 3 demand larger teams and this option might require more people overall. One can't be sure because teams might come up with innovative solutions or come up with some new mechanism for sharing.

I'm sure some readers will discount this option very quickly but there are big benefits to complete independence — particularly when teams are separated geographically (e.g. Trading in London, Some Other in Frankfurt and Yet Another in Singapore) or when they are addressing different markets. One of the dangers of shared modules is that they become bloated by generic features nobody really wants but someone has to pay for.

This approach might also be advantageous when the company is in a growth and innovation mode. Let each team grow as fast as they can and innovate. In time, a "winner" might emerge or common elements appear naturally.

Another variation on option 3 would be to have one team take the lead. Say Trading, this would be a larger team who developed the share services as part of their business facing work. But they would not "genericize" those services. The other, smaller teams, would do what they needed, when they needed, to service their own value streams.

There are three options. I could come up with some more, but none is perfect. The important things are:

  • Create a clear way for teams to see the effects of their work and share in the value.
  • Allow teams autonomy in decision making and reduce dependencies.
  • Keep it simple so everyone can see cause and effect.
  • And of course, keep the teams stable  — don't break them up.

If you have any questions about Continuous Digital and #NoProjects please mail them over and I'll do my best to answer them in this blog.

Download the whitepaper on Five dimensions of Scaling Agile in Large Enterprises. Brought to you in partnership with Jile.

team organization ,agile ,shared responsibility ,conways law ,value

Published at DZone with permission of

Opinions expressed by DZone contributors are their own.

{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}