Affinity Estimation in Agile: The Complete Guide to Fast Backlog Sizing

Your Product Backlog has 150 items. Your Sprint Planning session is in two days. And nobody has any idea how big most of this work is. Sound familiar? This is exactly the problem Affinity Estimation solves. It's a silent, collaborative technique that lets your team size an entire backlog in under an hour - without the item-by-item debates that make Planning Poker sessions drag on for days.

Affinity Estimation works by having team members silently place items along a relative size spectrum - from smallest to largest - then quickly reviewing the groupings as a team. The silence is the secret weapon. It eliminates anchoring bias, prevents dominant voices from steering estimates, and forces everyone to think independently before the group discusses.

Quick Answer: What Is Affinity Estimation?

Aspect	Details
What It Is	A silent, collaborative estimation technique where team members sort backlog items into relative size groups without discussion
Best For	Sizing 50-200 backlog items in a single session
Speed	10-20 seconds per item (vs. 2-5 minutes per item with Planning Poker)
Scale Used	Fibonacci (1, 2, 3, 5, 8, 13, 20) or T-shirt sizes (XS, S, M, L, XL)
Key Differentiator	Silent sorting phase eliminates anchoring bias and dominant-voice influence
When to Use	New projects, backlog grooming for release planning, re-estimation after major scope changes
When NOT to Use	Sprint-level planning where individual story precision matters

What Is Affinity Estimation?

Affinity Estimation is an Agile estimation technique where a team silently sorts backlog items into relative size groups along a scale - typically Fibonacci numbers or T-shirt sizes. Unlike Planning Poker, which estimates one item at a time through rounds of voting and discussion, Affinity Estimation handles the entire backlog at once through physical (or virtual) card placement.

The technique was originally described by Lowell Lindstrom and is sometimes called "Magic Estimation" or "Silent Grouping." The core insight is simple: humans are much faster at relative comparison ("Is this bigger or smaller than that?") than absolute estimation ("How many story points is this?"). Affinity Estimation exploits this by turning estimation into a sorting exercise rather than a calculation exercise.

Here's what makes it different from every other estimation technique:

• Everyone estimates simultaneously - no waiting for turns
• The first phase is completely silent - no one speaks until all items are placed
• Items are compared to each other, not to abstract scales - you're asking "Is this bigger than that?" not "How many points is this?"
• The entire backlog gets estimated in one session - not item by item over multiple meetings

How Affinity Estimation Works: Step-by-Step Process

Step 1: Preparation

Before the session, the Product Owner writes each backlog item on an index card or sticky note. Each card needs enough information for the team to understand the scope - usually a title and 1-2 sentences of context. If using user stories, the standard "As a... I want... So that..." format works well.

Physical setup: Clear a large wall or table. You need enough space to create a horizontal spectrum with labeled columns.

Virtual setup: Use a digital whiteboard tool (Miro, Mural, or FigJam) with pre-created columns and digital sticky notes.

What you need:

• All backlog items written on cards (one per card)
• A clear wall, table, or virtual whiteboard
• Column labels for your chosen scale
• A timer (optional but recommended)
• The full development team present - everyone who builds the product

Step 2: Set Up the Scale

Create columns across your wall or board representing your estimation scale. The two most common options:

Fibonacci scale (recommended for teams that track velocity):

Column	1	2	3	5	8	13	20	?
Meaning	Trivial	Small	Moderate	Medium	Large	Very Large	Huge	Unknown

T-shirt scale (recommended for roadmap-level sizing):

Column	XS	S	M	L	XL	XXL
Meaning	A few hours	1-2 days	A few days	About a week	Multi-week	Too big - split it

Place one or two "reference stories" - items the team has already completed - in the appropriate columns. These anchors give everyone a calibration point before sorting begins.

Step 3: Silent Sorting (The Core Phase)

This is where Affinity Estimation gets its power. The rules are strict and simple:

1. Shuffle the cards and place them in a face-up pile
2. Everyone picks up cards from the pile simultaneously - no assigned order
3. Each person reads their card and places it in the column they think fits - without speaking
4. If you disagree with where someone placed a card, move it - still without speaking
5. If a card gets moved back and forth more than twice, set it aside for discussion
6. Continue until all cards are placed and no one wants to move any more

