Notes on Product Development: Shared Understanding
Tags: product, development, agile, collaboration
Published: 2020-01-22 12:45:42

---
title: Notes on Product Development: Shared Understanding
published: true
description: Creating a shared understanding
tags: product, development, agile, collaboration
series: Notes on Product Development
---

---

_There is a lot of literature focusing on product development, agility, methodologies, processes, frameworks and many other write-ups on anything related to building products.
This series is just a collection of personal notes, learnings and reflections on product development and everything that revolves around it. Mainly it's a collection of notes that focus on collaborative product work, on iterating and learning._

---

Some people view product development as a rigid process and others see it as exploratory. For some it can be a collaborative effort, for others it might be an isolated process with clear defined boundaries.


Most products evolve from trying to solve a __customer problem__. Sometimes the initial features are implemented by an individual or a very small team. But what happens when this small setup evolves into a large team or even teams working on these features?

At some point a different __process__ kicks in, __r​oles__ start to become more specific, ​specialists start to join and everything becomes more formal.​
While early on there is probably a shared understanding on why certain problems needed solving, it becomes harder to keep that shared understanding over time. People might join without having the ​general understanding or context ​that the initial members had.

_But isn’t making a shared understanding something of high priority?_

Let’s talk about what is meant with „shared understanding“ in this context. Very often we have roles, like _Product owner_, _Developer_, _QA_ or _UX_ person etc., all specified with certain r​esponsibilities within the process.

There might be a person that „manages“ a backlog of items and writes down the specifications in form of stories or in another format. 

Some people might be tasked with implementing these stories according to a predefined specification. Others might create designs and layouts and user workflows based on these specs and then there are others that ensure that the implementation matches these specification or acceptance criteria.

_Looking at the above scenario, is there a shared understanding?_
_Does everyone involved know why this feature is being implemented?_


From the above scenario, the „​story“​ is the artifact, that should create a shared understanding. It should contain some __information on the ​why__.
On the other hand, we can’t really tell if there is a shared understanding just from thinking about that scenario. There might be no shared understanding and the specifications being the only common thread. But there might also be a strong common and shared understanding as the collective had long discussions and maybe a couple of sessions to identify and define the specifications.

What we do see, is that some type of ​hand-off ​is taking place though. A story is defined, designs/workflows/mockups are created, these are then handed-off to a different group that does the implementation. Once the implementation is done this is handed-off to the next group that ensures the solution is on par with some predefined standard. There might be more hand-offs involved, like passing the implementation to ops, to run the solution and so forth.

_Is there a more effective way to generate a shared understanding though?_

Let’s think about some scenarios. In Scrum for example, it’s the ​_development team_ and the _​product owner_. ​Two separated entities, that meet at a pre-defined meeting like the ​sprint planning​.

_But why is there a built in hand-off from the very start?_
This might be due to historical reasons, mapping back to classic project management, which was tasked with ​managing the people and the ​project. The more modern version is a product person managing the product, but not being part of the implementation team.

_But who should be part of that team?_

Before we try to answer that question, maybe it would be interesting to start from the customer and work backwards from there.
A customer might need a solution for editing some profile information. Who could understand the actual problem inside the organization? 

Multiple people come to mind. Let’s think about this for a moment. It might be __sales__ people, ​who have information about recurring potential customer requests, but it also might be __customer support__, which could identify some problems in the workflow or user experience, or hidden features disguised as bug reports.

It might be some ​__marketing__ person, ​analyzing help docs or blog posts, that might touch the topic, that customers need solving. But it also might be a ​__product__ person,​ that has collected data and is always talking to customers. It might also be a __​developer__ that would write some queries to detect how a specific feature is used. It could be a __​QA__ person,​ but it also could be someone from ​__UX__,​ some ​__designer__,​ literally anyone might be able to provide some insights.

_But how do we approach it commonly?_

We mostly have a specific role that identifies features, that writes down these features and that prioritizes these features. So the information is mostly tied to a specific role. That role should ​__ensure that the right things are built__ and that everyone understands what is needed to be done, so that the feature can be rolled out to the customer. So a shared understanding now might be tied to that specific role, and the _quality_ of that understanding varies on how well communicated this is, be it in person or via an artifact.


_But what if thought about this from a different perspective?_

What if the team consists of a diverse range of people with varying expertise?
Obviously there is a thing called _[„​cross-functional“](https://en.wikipedia.org/wiki/Cross-functional_team)_​ teams, or [t-shaped](https://en.wikipedia.org/wiki/T-shaped_skills) professionals, but let’s not focus on this too much for a minute. Let’s think about how a team could create a shared understanding and collaborate based on that understanding to come up with a solution, that might solve the problem more effectively. Instead of having a fixed meeting once per iteration, there might be an ongoing discussion and iterating on the problem. Before jumping into the first solution, there might be room for iterating on possible options, on asking further questions and coming up with a better solution.

A team could consist of anyone, that might be ​_able to contribute to the problem and solution_ or​ a specified domain or the _​work to be done_.​ The _​earlier_ everyone is involved in the process, the _​earlier_​ a shared understanding can be manifested.
But let’s map back to the original customer problem. The customer is not really interested in how the solution is sourced, how the process is organized, if we use story points or write stories in general. What the customer is interested in, is __having the problem solved__.


Keeping this in mind, we can see that there are some opportunities that come with creating a shared knowledge within a team. A team dialog could create more effective solutions, which could lead to __less ​silos__ and hand-offs.

_Synchronization is underestimated_​. If the knowledge is spread all over the place, it would require continuous synchronization, to leverage the collective knowledge and skill, furthermore, there might be a lack of context, once knowledge is passed down from one individual to the next. As the context keeps changing, there is a continuous need to translate the context to everyone involved. A side-effect is mostly needing more and more meetings to keep everything synchronized.

So what if we identified the problem and are able to quantify the impact, but also include quality aspects into our thinking from a product perspective? What if we are able to build a team of diverse people that can ask customers questions, that can collaborate with the customer, invite the customer to sessions and so forth? 

_What if we​ didn’t care about roles and more about who can contribute to the solution?_

Seeing it from this perspective could mean the following: a strong focus on the complete line of work needed, from exploration to delivery and maintenance. This also means making the ​__complete process transparent__,​ including where does an _idea_ come from, why is it moved to ​_exploration_ phase, how is the decision behind making this a worthwhile investment to implement it, what are the _​metrics_ for _validating_ that this feature is actually useful and adding value. It would require
shifting from hand-offs to collectively understanding the problem and working from there.

At the end we’re building things to solve problems, not to show some reports or charts based on isolated metrics that have nothing to do with actual customers.

This requires a different way of thinking about the work, it would require moving from focusing on strict workflows to focusing on the work that actually needs to be done. It would require to ask the right questions: _„​What benefit does this meeting have?“_​, _„​Who can contribute?“_ or _„​What are the metrics for the decision process?“_. 

​If we can map back everything to actual customers, we can ask _„How does this make the customer’s life easier or simpler or better?“_

It would also enable us to value learning. One constant goal might be to learn more with every exploration. Learn more about our customers, learn about how to identify better ways of solving problems.

If anything, we should try to improve shared understanding. Make the information transparent, enable everyone to contribute in a sensible manner and leverage the collective group knowledge for continuous improvement.

---

If you have any questions or feedback please leave a comment here or connect via Twitter: [A. Sharif](https://twitter.com/sharifsbeat)