Category Archives: Organization

Shaping software development teams #3: autonomous teams vs. technical integrity of shared components

This is a follow-up to https://oliverbaier.wordpress.com/2019/03/06/shaping-software-development-teams-2/. Initial post at https://oliverbaier.wordpress.com/2019/03/02/shaping-software-development-teams/.

There are those day where I’m not sure why I bother writing. So I have tried—and failed—to provoke a discussion in this series of posts using quite a few words. Turns out, Simon Brown (of C4 Model fame) can do it in a single tweet:

Autonomous feature teams tend to weaken technical integrity of shared components

While the discussion on my blog isn’t happening, I hope that this Twitter thread will trigger an interesting discussion and yield valuable insights.

Shaping software development teams #2: greater independence, less consistency, more duplication

This is a follow-up to https://oliverbaier.wordpress.com/2019/03/02/shaping-software-development-teams/.

A platform of loosely connected product

A while ago I was supporting a company that offered a digital platform to small and medium-sized business in a specific industry. Great people, interesting ideas — a very enjoyable experience.

This platform was composed of independent products which were connected only very loosely. Some of these products were also marketed to customers independently of this platform.

Greater flexibility, greater inconsistency, more duplication of effort

This approach provided great flexibility to the company and its partners, independence and perhaps even a friendly and good-natured competition of ideas and approaches. However, these products (or services) provided very different experiences to their users — in terms of visual design, but also in terms of interaction design, terminology, data structures etc..

This could be considered to be largely acceptable as users understood (at least to some degree) that different products were used by this platform, but a higher degree of consistency would likely have been appreciated by users. However, that company also experienced a higher degree of feature duplication than would have been acceptable in any of the initiatives I’ve worked before.

Trading consistency for team effectiveness and efficiency?

More cohesive platforms (products, services, applications, whatever), or platforms that are desired to be perceived as more cohesive by users, can be negatively impacted by much subtler inconsistencies than the ones I described above. Avoiding these inconsistencies while maintaining team effectiveness and team efficiency is what this discussion is all about.


Updates

2019-03-15: Added note on feature duplication.


Shaping software development teams

You can only do so much in a single team

There seems to be a broad consensus that many types of software are best built and developed by cross-functional, self-organizing teams with about five to nine members using lean and agile approaches. (There are types of software and problem domains that require different approaches or need to be supplemented by additional practices, for example in health and safety related domains. I don’t focus on these here.)

Much software requires more than a single team to build and run. At this point, a decision on how to shape these teams and which responsibilities they take on becomes necessary. This decisions will have a significant impact on how the teams work, on how they collaborate and communicate with each other, and on the results they produce.

Teams shaped by functional domain

The common approach seems to be to organize teams by feature or functional domain. In this case, the teams would cover the full technology stack from front-end via services and application down to databases, storage, integration and compute infrastructure. This is certainly better than organizing teams by software layer such as user interface, application logic, underlying domain logic, and the data access layer.

In an e-commerce context, one team might take responsibility for product browsing and selection while another team might be responsible for the checkout process. A third team might take responsibility for account maintenance.

This might look something like this:

A diagram depicting a web application with user interface elements for the Browse, Checkout and Account domains. In addition, there are separate service for these three domains. There is one team per domain. This team is responsible for the user interface element and the corresponding service. It is unclear who owns the overall web application or ensure its integrity.

This is not unreasonable when we look at a single web application — but it may not be without problems even in this limited case. Great care needs to be taken so ensure that the boundaries between these teams do not lead to observable boundaries between these features or functional domains. For example, we do not want the user interface to subtly change when moving from product selection to checkout. (Think Conway’s Law.)

Going further, how does this approach scale to different client apps and interfaces? What if we want to add an iOS app? An Android app? Plus a public API? And support for voice assistants?

Adding people with the necessary skills to the teams is likely to cause the teams to grow beyond a reasonable size (even if individual team members are skilled in multiple areas). And the problem of ensuring integrity in these client apps and interfaces multiplies with the number of apps and interfaces.

App teams and service teams

To me it seems beneficial to separate the responsibilities for the client apps and interfaces from the services (or components) providing functional capabilities (i.e. managing access to data, implementing calculations, or implementing a business interaction such as placing an order).

This might look like this:

A diagram depicting a team responsible for the web application (with user interface elements for Browse, Checkout and Account) and a separate team for each of the services (Browse, Checkout and Account).

This allows app teams to focus on their users, the context they live and work in, their needs and preferences. Ensuring experiential and structural integrity within a single app becomes easier. App teams can also develop deeper expertise in the app-specific technology stack (e.g. web front-end vs. native mobile front-end vs. API management infrastructure).

Similarly, teams taking responsibility for services (or components) in a functional area can develop deeper expertise in this functional domain (e.g. pricing, order fulfilment, or product configuration). These teams can also develop deeper expertise in their service-specific technology stack.

Broad and shallow vs. narrow and deep responsibilities

I view app teams as having broad yet shallow responsibilities while service teams have narrow yet deep responsibilities. This refers to the breadth of functional scope and the depth of the technology stack. (I do not imply that app developers are somehow less technically adept or that their work is less technically complex than that of service developers. But in order to display a price to a user I do not have to know how to determine that price. And in order to determine that price I do not have to know when and how to effectively display that price to a user.)

