Category Archives: Agile Software Development

What If Your Scrum Team Was Funding You?

(This one’s addressed at Product Owners or anyone who is from the “business side” of a company. Not the “business end”; that’s something else.)

money growing in soil

Convince your team like you’d convince an investor and you’re onto something.

Teams Will Build What You Ask … Useful or Not

When I think of what I love about Agile and Scrum, I think: self-organizing teams, empowerment, creativity, customer collaboration (over contract negotiation!), no titles for development team members, exploration, experimentation, ownership … all things that assert or strongly imply that the development team is the beating heart of the whole enterprise, and that the rest of us exist to support them and enable them to build great things to delight existing customers and attract new ones. But the team is busy building things, and there are business-minded folks who spend more of their day thinking about what to build next and why, so even with the best of intentions many companies start to slip into a pattern like this:

The execs set the goals … then the sales, marketing and product teams meet a lot and decide what to build at a high level … then the product owner and business analysts meet a lot and decide what to build at a detailed level and in what order … then we tell the development team what to do.

But we know we should empower the teams, so we give them some business context during planning or grooming, or occasionally do “innovation time” or let developers tag along to user feedback sessions.

Which is great. But.

If you give the team useless features to build, they are going to build them just like they’d build amazing useful fantastic great features if you’d thought of those instead. They are going to negotiate scope during sprint planning and then Commit and gosh darn it, they will burn those 35 story points of useless crap down to Zero with Zero Defects and every Acceptance Criterion will be checked off. They might not enjoy it, but you’re paying them a lot of money and they all went through grueling technical education and they are predisposed to write code and write it well. But guess what? They probably have ideas about what you should build, and questions that go beyond story grooming, but unless you have a phenomenally open work culture and great communication (good for you!) then those ideas may not be getting enough sunlight and so you’re missing out, and so are your customers.

Let’s Pretend

So let’s pretend for a moment that the development team has all the money. One developer won the lottery, another comes from old money, and the QA lead has reaped the benefits of 3 straight IPOs. But for some reason they all keep working and they’re funding your company. I know, it makes no sense … suspend that disbelief like when you watch those superhero franchise movies.

Everything else is the same as the real world. The Product Owner ranks the backlog and brings the stories to the team to size and refine, and then the team commits to the most important work. Except now when you introduce a new feature to the team, you have to start by convincing them to pay for it:

You: “So, we need to integrate with Yawp’s restaurant review platform.”
Developer: “Interesting feature, Bob. Tell me why I should spend my valuable time and money building this.”
You: “Well, we have a partnership with them and …”
Developer: “But won’t people just go directly to Yawp instead of going through our app?” (glances at smartphone)
You: “We don’t think they will … I really …”
Developer: “Do you have any data to support this hypothesis?” (looks distracted, grins at tester)
You: (flustered) “Well I could get something together.”
Developer: “Great, get back to me when you have something.”

and … scene. Ouch. Truly the darkest timeline.

But Seriously

If you were able to sell – I mean really sell – your feature to the development team, how committed do you think they’d be? Would they put in that extra effort to get over the line? Sure they would. How likely would they be to just deliver you something “pretty good” that is technically correct but just doesn’t wow you? Not very, right? After all, it’s their money riding on the outcome.

And what do you think they’d do if they had a different idea, maybe even a better idea? You know that one: They’d be sure to tell you and you’d listen! If you have money, people listen whether the ideas are good or not 🙂


Well, we’re back in the real world. Phew! Shake it off, Taylor Swift, it wasn’t that bad. No one is really going to force you to sell the team on the value of your features. But you really should, shouldn’t you?

bored developers

If your team isn’t sold on the value of the work, it’s your job to convince them.

It’s The System, Maaaan!

Battleship Control Room

Do the modes of control in your workplace encourage dysfunctional team behaviors?

For those of you working with Agile development teams, here’s a question:  Are the behavior patterns you see in your teams because of the personalities of the team members, or because of the structures the team is operating within?  Think carefully …



Out Of The Mouths Of Babes

Recently I was driving my 4th grade son home from school when we were blocked by an accident in my neighborhood. Our streets are very narrow and people park on the street instead of in their driveways for some reason, so you have to be careful passing traffic going the other way. This particular day, a school bus and a car going around a curve in opposite directions had sideswiped each other and were totally blocking the street while waiting for the police. No one appeared to be hurt, so we turned around to make a 2 mile detour to get to my house the back way.

