Planning Poker And Other Consensus-Based Estimation Methods

What is Planning Poker?

Planning poker is a consensus-based technique for estimating user stories in agile software development. It involves a moderator, customers, and developers estimating story points or effort values for stories through discussion and multiple voting rounds using a deck of cards with values representing estimates.

Planning poker originated at Neoteric in the early 2000s as a way to accurately estimate projects in an agile environment. Traditional estimation approaches based solely on individual viewpoints were not working well, so a collaborative group estimation approach was devised. This method aimed to leverage the wisdom of the entire team through debate and consensus.

In a planning poker session, the moderator presents a user story to the estimators. Each estimator privately selects an estimate card representing their initial assessment. All cards are then revealed simultaneously and estimates are discussed amongst the group. The high and low estimators explain their rationale and after discussion, another voting round occurs. This process repeats until consensus is reached on the estimate.

Key Benefits of Planning Poker

There are several key reasons why planning poker is favored over individual estimation techniques:

• Promotes increased discussion and reaches group consensus – Rather than just averaging estimates, the dialogue helps assess technical and market risks to arrive at a shared estimate.
• Accounts for unknowns and reduces anchoring bias – Discussion brings out information that individuals did not consider, resulting in better assessment.
• Easy to adopt, flexible, and engages team members – The card deck and estimation scale can be easily tailored if needed.

Running an Effective Planning Poker Session

Conducting an efficient planning poker session requires some preparation and structure:

Selecting the Stories: The product owner and lead developers pick the priority stories and decomposition level for the session based on goals.

Determining Participants: Include a facilitator, product owner, architects, and developers actively working on the stories to leverage multiple viewpoints.

Appointing a Moderator: An experienced facilitator drives conversations toward consensus and keeps the session on track.

Agreeing on a Scale: Typical scales are T-shirt sizes (S, M, L), the Fibonacci sequence, or powers of 2. Select a scheme all participants are comfortable with.

Estimation Rounds: For each story, have estimators reveal cards simultaneously. Discuss high and low estimates before re-voting. Repeat until consensus.

Dealing with Disagreements in Estimates

Variations in estimates are common since information is interpreted differently. However, large disagreements should be discussed and resolved. Useful strategies include:

• Analyzing underlying assumptions and risks – Uncover gaps for stories with ambiguous details.
• Avoiding overconfidence and hiplining biases – Consider unknown factors regardless of experience.
• Re-assessing complexity – Breakdown stories into smaller ones if complexity is unclear.

By surfacing information gaps and clarifying details, re-estimation brings participants closer to agreement.

Planning Poker Variations

While the standard approach works for collocated teams, modifications help in some situations:

Distributed Teams: Remote participants reveal estimates using online cards or video conference screen sharing.

Additional Data Points: Some teams supplement story points with defect counts, business value ratings, or risk assessments.

Custom Scales: Rather than abstract story points, scales based on ideal hours or numerical complexity scores can be used.

Example Code Snippets for Planning Poker Apps

Apps that enable online planning poker provide helpful automation. Example snippets from implementation languages are shown below:

[Python] Setting up Deck and Cards Module

import random 

class Deck:
    def __init__(self):
        self.cards = []
        self.build()

    def build(self):
        for value in [0, 1, 2, 3, 5, 8, 13, 20, 40, 100]:
            self.cards.append(Card(value))
    
    def shuffle(self):
       random.shuffle(self.cards)
    
    def deal_card(self):
       return self.cards.pop() 

class Card:
    def __init__(self, value):
        self.value = value

[JavaScript] Shuffling and Dealing Cards Interface

function shuffleAndDeal() {

  deck.shuffle(); 

  players.forEach(player => {
    const card = deck.dealCard(); 
    player.addCardToHand(card);
  });

  showHands();

}

[Java] Managing Rounds and Participant Votes

class PokerRound {

   List players;
   PokerCard selectedCards[];

   void startNewRound() {
      collectVotes();
      showVotes();
      discuss();
      if(consensusReached()) {
         endRound();
      } else {
        startNewRound();  
      }
   }   

   boolean consensusReached() {
    // determine if votes are within threshold
   }

}