Time guidance: For a backlog of 100 items with a team of 5-7 people, the silent sorting phase typically takes 15-25 minutes. That's about 10-15 seconds per item - compared to 2-5 minutes per item with Planning Poker.

Step 4: Review and Discuss

Once the silent phase ends, walk through each column from smallest to largest:

1. Quick scan: Does each column "feel right" relative to the columns on either side? Are the items in column 3 clearly bigger than column 2 and clearly smaller than column 5?
2. Flag outliers: If anyone thinks an item is in the wrong column, discuss it briefly. Aim for 30 seconds max per disputed item.
3. Handle the "?" pile: For items that couldn't be placed or kept bouncing between columns, the Product Owner provides additional context. If that resolves the ambiguity, place it. If not, mark it for a refinement session.
4. Check the boundaries: Items at the edge of two columns are common. The team quickly votes (thumbs up/down) or the facilitator asks "Does anyone strongly object to this being a [size]?"

Time guidance: The review phase should take about half the time of the silent sorting phase. For 100 items, budget 10-15 minutes.

Step 5: Assign Final Estimates

Once the team is satisfied with the groupings:

1. Record each item's size in your backlog management tool (Jira, Azure DevOps, Linear, etc.)
2. Note items flagged for splitting - anything in the "?" or "Too Big" column
3. Photograph the wall (for physical sessions) as a reference
4. Calculate rough totals if needed for release planning - add up story points per column

The entire process - from shuffling cards to recording results - typically takes 45-90 minutes for 100-200 items. The same backlog would take 3-5 full days with Planning Poker.

Why Silent Sorting Changes Everything

The silence in Step 3 isn't just a nice process trick - it solves three fundamental problems that plague other estimation techniques:

1. Anchoring Bias Elimination

In Planning Poker, even with simultaneous reveal, team members often hear the discussion after the first round and adjust toward the majority. In Affinity Estimation, there's no discussion to anchor to. Each person makes their own judgment by reading the card and comparing it to what's already on the wall.

2. Dominant Voice Neutralization

Every team has someone who speaks first and speaks loudest. In verbal estimation, that person's opinion disproportionately influences the group. Silent sorting gives the quietest team member exactly the same influence as the most vocal - they can move any card to any column.

3. Speed Through Parallel Processing

Planning Poker is serial - one item at a time, one discussion at a time. Affinity Estimation is massively parallel. Five team members reading, thinking, and placing cards simultaneously means you're processing 5 items at a time. With a 7-person team and 140 items, each person handles about 20 items in the silent phase. That's 20 individual decisions × 15 seconds each = about 5 minutes of active sorting per person.

When to Use Affinity Estimation

Affinity Estimation shines in specific situations. Use it when:

• You have a large, unestimated backlog - 50+ items that need sizing for the first time
• You're starting a new project - the initial backlog has been created but nothing has been estimated yet
• You're preparing for release planning - you need rough sizes to forecast delivery timelines across multiple sprints
• The backlog has changed significantly - a pivot, major feature addition, or organizational change has invalidated previous estimates
• You need to re-estimate after team composition changes - new team members bring different perspectives on what's "big" vs. "small"
• You're doing quarterly or PI planning in a SAFe (opens in a new tab) or similar scaled framework
• Stakeholders need rough estimates fast - you can size 150 items in an hour and give leadership directional numbers

When NOT to Use Affinity Estimation

Don't reach for Affinity Estimation when:

• You need precise sprint-level estimates - Planning Poker gives more granular results for the 10-15 items in a sprint
• Your backlog has fewer than 20 items - the overhead of setting up columns isn't worth it for small backlogs
• Items require deep technical discussion - if most items are ambiguous or poorly defined, you need refinement before estimation
• The team has never worked together - without shared context on "what does a 5 mean for us?", the silent sorting produces too much disagreement
• You need estimates that include risk/uncertainty separately - Affinity Estimation bundles everything into a single size

Affinity Estimation vs. Other Techniques