During the drive, I said to my son, “Wow, I hope no one’s hurt.” Then I asked him, “So … I wonder whose fault it was?” I was thinking about the bus driver and the car driver, but he immediately said, “Whoever designed the road. It’s way too narrow.”

Hmm … good point. Maybe both drivers were doing their best, and the system constraints set them up for failure. Can we relate this back to Agile teams in some way?

A Bit More About Why People Do Stuff

Around the same time this happened, I listened to an episode of the excellent Invisibilia podcast called The Personality Myth (synopsis here). I was already thinking about systems inducing behavior in people, but this discussion went even further to talk about whether people even really have consistent personalities! That is, if you think about people you know, maybe they only seem consistent because you encounter them repeatedly in more or less the same situations: at work every day, as your spouse at home, as a friend you play tennis with, or whatever. You’ve probably had the experience of seeing someone you thought you knew in a new and unexpected way. One person can be a quiet software tester at work, a community leader, music teacher, protester, party animal … or someone might seem stable but change dramatically under financial, work, or social pressure.

The discussion about this in psychology is called the Person-situation debate (Wikipedia):

The person–situation debate in personality psychology refers to the controversy concerning whether the person or the situation is more influential in determining a person’s behavior. Personality trait psychologists believe that people have consistent personalities that guide their behaviors across situations. Situationists, opponents of the trait approach, argue that people are not consistent enough from situation to situation to be characterized by broad personality traits.

The podcast talks in part about a hardened criminal who becomes an expressive ballet dancer when exposed to a new set of expectations. So surely we should be able to change our Agile environments and get different results out of our teams, right?

Refine Your Agile Experiment

Agile asks us to continuously inspect and adapt not just the product we’re building, but also the process itself. Teams do this via holding retrospectives and acting on “things to try”, but often they are more focused on technical or mechanical changes rather than influencing behaviors. They may also stay away from certain topics because they perceive them as sensitive or otherwise off limits. Guess who gets to worry about those things? You do! Here are just a few things that can significantly affect how teams behave:

Measuring teams against each other. It’s really tempting to look at story points or actual hours and use those to compare teams. Don’t do this. Story points normalize over time for individual teams, but not across teams unless there’s a lot of cross-pollination of members and ideas. And teams’ “actual hours” are often … er … highly creative retroactive estimates. As soon as teams think you’re gauging them like this, they will start overestimating everything to protect themselves. Instead, look at the big picture. Is each team delivering obvious business value? Do they always burn down 100% of their committed stories? How do their features look? Do they generate lots of production bugs or later rework?

Measuring individuals instead of teams. If you want your teams to jealously guard information and little architectural fiefdoms, and point fingers when things go wrong, the best way is to measure each person on a team as an island unto themselves. If instead you want your teams to hold each other accountable and work together to get things done despite individual hurdles, make it clear that success or failure happens at the team level and keep that focus for things like rewards and performance reviews. Obviously there will be occasions where someone just isn’t a good team fit, but more often members of a high-functioning team will actively strive to support each other and fill in skill gaps so that they can deliver more consistently.

Chaotic or inconsistent process. Scrum (and Agile generally) is about rhythm and predictability. Plan, execute, review, repeat. Over and over every couple weeks, forever. Take advantage of that rhythm by doing things the same way you did last time – except of course for things you decide to change as part of your retrospectives. Is your planning day always on Mondays (for example), with opening and closing ceremonies at the same time? Do stand-ups start at 9:30 am in the same spot each time? Is backlog grooming every Wednesday at 4 pm? Do you have a standing invite list for sprint reviews? Are retrospectives done before the next sprint starts? Are you insulating the teams from random production issues somehow, by using a support team or accounting for support time in planning? The answers to all these questions should be “yes”! For everyone on your teams – developers, testers, Scrum Masters, Product Owners – executing on the current sprint should be the number one priority. If it truly is, you should be able to create a reusable template for each iteration and let other non-sprint stuff live in the gaps. If the sprint stuff is what’s living in the gaps, you have a problem.

Lack of solutions from management. Teams get asked to do a lot. I haven’t yet seen a sprint where the Product Owner starts out by asking the team to do 80% of what they did last time. It’s usually a down-to-the-wire negotiation during planning, and the team decides to “go for it”. Then stuff happens – sick days, production issues, technical surprises – and they push through all of these, or try to anyway. But they also need the system to work for them, which means listening to their concerns and acting on them as needed. Did they work too many hours last time? Did we spring a feature on them at the last minute? Are they still fiddling with old work while trying to start on a new goal? Do they have the right development machines and software tools? How about work space issues like chairs, ergonomics and noise level? Nothing’s more demoralizing to a team than knowing what’s wrong and feeling helpless to change it. You’re supposed to be helping build self-directed, empowered teams – so get to it!

