Agile Prioritization: Which Widget?

Your company is building out a toolkit to support third-party developers.  You’ll need a bunch of different types of widgets – combo-boxes, text entry fields, domain-specific controls, etc.  You’ve got a long list of desired controls from your customers.  You’re agile.  What do you build first?

Agile In A Soundbite

Being agile is about delivering incremental value, quickly, getting feedback, and then delivering more incremental value.  Repeat until “done.”  Good agile adds a qualifier – do the most valuable thing quickly, get feedback, do the most valuable thing (that has not already been done) quickly. Better agile optimizes the rate at which you deliver value by taking into account both benefit and cost.  Great agile overlays a focus on getting better at doing all of these things while you do them – becoming a learning organization.

Boiling the Ocean

A product manager I was coaching was faced with a challenge commonly referred to as boiling the ocean. His team was tasked with solving a market problem, and they were constrained to doing it with a service-oriented architecture that exposed a set of widgets (user interface controls) that customers could easily integrate into their products.  This approach was designed to provide competitive differentiation by reducing the time and cost to deploy solutions that allowed customers to integrate his product into their existing platforms.

In initial conversations with customers, technologists, and architects, this product manager quickly amassed a list of desired widgets (controls) and scenarios (stories) in which they could be used.  The product manager’s team had recently switched to an agile development methodology.  The internal stakeholders, not yet accustomed to agile development, wanted “all of the widgets,” now.

This product manager was able to convince them that the team would deliver the widgets incrementally, following agile principles.

His question was – How do I sequence the widgets in the backlog?

Defining Widget Priority

The product manager had a list of widgets, combo-boxes, data-grids, text fields, radio buttons, etc., and for each widget, he had a real-world scenario showing how the widget could be used.  Most of the scenarios involved customers using multiple widgets.  He wondered if he should do some sort of analysis that detailed the frequency of use of each widget.  “This widget is used in 7 scenarios, so it should be done first; this widget is used in 5 scenarios…”

There was a strong temptation to add several “Create a widget” tasks to his backlog.  It would be easy for his development team to estimate the effort required to deliver each widget.  His team wanted to deliver incrementally, and “one widget at a time” felt like logical, discrete chunks of work to them.  They could easily sink their teeth into estimating, building, and testing each widget.

A quick reminder of a main tenet of agile, delivering incremental value, illuminated the flaw in this approach.  This approach would have been an inside-out prioritization, when value delivery requires an outside-in perspective. (See the ‘recommended reading’ suggestions on this page to check out Kessler and Sweitzer’s great book.)

If the team used this approach, after the first widget was complete, they would be able to deliver exactly 1 task, and 0 stories.  Development teams don’t deliver tasks, however.  The team’s customers would not be able to get incremental value from having a single widget.  The team would have delivered seven incomplete stories – so they would have delivered no stories at all!

We reworked his approach as follows:

  1. Assess a value for each story, making sure that each story would enable his customers to accomplish something valuable.
  2. Engage their user interface / user experience designer to design a solution for the most valuable story.  This design was constrained to use widgets in the user interface.  The suggested way to communicate this design was with a storyboard and low-fidelity wireframes.
  3. Identify the widgets needed to be built to deliver that story, using the designer’s design.
  4. Deliver the story to the development team, including the storyboard, wireframes, and list of widgets to be used as acceptance criteria.
  5. Get the development team to size (estimate) the effort to complete each story.
  6. Where stories were too big (epics), collaborate to identify good ways to break up the stories into manageable chunks.
  7. Repeat steps 2 through 6 until the amount of identified effort was likely to fill the release (keep the dev team busy delivering value).
  8. As the team delivers each story, get feedback from the market, revisit the prioritization, and revise the “next” story.

What we discovered was that a scenario like the following (modified for this article) played out:

  • The first story required two widgets.  As no widgets existed, both had to be built.
  • The second story required three widgets, but two of them had been built to support the first story – only one incremental widget had to be created.
  • The third story used one of the widgets from the first story, but required additional behaviors.  The original widget was modified to provide incremental capabilities (and value).

A Note On Team Structure

Astute readers will notice that there was a design step “inside the requirements process” – before the stories were delivered to the development team.  Technically, that is true, for the way this particular company was organized.  The user experience designer was not a member of the scrum team, but rather, an external consultant who supported multiple teams.  The product manager engaged the designer prior to engaging the development teams.

This just as easily could have happened as follows:

  1. Product manager identifies, values, and prioritizes stories to be added to the backlog.
  2. Development team, as part of sizing the stories, engages their user experience designer to select the appropriate widgets, and those design decisions inform the estimation process.
  3. Everything else is the same.

This procedural variation does not have design “inside the requirements process.”  The same people do the same things, in the same sequence in this scenario.  The only difference is that the interface / interaction designer is a member of the development team.  That would be ideal, but that was not how the company was organized.

In this particular example, having the product manager collaborate with the UX designer made the most sense.  It introduced less complexity for the product manager to accept responsibility for this activity than it would have for the development team (who was still new to using an agile delivery cadence) to do it.


The key ideas at play here:

  • Focus on realizable value to the customer (outside-in development), not tractable tasks (inside-out development).
  • Collaboration with a UX professional is key to driving “interface requirements.”
  • Deliver frequently and valuably, get feedback (learn), and incorporate that knowledge into whatever is next.

17 thoughts on “Agile Prioritization: Which Widget?

  1. Pingback: bishoph
  2. Great post on a simple concept that is often overlooked. Couple additional thoughts:

    One item which I believe is conveyed in you post via the inside out/outside in comment is the basic tenant of writing a story from the users perspective. (As a I want to accomplish ). We find that this continually has to be re-enforced/reminded. It seems to be a natural tendency to slide from outside in perspective to inside out, and then you lose customer focus.

    On UX: In our shop we are very lucky to have a great interactive design team. However in our structure they are outside of the product/development teams so we interact as needed with them similar to an internal consultancy. They helped us create some design standards that we can re-use and engage as new concepts come up that don’t seem to fit the guidelines. However more often – we do simple wireframes (with visio, powerpoint or balsamiq) as needed based on the nature of the user story. Even if they are not optimally designed for the user experience, often they help visually convey complex topics to a development team more quickly than text or words. They also help frame up the problem, so that we can create a more sucinct (smaller) set of Acceptance tests.

    1. Thanks, Kevin (@kevind on Twitter)!

      Great point about continual reinforcement of outside-in versus inside-out. Agree about the tendency to slip. Especially when the internal team has a greater mind-share from the product owner (or product manager) than the external influencers. Easy to get mis-reoriented (or mis-reorientated depending on the flavor of English you speak).

      Good data point re: UX. Another thing that it is difficult to remember – the first design does not have to be the final design. Getting a visualization that enables the story is the first goal. Improving that visualization is something to be prioritized for follow-up. This opens Pandora’s box of “big up-front design” discussions – which I wrote about in Nov 2008, Satisficing Sprints, in the context of providing something that is “good enough.”

      In the first sprint, we propose an interaction design that may be good enough. We quickly get feedback from customers and / or stakeholders. Based on that feedback, we decide if it was good enough. If it wasn’t we decide if closing that gap is more important than the other items on the backlog. If it is, we iterate on the design for that. If it is less important, we tackle another story.

  3. Pingback: Scott Sehlhorst
  4. Pingback: johnpeltier
  5. Pingback: Hugopw
  6. Pingback: Cranky Product Mgr
  7. Pingback: marquinhosarm
  8. Pingback: Barry Latimer
  9. Pingback: Steven Vore
  10. Pingback: Glen Pfeiffer

Leave a Reply

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.