Aspect	Affinity Estimation	Planning Poker	T-Shirt Sizing	Bucket System
Best batch size	50-200 items	5-15 items	20-100 items	50-200 items
Time per item	10-20 seconds	2-5 minutes	30-60 seconds	10-30 seconds
Precision	Moderate (good for planning)	High (good for sprints)	Low (good for roadmaps)	Moderate
Silent phase?	Yes (core mechanism)	No (discussion-based)	Optional	Yes (variant)
Scale	Fibonacci or T-shirt	Fibonacci	T-shirt	Fibonacci
Best for	Initial backlog sizing, release planning	Sprint-level refinement	Roadmap-level sizing	Large-scale initial sizing
Anchoring risk	Very low	Moderate (mitigated by reveal)	Low	Very low
Remote-friendly?	Yes (with virtual boards)	Yes (with poker tools)	Yes (simple polling)	Moderate
Output type	Story points or size labels	Story points	Size labels	Story points

The common estimation progression most teams follow:

1. Affinity Estimation for initial backlog sizing (get rough sizes on everything)
2. T-Shirt Sizing for roadmap-level planning conversations with stakeholders
3. Planning Poker for sprint-level refinement (precise sizing of the next sprint's work)

These techniques aren't competing - they serve different purposes at different planning horizons.

Running Affinity Estimation with Remote Teams

The physical wall-and-sticky-notes version is straightforward. Remote sessions need more intentional setup but work just as well. Here's how:

Tool Setup

Use a virtual whiteboard with these features:

• Infinite canvas with zoom capability
• Real-time collaboration - everyone sees moves instantly
• Sticky notes or cards that can be dragged between columns
• Timer built in or alongside (for the silent phase)

Recommended tools:

• Miro - Create a board with pre-made columns. Each team member gets a unique cursor color so you can see who's moving what.
• Mural - Similar to Miro with built-in voting and timer features.
• FigJam - Lighter-weight option from Figma, good for smaller teams.

Remote Session Protocol

1. Pre-session: Create the board with columns and import backlog items as sticky notes. Share the board link 30 minutes before the session so everyone can verify they have access.
2. Briefing (5 min): Explain the process, point out reference stories, confirm the scale.
3. Silent sorting (15-25 min): Mute all microphones. Turn off cameras if preferred. Everyone drags items into columns. The facilitator watches for "tug-of-war" items (moved back and forth 3+ times) and flags them.
4. Review (10-15 min): Unmute. Walk through each column on a shared screen. Use reactions or quick polls for disputed items.
5. Recording (5 min): Export results to your backlog tool.

Common Remote Challenges and Solutions

Challenge	Solution
Two people move the same item simultaneously	Use "claim" convention - place your cursor on a card for 2 seconds before moving it
Can't tell if someone is still sorting	Use a "Done" sticky note - each person places one when they're finished
Items are too small to read	Use a consistent card format: Title only (no descriptions). Keep a separate reference sheet for details
Someone talks during silent phase	Mute enforcement - facilitator controls muting, reminds via chat: "Silent phase in progress"

Industry Examples

Affinity Estimation adapts well across industries. Here's how different types of teams use it:

SaaS Product Development

A product team with a 180-item backlog for Q2 planning. The Product Owner prints each feature/story on a card. The team sorts items using Fibonacci (1-20). Result: full backlog sized in 55 minutes, enabling the release manager to build a 3-month roadmap with confidence levels per feature.

Healthcare IT

A hospital system's development team needs to estimate 120 HIPAA-related compliance updates. They add a "Compliance Review Required" flag to items landing in 8+ columns. The compliance officer participates in the review phase, flagging items that need security architecture review before development begins.

Financial Services

A banking platform team uses Affinity Estimation quarterly to size the combined backlog from three product streams (mobile, web, and API). Cross-team representatives participate so that shared dependencies get consistent sizing. Items touching payment processing infrastructure automatically get bumped one column larger to account for regulatory testing overhead.

E-commerce

A retail platform team sizes 200+ items before their annual holiday feature planning. They run separate Affinity sessions for customer-facing features and back-office/ops features because the teams have different velocity baselines. T-shirt sizing works better here - stakeholders from merchandising and marketing participate and find S/M/L more intuitive than Fibonacci numbers.

Mobile App Development

A mobile team estimates features for both iOS and Android simultaneously. Items requiring platform-specific work get two cards (one per platform) while shared backend work gets a single card. This surfaces platform-specific complexity that a single estimate would hide.

Government / Public Sector

An agency modernizing legacy systems uses Affinity Estimation to size migration tasks. The "?" column gets heavy use - many legacy components have unknown complexity until investigation begins. The team runs a spike sprint for "?" items before re-estimating them in the next Affinity session.

EdTech

A learning platform team sizes 90 items combining new course features, accessibility improvements, and LMS integrations. They include an instructional designer in the silent sorting phase - not for technical sizing, but to flag items where content creation effort dwarfs development effort.

Startup / Early Stage

A 4-person startup team uses a simplified 5-column Affinity board (1, 2, 3, 5, 8) for their first product backlog of 60 items. With a small team, the silent phase takes just 8 minutes. They re-run the session monthly as the product pivots and the backlog evolves.

Common Mistakes and How to Fix Them

Mistake 1: Breaking Silence During the Sorting Phase

What happens: Someone says "Hey, where did you put the login feature?" or "That's definitely not a 3." Suddenly multiple people are talking and the silent phase collapses into a group discussion.

Why it matters: The entire value of Affinity Estimation - speed, reduced anchoring, equal participation - depends on the silence. Breaking it turns the session into a slower, less accurate version of Planning Poker.

Fix: The facilitator must enforce silence firmly. Use a visible timer. If someone talks, hold up a "SILENCE" card or send a chat message. Some teams play music during the silent phase - it makes occasional whispers less disruptive and creates a clear signal for when the phase ends (music stops).

Mistake 2: Spending Too Long on the Review Phase

What happens: The team argues about individual item placement for 5+ minutes each. The review phase takes longer than the sorting phase.

Why it matters: If your review takes longer than sorting, you've lost the speed advantage. You might as well have used Planning Poker.

Fix: Set a hard 2-minute timer per disputed item. If the team can't agree in 2 minutes, go with the larger size (it's safer for planning) or mark it for refinement. The facilitator should move the conversation along: "We've heard both sides. Larger size or further refinement - which is it?"