Lack of a clear vision. Most people will work harder and smarter if they are part of a compelling story. Product Owners take the wheel here – hmm, will “take the wheel” make sense in 30 years when all cars are self-driving? Anyway … the vision for a team needs to start at a high level and zoom in to the current time and scope:

  • Where is the product going?
  • Where is the product going in the next quarter?
  • Where is the product going in the next release?
  • How does my team fit into the vision for the next release?

Teams need to understand this vision and believe in it. They need to see their work get released and used by actual customers. They need to hear feedback from those customers in some way, the more directly the better. If teams do a competent job but don’t seem to have any fire, and rarely deliver any brilliant insights, it’s a good bet they don’t buy into the vision.

In Closing

I’d like to stress here that I’m not saying that individuals are helpless pawns whose actions are determined solely by environmental factors. We expect professional software teams to succeed in the system of which they’re a part, even as they try to push and pull it into a form that suits them. But as a leader you can have a disproportionate effect on that system and can accelerate positive change. So next time you see unwanted behaviors in your teams, please at least think about whether the problem might not be with the individual players, but with the rules of the game.

Definition of Ready (to be a robot)


Robots are cool, but they don’t get to make important choices.

Most agilists are familiar with Definition of Done (DoD): a team works together with the Product Owner to agree on a set of criteria that they can all point to and say “a story is complete when this list is checked off”. DoD can get pretty elaborate, including automated testing, documentation, bug rates, and so on. Teams don’t always hit their DoD with every story, but it’s a shared goal and reduces debate over what “done” really means. The value of a Definition of Done seems pretty obvious.

Definition of Ready (DoR) is the natural companion to Definition of Done, but it’s used maybe a bit less often. It lists out all the characteristics a story should have before the team accepts it into the sprint. It’s most helpful when teams struggle in their collaboration with Product Owners, business analysts, UX specialists, or other dev-team-adjacent roles. It says, “look, we’re eager to make a firm commitment and get started on this work, but we can’t just wing it. We need good acceptance criteria, and need to have talked about the stories enough to feel like we know what you want and how long it might take. We expect some challenges and surprises, but there’s no reason to be totally unprepared.”

Again, the value of a good Definition of Ready seems apparent. But I recently saw a DoR that looked something like this:

  • Acceptance Criteria detailed enough to be the basis of a test plan.
  • All UI wireframes completed by the UX team.
  • All text content finalized and translated.
  • All input validations detailed and complete.
  • System designs complete and finalized by the architecture group.

… plus all the usual stuff about sizing, review with the Product Owner, and the INVEST story characteristics.  Seems good, right?  I thought so at first too.

So, What’s the Problem?

The team with this Definition of Ready had a few notable characteristics:

  • The Product Owner and adjuncts (BA, UX) struggled to get things ready in time even though they were clearly trying.
  • The team was quick to point to missing DoR items as a reason for problems getting stories done and done well. “Well, the error messages weren’t provided.”
  • There was an over-dependence on design “spike” work prior to the sprint, often by different people.
  • Team members often complained that the work was boring or cookie-cutter and that there was no room for creativity.

What if I paraphrased the team’s DoR like this: “Before we start to work on these stories, we want them to pass through a series of gates – Product Owner, UX team, and architecture team – so that everything is finalized and we can be 100% sure in advance we know exactly what to build”? Hmm, what’s that sound like? Starts with “W”, has “RF” in the middle, and ends with “L” … no, not “Winterfell”. Waterfall!

How Did This Happen?

The team certainly didn’t mean to ask the business to spell out their work for them to that degree. They were reacting to some common problems that spring up in teams, mostly around communication. This team was pretty disconnected from the customer and the product vision, and wasn’t getting involved in any of the brainstorming and back-and-forth debate about features and how they should work. In addition, the organization was under a lot of pressure to deliver a lot in a short time and was reluctant to give the development teams an open license to be creative; instead, people in various named roles were expected to provide 100% of the ideas in their space. Finally, communication during sprints was unreliable because of how busy everyone was with design for the next feature, conferences, customer surveys, meetings, and tons of other stuff.

In this environment, the team had been left in the lurch more than once. Three days left in the sprint, and no one to answer a question. Lots of “we actually meant this; can you squeeze in that change?” Bombshells, curve balls, the works. And despite all this, a real quickness to blame the team any time a sprint didn’t burn down 100%. They went into defensive mode and traded the joy of creativity for the certainty of detailed requirements.

