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:
While the discussion on my blog isn’t happening, I hope that this Twitter thread will trigger an interesting discussion and yield valuable insights.
Johnston, Clark & Shulver write about the service concept mainly from the customers’ perspective. They also allude to relevant others (specifically, ‘business leaders’) when discussing the service experience, outcomes and operations. However, this only seems to be a subsidiary concern.
Their version of a service concept does a good job of summarising key aspects of a service in an informal manner — and I use it in this way. However, more structure is clearly needed when going beyond that informal summary.
We need to think about employees (more generally, service providers) first. If we take good care of employees, they will usually take good care of customers, too. So we need to think about the employee experience, outcomes for employees, and the value a service creates for employees as much as about the customer experience, outcomes and value.
But other people are involved in or affected by the service. These may include others in the organisation providing the service as well as people external to it such as investors. Furthermore, there may be regulators, the community the organisation operates in, and even society at large (think ecological or ethical externalities).
When thinking about customers (or clients), we ought to also think about non-clients and anti-clients. Tom Graves (2010, loc. 254-256) describes non-clients as “people who are not and will probably never be customers of ours, such as people who live in a different country than one we serve” and anti-clients as “people who don’t trade with us in the normal sense but who don’t like us or what we do”. (Also see Tom’s blog posts on anti-clients here.)
Much has been written about the importance of selecting good names for things so that I probably don’t have to write much here. Just keep in my mind that the service name will be used very frequently, so taking time to find a good name or even changing an existing name to something better will pay of quickly.
The organising idea is the briefest meaningful summary of what constitutes the service under discussion. It is our first opportunity to communicate intent. A single sentence, perhaps even only a phrase, will often be sufficient.
To Johnston & Clark (2005), the organising idea is “The essence of the service bought, or used, by the customer.”
I’ve written about explicitly stating intent on my old blog before. First and foremost, it allows others to make independent progress toward a larger objective.
Live tweeting from London Lean Kanban Days 2019, Tobbe Gyllebring shared this:
That’s much nicer and much more powerful than what I used to say. Going forward, I’ll just borrow this:
Clarity of intent enables autonomous aligned action.
— Karl Scotland (paraphrased) via Tobbe Gyllebring
I like the notion of an organising idea: What is the fundamental idea that we should organise everything else around? Or even better, that we should let everything else (and everyone) organise around?
See The service concept revisited for context and for links to related posts. Interested in exploring this further? Please get in touch, I’d love to hear from you!
Johnston, R. & Clark, G. (2005) Service operations management: improving service delivery. 2nd ed., Pearson.
My discussion of The structure of the service concept is the most popular post on my old blog On Service Design. When I wrote it almost six years ago the topic didn’t seem to get much attention. Academic services marketing and service operations literature mentioned the term frequently, but almost no-one bothered to define it or describe its structure or content.
The Service operations management textbook by Johnston & Clark (the recent edition is by Johnston, Clark & Shulver) is by far the most thorough discussion I was able to find.
I still like the idea of a service concept very much, in particular for its effectiveness. A well-written service concept can communicate a wealth of information in a very small space.
I typically use the service concept in a fairly casual form when exploring initial ideas for digital services with clients and colleagues. Interestingly, I’m back to the earlier (2005) version of the concept’s structure (although the differences aren’t huge).
It’s useful for me to revisit the fundamentals and relate it to other relevant concepts, including some of the popular design canvases. Furthermore, I want to dig into its elements in more detail. I’ll be doing this in a series of future posts.
The need for shared-value propositions makes a similar point with respect to considering a service’s value not only in relation to customers and business owners, but also in relation to employees, suppliers and even society at large
We thought that we had the answers It was the questions we had wrong
— 11 O’Clock Tick Tock, U2
I’m afraid I’ve been a bit of a disappointment to some of my clients and to some of my managers. Rather than dropping into a situation and having the right answer to the issue under discussion, I tend to ask questions. Many questions. Way too many questions. And it’s getting worse with age.
Why does he ask all these questions? Isn’t he an expert?
Truth be told, it hasn’t always been like that — but the result’s weren’t always pretty. I can provide an answer quickly even today, but this is probably not a good answer to your question. At least not to the question you should be asking.
I can’t know what that question is until we’ve had a good conversation. Even better, you might be able to decide what that question should be during or after our conversation. And while we’re at it you might be able to determine what a good answer to that question is, the one that considers the specifics of your situation — which you understand so much better than I ever could.
I’m with you all the way on this journey. I’ll try to ask smart questions, give you food for thought, identify issues and risks, but also opportunities, probably make some suggestions or recommendations. And I’ll tell stories about similar or related things that I’ve seen, of things that worked and things that didn’t.
We’ll explore a situation together and co-create insight.
I’m lucky that I meet more and more people — clients, managers, colleagues, partners — who value this approach.
As a software developer, software architect or anyone else who influences software, you’ll want to know about Ruth Malan. Ruth writes about software architecture and, particularly interesting, about visual design in the context of software architecture.
I think you might be really interested in what Tom Graves (Tetradian) and Joseph Chittenden are doing on Patreon.
Their work is relevant for anyone involved in making change happen in organisations, i.e. you, me, regular people, and those in roles such as line managers, project managers, programme managers, product managers, product owners, system owners, business architects, enterprise architects, business analysts, software architects and so many others.
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.
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:
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:
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:
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…