Mistake 3: Not Using Reference Stories

What happens: The team starts sorting with empty columns and no calibration. Each person has a different internal definition of what "5" means.

Why it matters: Without reference stories, you'll have massive disagreement in the review phase because everyone calibrated independently. A "5" to one person is an "8" to another.

Fix: Before sorting begins, place 2-3 completed stories in different columns as anchors. These should be stories the entire team worked on and remembers. During the review, you can point to these references: "We agreed the authentication story was a 5. Is this payment feature bigger or smaller than that?"

Mistake 4: Including Items That Aren't Ready for Estimation

What happens: Cards with vague descriptions ("Improve performance") or missing context ("API changes") get included. Team members don't know what to do with them and either guess randomly or place them in "?".

Why it matters: Garbage in, garbage out. Estimating poorly defined items produces unreliable results and wastes the team's sorting time.

Fix: The Product Owner should pre-screen items before the session. Every card needs: a clear title, enough context to understand scope, and known dependencies flagged. Items that aren't ready go into a "Needs Refinement" pile before the session begins - they don't enter the sorting phase.

Mistake 5: Using Affinity Estimation for Sprint-Level Planning

What happens: The team tries to use Affinity Estimation results directly for sprint capacity planning without additional refinement.

Why it matters: Affinity Estimation gives directional sizes, not precise estimates. An item estimated as a "5" during Affinity might actually be a "3" or an "8" once the team digs into implementation details. Sprint planning needs that precision.

Fix: Use Affinity Estimation for release planning and backlog prioritization. Then use Planning Poker (or a similar technique) to re-estimate the top items during Sprint Refinement before committing to sprint work.

Mistake 6: Forcing Consensus on Every Item

What happens: During the review phase, the facilitator insists that every single item must have unanimous agreement before moving on.

Why it matters: Perfect consensus on 150 items is impossible and unnecessary. For planning purposes, being within one column is accurate enough. Spending 5 minutes getting agreement on whether something is a "5" or an "8" defeats the purpose of a rapid estimation technique.