The Fix

There’s no exact right amount of detail to demand before accepting a story into a sprint. We’ve all heard that a story is an invitation to a conversation. That conversation should certainly start before the sprint, in story sessions, backlog grooming, and high-level design white-boarding. But it absolutely must continue into the sprint as the team begins to grapple with the details and has early builds available in test environments. That means that the Product Owner needs to be available throughout the sprint, which is a basic Scrum rule that is often broken to varying degrees. It also means that the team should have more authority over technical decisions and should not need be overly reliant anyone outside the team to give them answers. Remember, an ideal Agile team has the skill set to deliver a feature on their own. They should make a plan to own the work themselves and pull in auxiliary resources as needed instead of waiting to be given a complete instruction manual. If those auxiliary contributors have daily, strong, and open communication with the team, the team can get comfortable with a bit more ambiguity going into a sprint. I feel strongly that this makes for a healthier, happier team that is able to really deliver the spirit of want the business wants, and more often than not surprise and delight the Product Owner with brilliant solutions to the business problems posed to them.

I’m not saying to throw out your Definition of Ready, if you have one. Just don’t let it be a substitute for continuous communication or for trusting your development teams to make some decisions in flight. And teams – don’t write all the creativity out of your job.

Decomposing Product Owners

Despite the title, this has nothing to do with a horde of zombie product owners shuffling through the streets in search of Scrum teams.  I want to talk a bit about how Scrum defines the Product Owner role and how this can differ from real-world product ownership.  Specifically, let’s look at the responsibilities of the Product Owner and think about how organizations might end up handing parts of the role to someone else, and what the effects might be.  Finally, I’ll talk about how we might influence an organization to move towards defining more by-the-book Product Owners, or failing that, how we might ensure that the people who together compose the role are at least working together effectively and presenting a unified face to their teams.

Wait … Who Is The Product Owner?

Several years ago I did some basic Scrum training for new Scrum Masters in an organization.  Scrum was up and running within the team, but I saw some possible dysfunctions, so I structured the training like this:   First, I would explain some role, ceremony, or artifact as I understood it, including the value added by it; then, I’d ask the new SM to compare that definition to what he or she saw within the team.  Was everything A-OK or were there differences?  For any differences, did they represent a conscious choice to improve the process a la the “ha” of “shu-ha-ri”, or were they problems to be solved?

We were chugging along and generating insights until … we got to Product Owner.  I talked a bit and presented a basic list of PO characteristics like this:

  • Owns the product backlog and works daily to refine it
  • Understands the market and where the product is going
  • Provides clarity of purpose to the team: sprint goals, release plans, etc.
  • Is available to the team on a daily basis
  • Respects the team’s focus during sprints

I should note at this point that the organization had classic Product Managers who had received some general Agile and Lean training and had been given the PO role, but retained the original PM title.  In addition, there were business analysts who worked in the backlog and did grooming with the teams, plus a Project Manager overseeing the various teams, functional managers, and a UX lead who had probably the most frequent and detailed contact with users (If you’re in a large company that started waterfall and then went Agile, this may sound familiar).

Anyway, at the end of this brief summary of the Product Owner role I asked a budding Scrum Master, “So, based on this, who would you say is our Product Owner?”

(pause … gears turn)

“Um … I dunno … [names Project Manager]?”

Well that’s not ideal, is it?  We had a couple of PMs who clearly owned the product and prioritization, and teams of developers and testers who were more than a bit fuzzy on how the various business-facing roles work.  As you might imagine, I observed quite a bit of churn around prioritization, requirements, and vision.  And not the good kind of churn: no homemade butter was produced.

All of the people in this story were smart and dedicated and had a pretty good relationship with each other, but somehow the teams were performing less than optimally.  They generally got the requested work done, but the creative spark and exuberant collaboration you’d hope to see in a Scrum team was not quite there.  So let’s look a bit more at how the Product Owner role can be delegated or diluted and what that might mean.

Product Owner vs. Product Manager

A lot has been written on this topic, so I won’t linger too long here, but I like to see Product Owners who operate close to the metal: They’re in the grooming meetings, they know the agile tools (JIRA, Rally, TFS), and they roll up their sleeves to rank a newly found bug against the upcoming stories.  The farther up the pyramid they are in the company, the less time they tend to spend rubbing elbows with the team, and that can lead to a “development versus business” mentality where the development teams feel like “they” pressure us into unreasonable commitments, and the product management organization feels like the team is not fully committed and is disconnected from the business’ needs (probably because they are!).

