This chapter is from the book
This chapter is from the book
This chapter is from the book
Team Building
A large team is hardly manageable as a whole. Thus, in order to establish a flexible team, the team is usually divided into subteams of no more than ten members.
The typical structure used by large teams (and in large companies) is still based on Taylor’s theory of building teams according to their knowledge, as I mentioned earlier. Therefore, you will often find an analysis team, a design team, a test team, and so on. The developers are typically further subgrouped into smaller sub-teams, each responsible for a specific function like presentation, database, network services, and the like. This Tayloristic split is also known as horizontal team division. Taylorism works quite well for jobs that are repeatable. It doesn’t work as well if a lot of creative and holistic thinking is required. You can furthermore consider defining vertical teams, which are focused around business functionality. These teams are also known as domain or feature teams, as Peter Coad terms them in the Feature Driven Development process. On the other hand, if you are dividing the team vertically, you might find that not every team has all the necessary skills, or even worse, that every team might start to address the same problems.
Therefore, do not make this an either-or decision, but an as-well-as one. For example, if you start with a small team and build slowly, you will come to the conclusion that on future projects, your starting team should be staffed with people who have good domain knowledge and a major technical background. This starting team most often defines the first architecture and verifies that the system can actually be built. Furthermore, it can serve as a model for the formation of the other teams. The horizontal and more technically focused teams should then support these new (vertical) subteams.
Building Teams and Subteams
As mentioned earlier, dividing the whole team into several sub-teams should not be a decision between vertical or horizontal divisions. Instead, it should be an as-well-as decision, to provide a better mix of knowledge in the teams.
Either virtual or real technical service teams could be installed to further support those vertical, domain teams.7 For example, on one of my projects, we defined domain teams focusing on a specific domain area in banking, with one team focusing on accounting and another one on customer management. Each team had the knowledge needed to implement the features belonging to its domain, including the graphical user interface, the connection to the host, the business logic, and all the other required technology. If, for instance, the accounting team required some functionality from the customer management team in order to implement a feature, the accounting team would just bilaterally discuss the requirements with the customer management team. The customer management team then in turn would provide the required service within the development cycle.
)
We established in this case real (not virtual) technical service teams that were responsible for supporting the domain teams by providing some base functionality. For example, we assembled an architecture team responsible for the business logic, and a presentation team for all graphical user interface aspects. Those technical service teams were requested to visit all the domain teams regularly. On request, members of a technical service team supported domain teams as regular team members for a specific amount of time.
Technical service teams should always regard themselves as pure service providers for the domain teams. For instance, the technical service team responsible for building and supporting the architecture should always shape the architecture according to the requests of the domain teams, not vice versa, since the domain teams have to use whatever the architecture team creates, as is often the case.
Depending on the actual size of your team, you will establish either virtual technical service teams or real technical service teams. The members of the virtual teams are usually regular members of domain teams. In contrast, members of real teams usually lack a close connection to the domain teams. For this reason, you have to ensure that real teams do not develop the best architecture, but the most adequate. You have to avoid features that are implemented just because somebody believes they are needed. Technical teams have to think of themselves as service teams, delivering services to their customers, the domain teams. The big advantage of this strategy is that the architecture only contains what is required. This makes the architecture much easier to maintain and, as a side effect, cheaper. Additionally, it eliminates the oft-occurring social discrepancies between the technical and domain teams. One often gets the impression that those teams are working on different projects (not least from the way they talk about one another). Unfortunately, this impression is seldom wrong, and those teams have different objectives. Where technical teams’ objective is to make use of a specific technology and develop perfect frameworks not requested by the domain teams, the domain teams’ goal is to implement the domain, not caring if they can profit and learn from one another (or from the frameworks the technical teams provide).
But how do the technical service teams know which service is required and, more importantly, which requested service has the highest priority? The team has to come up with a strategy. Not every requirement from each and every domain team will be implemented, because certain requirements might contradict each other. Or, worse, implementing these requirements will cost so many resources that other teams will not be able to get their (more important) requirements done.
Therefore, like real customers, the domain teams have to speak with one voice. Retrospectives can serve as a forum for deciding on new or changed requirements since all teams are present (or at least represented) and the focus of the retrospective is the project’s status and progress, anyway.8 If one team states that it cannot proceed because it needs some special technical service, all teams can decide jointly if this is a requirement they support; if approved, the service will be a joint requirement for the technical service team. Otherwise, the requesting domain team has to implement the service on its own. These requirements are then scheduled in the same way the domain teams schedule their requirements. Thus, the technical service team schedules requirements with the highest priority first and does not schedule more than it can accomplish within the next development cycle. It might have to negotiate workload with the domain teams. At the beginning of the project, especially, the domain teams define many requirements for the technical service team, but at other times, there may be few requests, if, for example, the architecture can just be used as is. During “high season,” you should ensure that the technical service team does not accept more work than it can accomplish. During “low season,” you should ask the members of the technical service team to join the domain teams instead of implementing unnecessary additional features.
Requirements Channels, by Stefan Roock
In this project, we had to implement a system supporting multiple channels for different user groups, with various front-end technologies (desktop, Web, laptop). Our starting project team consisted of five people from the development company and two consultants. With seven people, it was a size typical for an agile project. We had all the Extreme Programming practices in place when the project had to scale up and accept additional manpower—mainly developers. The goal was to have about twenty-five people in the project.
When scaling up, we had to address the issue of project structure. It became clear that it would not be possible to integrate all these people in one large team in the project. Therefore, we decided to split the project up into teams. But, we asked ourselves, what are the criteria for the division of teams? Do we use the architecture as the structuring mechanism and assign each subsystem to a team? Or do we assign each requirements channel to a team? In the first case, each requirements channel had to talk with every team. In the second case, each team had to modify classes all over the system. Since the planning games seemed to be too complex in the former, we chose the latter.9
)
)
We then got three teams for the three requirements channels, and a technology support team. The teams were rather small (four people), which supported taking over responsibility.
One thing we learned was that reorganizing teams takes more time than we thought. When we changed the organizational structure, the developers needed several weeks to get used to the new structure and get up to their development speed again.
Because teams were not assigned to subsystems, every developer was able to modify every part of the system. This was no problem because the developers were able to master the code base (about twelve-hundred classes).
As time went by, additional developers joined the project and the code base grew. We ended up with about thirty developers with different programming skills. Now some developers weren’t able to modify every part of the system without it breaking. Our first step was to tag core classes and the very complicated parts of the system as “expert code,” which had to be modified by a so-called system expert.
That solved the problem, but it didn’t seem to be a very smart solution since there was no way to guarantee that only system experts modify the crucial part of the system.
Currently, we are searching for better mechanisms for assigning code to teams. The main idea is to take the layering of subsystems into account. Some subsystems are specifically for a requirements channel and should be assigned to the relevant team. Other subsystems are relevant to several user groups and can’t be assigned to one of the existing teams. These subsystems are assigned to a virtual “base subsystem” team, which is created on demand from the system experts sitting in the existing teams.
Team Roles
The idea is that a team must have members that possess all the required knowledge. In that sense, each team is a generalist in its domain. For instance, a domain team will be assembled by domain experts, graphical user interface developers, and database developers. But although the team consists of these different experts, those experts will not work solely in their field of speciality. Instead, the team members must take different roles. For example, it is rather typical for the database developer to learn from the graphical user interface specialist how to build the presentation, and to then contribute to the user interface development. Thus, the goal of having generalists rather than specialists on a team is attainable by spreading the available knowledge.
The goal of this approach is not egalitarianism of all team members. Distinct skills and experiences are still necessary for specific tasks. However, the goal is to avoid the general tendency toward thought monopolies and to spread knowledge and skills.
Additionally, each agile team also possesses the required administrative knowledge necessary to perform, for example, integration and configuration management. The person who takes this role concentrates mainly on issues based on internal team integration and configuration, but will also be this function’s contact person for people external to the team. However, individual team members may have multiple roles: For instance, the person responsible for integration and configuration may be the domain expert, too.
It is very helpful to establish a team lead for every team. This person acts as a contact person for the whole team. Often, the team lead coordinates who will attend a specific meeting, such as a retrospective.
Team Jelling
Ideally, the whole project team pulls together, all team members communicate honestly and openly, and everybody has the same big picture in mind. As Tom DeMarco puts it, the team jells.10 The pulling together must especially be supported so it becomes natural. In addition to the more formal aspects of project development, other, more enjoyable and motivational, tactics must be employed to keep your project on track:
- Food: If you provide food, or just snacks—healthy or otherwise—the area where you place the food will soon become an extremely popular part of the office. And when groups of people are there, taking advantage of the free food, they will start talking. You might also want to make use of team lunches, although you should ensure that lunch time is also a break time that allows the team members to relax and recover from their work. On the other hand, breaking bread together always helps people get closer to one another.
- Party: Organize a party once in a while—after the delivery of a major release, for example. This does not have to be something big. It would be enough to serve some sandwiches and beverages for a couple of hours or so. This will help people who wouldn’t otherwise have the chance to sit and talk to each other. Try to convince the company of the importance of such project parties, so it will approve them.
- Recreation: Organize some sort of recreational outing. It can be a sporting event, such as a volleyball match, or some other social event, such as bowling, go-cart racing, or something along those lines. Doing something as a group will help team members get to know each other, especially when people are asked to team up with someone they do not work with regularly. This will hopefully reinforce respect and acceptance among all. Ensure that everybody can participate in the event, taking into account team members’ disabilities, for example.
- Project identity: Encourage the team members to cultivate a sense of project identity. Authors Mary Lynn Manns and Linda Rising stress the importance of having a group identity in Fear Less: Patterns for Introducing New Ideas into Organizations. They recommend a separate pattern, called Group Identity.1111 Special T-shirts, project-specific food and beverages, or even project-specific phrases and slogans help to develop a project culture. On one project, we even came up with a project cocktail. However, the project should not alienate itself from the outside; the group identity should help newcomers to identify themselves with the project.
Regeneration: Ensure that project members have time to regenerate. Even when people are under pressure to deliver, make sure that they take their vacations and are not working overtime. A project is comparable to a marathon, not to a sprint.
- Communication of results: You cannot overestimate how motivational it is for teams to have reports on the growth of the system or the customer’s feedback. Therefore, make sure everybody knows about the project’s progress.
)
All the strategies suggested (just a sample of the possibilities) rein-force communication and will ensure that your team members will get to know each other better and, more importantly, learn to respect one another. Try to ensure that members from different subteams interact with each other. For example, if you organize a sporting activity, you can request that each side contain no more than two people from the same subteam. It is astonishing how much this contributes to a sense of communal identity among team members, and this usually results in projects that run more smoothly.
Some strategies are not readily implemented in certain companies. For instance, organizing a party that needs temporal and financial support could be a problem. This is a sure sign that the importance of communication is still underestimated. You will need to convince the organization otherwise. It is worth the effort.