Fix: Adopt a "good enough" standard. If most of the team agrees and no one has a strong objection, accept the placement and move on. Save detailed estimation for the items that actually enter the next sprint.

Mistake 7: Not Photographing or Recording Results

What happens: The team finishes a great session, feels good about the estimates, then struggles to transfer 150 items into the backlog tool accurately. Some items get lost. Some sizes get entered incorrectly.

Why it matters: All that work is wasted if the results aren't captured properly.

Fix: Assign one person as the "recorder" who photographs the wall (or exports the virtual board) immediately after the session. Ideally, transfer results into the backlog tool during the session while everything is still visible and the team can verify entries.

Affinity Estimation Maturity Model

Stage 1: Learning (First 1-3 Sessions)

What you'll see:

• Silent phase feels awkward - people instinctively want to discuss
• Lots of items end up in the "?" column
• Review phase takes as long as or longer than sorting
• Wide disagreement on many items during review

Focus on:

• Enforcing the silence strictly
• Using clear reference stories
• Keeping the review fast - accept "close enough" sizing
• Building team comfort with the process

Stage 2: Calibrating (Sessions 4-8)

What you'll see:

• Silent phase gets faster - team members have shared calibration
• Fewer items in the "?" column
• Review phase shortens significantly
• Disagreements cluster around boundary items (is this a 5 or an 8?)

Focus on:

• Updating reference stories with recent work
• Tracking how often Affinity estimates match sprint-level Planning Poker estimates (calibration accuracy)
• Reducing the number of "tug-of-war" items

Stage 3: Optimized (Session 9+)

What you'll see:

• 100+ items sorted in under 15 minutes
• Review phase focused only on a handful of disputed items
• Results closely match subsequent sprint-level estimates
• The team can explain their sizing rationale clearly for each column

Focus on:

• Using historical data to validate and improve accuracy
• Teaching new team members the calibration by walking them through reference stories
• Extending the technique to cross-team estimation (multiple teams sizing shared work)

Best Practices for Facilitators

1. Prepare the space before the team arrives. Whether physical or virtual, the columns, labels, and reference stories should be set up and ready. Don't waste 15 minutes of everyone's time on setup.

2. Read each card aloud before shuffling. A quick 10-second review of each item ensures nobody encounters a card they've never seen before. This can be done in the briefing phase.

3. Use a visible timer for the silent phase. A countdown timer projected on a screen (or shared in the virtual tool) creates gentle urgency and prevents the sorting from dragging on.

4. Track "tug-of-war" items during silent sorting. Keep a notepad and mark items that get moved between columns 3+ times. These are your discussion targets in the review phase.

5. Don't let the review become a second estimation session. The review is for catching obvious misplacements and resolving disputes - not for re-estimating everything.

6. End with a quick retro. After each session, spend 3 minutes asking: "What worked? What should we change next time?" This continuous improvement is what takes teams from Stage 1 to Stage 3.

7. Size matters for the session. 5-9 people is the sweet spot. Fewer than 5 means limited perspectives. More than 9 creates coordination overhead during the silent phase - too many hands reaching for the same cards.

8. Schedule sessions when energy is high. Affinity Estimation requires focus and quick decision-making. Don't schedule it after lunch or at the end of a long meeting day. Morning sessions produce better results.

Conclusion

Affinity Estimation is the fastest way to size a large backlog while still getting the whole team's input. The silent sorting phase - which might feel strange the first time - is exactly what makes it work. It removes the social dynamics that slow down and skew other estimation techniques.

Start with these three things: set up your columns with clear reference stories, enforce the silence during sorting, and keep the review phase short. After 3-4 sessions, your team will be sizing 100+ items in under an hour with accuracy that's close enough for release planning and roadmap decisions.

Remember: Affinity Estimation doesn't replace Planning Poker. It complements it. Use Affinity for the big picture (what's in this release and how big is it?), then use Planning Poker for the close-up (what exactly are we committing to this sprint?). Together, they cover every planning horizon your team needs.

Frequently Asked Questions (FAQs) / People Also Ask (PAA)