Just like some teams tend to place the Scrum Master hat on a tech lead, it’s tempting to give the Product Owner title to a relatively high-ranking person.  That’s not really necessary though; the PO just needs to have enough delegated authority to make priority calls as they arise.  Much more important is the physical and/or mental proximity to the team, and the ability and desire to rank work at the story and bug level.

Product Owner vs. Business Analyst

Product Owners have a tough job.  They’re expected to really understand customers and the market, which probably means flying to conferences, sitting in marketing calls and user feedback sessions, and the like.  But they are also supposed to show up for Scrum ceremonies, dig into the minutiae of the backlog, and keep up with the progress of the current sprint.  How is that possible?  I know that when I was a development manager and took on the PO role on top of that I spent at least 2 hours a day, every day typing stories into JIRA, writing acceptance criteria, and creating mockups … all before customer meetings, strategy sessions, and more.  I made myself very approachable to the development team, and they had questions.  Boy did they have a lot of questions.

Given all this, some companies hire business analysts to handle the detail work of breaking features into stories, writing out acceptance criteria, and the like. But the BAs typically don’t have authority to prioritize the work or make calls on functionality.  If they are the ones doing grooming sessions with the teams, that means there’s a lot of “let me get back to you on that” or “I’ll run that by [product owner].”  This doesn’t have to be game-breaking, but it’s a slower feedback loop than direct PO-to-team discussion, so it’s something to watch.

Product Owner vs. True Power

By “true power”, I mean “who really makes the calls?”  Is it the VP of Product Management?  Senior Product Owner?  Someone in the development organization?  Sales?  One of the Product Owner’s key jobs is to manage directional push coming from anywhere inside or outside the organization.  Unless the PO is also the CEO (not likely), that means he or she needs to absorb all those wants and needs and make sure the backlog paints a true picture of what is most likely to be coming up next.  If those with true power are going around the PO and setting other priorities for teams, it creates confusion and disorder.  It’s up to the PO to manage stakeholders and keep that from happening.

Out of Many, One

Let’s finish up by going back to the anecdote of the budding Scrum Master who couldn’t point to a single person who met the criteria of Product Owner.  What could we do to fix this? It might not be feasible to snap your fingers and realign the job responsibilities of the PO, BA, UX, and/or project manager, but small changes can make things a bit more clear.

The Product Owner should articulate the product vision to the team every sprint.  If the PO isn’t available every day, he or she should show up to sprint planning with a compelling story about what the team is building and why.  This shouldn’t take long and provides the purpose the team needs to get energized.

The Product Owner should delegate some authority.  An engaged development team has a constant stream of questions for the Product Owner.  If the PO can’t commit to same-day responses on most questions, he or she can delegate (to a BA or other proxy) to give the team a better contact point.  But this person needs to have some true power to make decisions that won’t get revoked as soon as the PO is back in the office.

The Product Owner should review stories for the current sprint early and often.  I’m assuming here that the PO shows up for planning and the sprint review – if that’s not happening it certainly needs to.  But the sprint review or demo is too late for clarification.  Even a globe-trotting PO should be able to VPN into the test environment from the road and play around with features that are under development, so that small corrections and clarifications can be made in flight.  The team can facilitate this by adding “Product Owner has had the chance to review the work” to the story-level Definition of Done and proactively notifying the PO when stories are up and working.  Note the wording– “has had the chance” means the team offered the work for review, not that the team waits for the review to close the story.  If the PO doesn’t get to it and gets a nasty surprise at the sprint review, well … revisions go in the next sprint.

Present a united face to the development team.  This is the most important.  A PO who has other people helping to guide the work for the team owes the team clarity on how all the roles fit together.  This means frequent repetition of whatever arrangements have been made:  “Hey everyone – I’m going to be at the Business Success Summit next week; I’ve asked Susan to handle any UI questions or priority calls.”  Ideally the PO and friends also appear together at key points.  It might be obvious in the PO’s head, but standing in front of the team along with the business analyst/project manager/whoever and saying “yes, this is the vision; yes, we are all in agreement” can be very powerful.

In Closing

I hope this has been helpful.  I truly believe having a single product owner who ticks all the PO boxes is the best and simplest arrangement, but I realize that in the real world the PO is sometimes decomposed into several individuals.  Think about whether any of the tensions and variations above match your current situation, and what you might do to move things back toward the ideal.  There’s power in realizing that problems exist, and if you can see them, it’s a good bet that others do too and that you can rally together to overcome them.