I envisage these broad app teams and the deep service teams like this:

A diagram showing several app teams using broad but shallow shapes. It also shows several service teams using narrow but deep shapes.

This approach to organizing teams requires collaboration between the app and the service teams to design and evolve the service API. We replace informal collaboration between team members (e.g. those focused on the UI and those focused on service implementation) with formal cross-team collaboration on an interface. This collaboration on the interface also ‘pays’ for mitigating the risk of friction at the boundaries of different parts of each app.

In this context, I’m thinking more about data-centric services (probably with a fairly generic and perhaps somewhat coarse-grained interface) rather than fine-grained RPC-style functions dressed up as a not-quite-RESTful JSON-over-HTTP interface. This should lead to increased stability (i.e. reduced volatility) of the interface and simplified dependencies (i.e. coarse-grained rather than fine-grained dependencies).

This is not “separate teams per software layer” — I think

So, I’m not — at least I don’t think I am — naïvely advocating for removing the UI layer from the application component, and thus advocating for a minimal form of separate teams per software layer. Instead, I view the different client apps and public APIs as individual products. I think that these products need to be product-managed. Similarly, I view these underlying functional services as products. The sum of their interfaces form an API (potentially, an internal API) which I view as another product. These products need — and deserve — to be product-managed, too.

What’s wrong with this?

And now, considering that this approach does not seem to be widely discussed, the Gretchenfrage: What am I missing? Why doesn’t this make sense? What would be a better principle for organizing teams in such a setting? Why is the team-by-feature approach superior?


I typically work for medium-sized to large companies building B2C, B2B or B2E products. Building significant features or functional capabilities typically requires collaboration and alignment with multiple groups within in the company. Such capabilities often depend on additional systems beyond the team’s control. YMMV.


As a bonus, the diagrams in this post show clearly that there is a difference between a visual designer and a graphic designer. Ah, well…


Follow-up posts


Updates

2019-03-15: Added diagrams. Added heading. Slightly extended comments on teams per software layer.

Cross-functional product management teams

Over the years, we have achieved some success with the cross-functional software delivery teams established (well, popularised) by lean and agile methods. More recently, the perspective has broadened somewhat to delivering usable solutions rather than working software.

I think it’s time to broaden the perspective a little more and to think of software-supported solutions in terms of products more consistently and to manage them accordingly. Kristofer Layon’s book Digital Product Management is a good start.

My experience mostly comes from fairly sizeable digital business initiatives in fairly sizeable organisations. While your mileage may vary with the size of the initiatives and the (network of) organisations you are involved, I believe that the basic argument put forward in this most still holds true in a smaller context.

Years ago I’ve seen projects succeed whose leadership included a competent functional architect and a competent technical architect. This duality was de-emphasised by the Unified Process with its strong focus on the (fairly technical) software architect role and by Scrum with its focus on the (fairly functional) product owner role. To make things worse, providing the “content leadership” (a better term, anyone?) on any sizeable initiative is a tall order for any single person, at least in my experience. Disciplined Agile Delivery begins to address this issue be re-emphasising this duality with its product owner and architecture roles.

To me, this looks like a good start but I think we ought to go a step further: I suggest that introducing cross-functional product management teams is likely to yield similar benefits in the area of “content leadership” as introducing cross-functional solution delivery teams did in the area of producing software-supported solutions.

For example, in addition to business and technology design expertise, we certainly want to include experience design expertise in the product management team in most contexts. Other expertise can be added as and when necessary.

In addition to the immediate benefits of the cross-functional approach, this will also help to reduce the load on the two people that used to be “the architect” or “the product owner”.

In the type of contexts that I tend to work in, this leaves a digital business initiative with three major groups: project management, product management (in a staff position to project management) and the delivery team(s).

The concerns addressed by these groups can be delineated quite nicely, which offers the benefits of clear focus for each of them. In combination with a shared purpose, these clearly defined responsibilities provide a strong basis for collaboration across these groups’ boundaries

De-emphasising organisational boundaries unfortunately not a silver bullet

Many smart people have written many smart things about new ways of organising work that have become feasible in the last few years. Some of these smart people are Tom Graves and Dave Gray. A key aspect of many of these new ways of organising is de-emphasising traditional organisational boundaries, i.e. in effect doing work across organisational boundaries that would have been done within organisational boundaries just a few years ago.

The opportunities this brings have been discussed thoroughly before as actually have been the risks. So the following really is old news…but I feel strangely compelled to get it out of my system:

When you depend on others for critical parts of your performance, then critical parts of your performance actually depend on others.

When operating in a network of nimble and effective organisations this might be not much of a problem—assuming you can reorganise your value stream or value network in a swift and flexible way. Traditional corporate outsourcing can produce scenarios in which several large organisations are tied together by rigid contractual frameworks and complicated operating models over a fairly long time.

In these situations, the partners may feel they cannot obtain and, respectively, provide optimal value, but tragically feel they are unable to do much about it. Sooner or later, organising essential work strictly within the boundaries of the organisation looks preferable.

That sounds like rewinding a couple of decades and starting over. I think we can do better than this.