Who designed this stuff, anyway?
Many development organizations have an “architect” role, meant to provide technical direction over an entire engineering process [As far as I can tell, “architect” really seems to be shorthand for “someone with deep and broad technical understanding and experience”]. How does this mesh with scrum-based, grass-roots development by empowered teams? Or perhaps, the real question is: if I have folks that would traditionally fill an architect role, what’s the best way to utilize them in a scrum setting?
Three areas in which these folks tend to contribute are (although this list is certainly not exhaustive):
- R&D: advanced prototyping/proof-of-concept work
- Due Diligence: evaluation of emerging technology
- Design: participating in system and/or software architecture and design
Let’s take each of these areas in turn.
Here the notion is to invest some amount of exploratory effort to remove technical risk from a product or feature–to the point where the feasibility of an approach can be established and an associated rough LOE (level of effort) can be given for a real implementation using this approach. We typically hand this type of task off to an architect, hoping his/her broad technical background can help provide hints/leads to navigating the solution space, and thus reduce maximum uncertainty with a minimum of effort (bang for the buck!).
Depending upon the nature of the problem at hand, and/or the structure of the available scrum teams, there are two readily apparent approaches:
run an R&D scrum team; this makes sense when there are sufficient architects around to form a team of them, and when the explorations are not directly tied to an existing product (e.g. technical feasibility for a new product)
embed your architects on the scrum teams themselves: this makes sense when your architects are more scarce (because it will be beneficial to have them on the teams for the other reasons we’ll mention below), but also when the explorations are directly related to an existing product. In this case, the rest of the scrum team they are on will benefit directly from (and help participate in) the exploration–this learning process will make a later production implementation easier, and will furthermore help teach the other team members how to do this type of work. This is vitally important if we are short on architects and good ones are hard to hire–then we need to view these other folks not as “non-architects” but rather as “architects-to-be.” This model is also easy to follow if you are already using the idea of prototyping sprints.
Technical Due Diligence.
Here, again, we are counting on our architect’s experience to enable a thorough and accurate assessment of some technology. If there is already an “architecture scrum” running as described above, this might be a natural place to fit these efforts. However, in the absence of a dedicated group, it may fall on an architect that is embedded on a scrum team (ideally one working on a product that might be impacted by the technology in question), which would also be perfectly fine.
Architects’ experience helps most during design exercises–knowing what kind of pitfalls to look for, what kind of generality to build in, and what kind of approaches/patterns are available and relevant. Design is also an area where collaboration is both possible and usually helpful (at least up to the amount of people that can fit comfortably around a whiteboard!). So, no doubt–we want our architects participating here in order to get good designs up front and hopefully minimize refactoring later.
Again, I am going to argue for the embedded approach here, as opposed to running an architecture scrum that spits out designs. I think the benefits here are overwhelming:
by generating designs as they are needed for feature development, effort will not be spent building in generality that may never be exercised
by having the scrum team participate in the design, those familiar with the details of the existing system will have input, ensuring the design is complete
by having the team participate, they will learn to become better designers themselves (again, a key benefit if there are not enough architects to go around–and there probably won’t ever be, by the way–as the architecture will have to live and grow regardless of whether an architect is available to design it all).
Well, I seem to have convinced myself, anyway, that the right thing to do with your architects is to just put them on your scrum teams and let them have at it (Ken Schwaber would be so proud!). In other words, don’t treat them any differently than you would any other engineer in your development organization (indeed, in our current organization, we have “architects” that do production development, and “engineers” that do software architecture, so we’re probably not far from this anyway). The main benefits of this approach are:
relevance - by staying grounded in the day-to-day realities of creating products, our architects will be focused on real needs
integration - by having architecture activities happen in the context of normal scrums, those activities will have a high likelihood of impacting production code
collaboration - as a team member, there are no artificial barriers to communication, no “us” and “them” mentality between architecture and engineering
resourcing - architects can leverage their teammates to provide extra horsepower towards architecture tasks
learning - by having scrum teams responsible for architecture tasks, experienced team members will teach less experienced teammates how to accomplish architecture-related tasks