Agile Product Manager in the Enterprise (3): Responsibility-Owning the Vision
Join the DZone community and get the full member experience.Join For Free
note: this is the third in a series of posts on the changing role of product management as the enterprise transitions to agile development methods. this series in turn, is a continuation of the series on the role of product manager and product owner in the agile enterprise which can be found in the product manager/product owner series on this blog as well as a series in the agile journal. (see the resource page for a mapping to the agile journal article series).
in the last post, agile product manger in the enterprise (2): a contemporary framework , i described a framework for product management and a separation of roles for the agile product owner and agile product manager on the enterprise context. i concluded with a suggested set of agile-specific responsibilities that are different than the activities in a pre-agile world. to reiterate: they are:
1. own the vision and release backlog
2. manage release content
3. maintain the product roadmap
4. build an effective product manager/product owner team
in this post, i’ll describe the specifics of responsibility 1: owning the vision and release backlog.
owning the vision and release backlog
the agile vision
though the instantiation and delivery models for the vision (vision/roadmap/feature set vs. product requirements document) are different, this responsibility is not new to the role. after all, if the product manager:
- has a continuous, in-depth understanding of the current solution
- stays abreast of the latest industry trends
- understands the changing needs of the market and the customer base
- articulates a clear direction for addressing gaps and opportunities
then having a vision , which articulates a clear direction for addressing gaps and opportunities, is a logical outcome.
communicating the vision
as we have noted, in agile the traditional product requirements documents (prd), system specification, software requirements specifications (srs) and the like are typically eliminated . in their place, agile enterprises take a leaner approach better suited to the last-responsible-moment, delayed decision making and artifact-light development practices of the agile enterprise.
however, since the prd and srs documents no longer exist to specify system behavior, communicating the vision to the agile development teams becomes even more critical . doing so is product management’s responsibility, because no matter how empowered and energized the agile teams may have become, it is pm’s responsibility to set strategic direction. the vision answers the big questions for the system , application or product under development, including
- where are we headed with this thing?
- what problem does it solve?
- what features and benefits does it provide?
- for whom does it provide it?
- what performance, reliability, etc. does it deliver?
- what platforms, standards, applications, etc. will it support?
an agile vision can take many forms
i’ve seen agile teams take a variety of approaches to communicating the vision. (note: i covered many of these in more detail in chapter 17 of ssa - lean requirements at scale: vision, roadmap and just-in-time elaboration ).these include:
- draft press release – highlighting the new features and benefits of the solution
- a “ very preliminary data sheet ” which accomplishes the same thing in a concise form
- jim highsmith’s “ product vision box “ which uses the product packaging box metaphor to capture similar elements
- rup-like vision document which is a standardized template which defines users, features, system qualities and the like. (one very agile team once told me, somewhat defensively, about why they still loved their rup-derived vision template: “we write to make sure management understands what we are about to build”)
it doesn’t even have to be that structured
each of these forms has proven their worth in a variety of agile projects, but it doesn’t even have to be that well structured. in one release planning session i facilitated, there wasn’t an opportunity for the four product mangers to collaborate prior to the release planning session. even if there were, it’s doubtful that they could have necessarily come up with a harmonized, force-ranked feature set anyway. (question: what self-respecting product manager wanted their number one feature to be placed fourth on the release backlog?) instead, we allowed each product manager approximately 45 minutes on stage. each presented a briefing deck, including a list with descriptions of the top ten new features proposed for their solution component. based on this context, the teams then went into the more detailed planning session.
clearly, this was not the ideal forced-rank prioritization we like to see in agile and it was left up to the teams to decide what to do about the fact that four product managers had separate priorities. but software, like life, can be a little messy. most importantly, this model seemed to work really well, in part because the product managers were part of the process and by the end of the session they had visibility into what the teams could and could not achieve in the time box.
the primary content of the vision is a set of features
no matter the form, the main content of the vision document is a prioritized set of features . in my earlier book managing software requirements , (perhaps attaining agile wisdom means we don’t have to throw out everything we learned prior) we described features as “services provided by the system that fulfill a user need”. features are “big picture” system behaviors that can be described in a sentence or two and which are written so that customers can actually understand, debate and prioritize them.
of course, in so doing we didn’t invent either the word “feature” or the usage of the word in that text. rather, we simply fell back on industry standard norms to describe products in terms of, for example, a features and benefits matrix which has been used traditionally by product marketing to describe the capabilities and benefits provided by our new system. by applying this familiar construct in agile, we also bridge the language gap from the agile project team/product owner to the system/program/product manager level and give those who operate outside our agile teams a traditional label ( feature ) to use to do their traditional work (i.e. describe the thing they’d like us to build).
in that text, i also posited that by managing the level of abstraction, a system of arbitrary complexity (from the space shuttle to the spellchecker on this soso editor) can be described in a list of 25 or so features. that still works for agile teams describing a vision today and features can still be used as the primary placeholder for user value.
undelivered features fill the release backlog
in the big picture graphic and series and in the product owner blog posts, we noted the primary currency of requirements expressions for the agile teams is the user story, which are contained in the iteration (story) backlog . (see graphic)
in a like manner, the release backlog contains the prioritized set of features that have not yet been implemented.
like stories, features can be scheduled (in a release) or unscheduled (waiting for future attention). they are prioritized and estimated. estimates at this scale are coarse grained and imprecise, which prevents any temptation to over-invest in feature elaboration and estimating. if and when a feature reaches a priority such that it hits a release planning boundary, it will be broken into user stories prior to implementation.
the vision must include any critical non-functional requirements
in addition, the enterprise is too large to assume that all the global development teams will naturally understand the various system qualities, i.e. those constraints and “ilities”, such as reliability, accuracy, performance, quality, etc, that are imposed on the system as a whole. therefore, these non-functional requirements must also be known and communicated via a central repository where all teams can readily access them. ( click here for more on non-functional requirements ).
these requirements are an adjunct to the vision and feature backlog and are every bit as critical as the functional requirements. as such, product managers have a major role in defining them. your enterprise development practices may now be more lightweight and agile, but the system still has to work when you ship it!
that’s it for the first responsibility: owning the vision and release backlog. we’ll move on to responsibility 2: managing release content, in the next post.
Published at DZone with permission of Dean Leffingwell. See the original article here.
Opinions expressed by DZone contributors are their own.