Posts

Async sprint planning: can it actually work?

Distributed team members working from different locations with planning artifacts floating between them, connected by dotted lines
Kelly Lewandowski

Kelly Lewandowski

Last updated 25/03/20267 min read

Sprint planning is one of the few Scrum ceremonies where the whole team needs to walk away with the same understanding of what they're building and why. That makes it a tough candidate for going fully async. But most of what happens in a two-hour planning session doesn't actually require everyone to be in the same room (or call) at the same time. The teams that do async planning well aren't skipping the conversation. They're just moving the reading and thinking parts out of the meeting, so the live time is spent on actual decisions.

The problem with fully synchronous planning

A typical sprint planning meeting runs 1-2 hours for a two-week sprint. In practice, a big chunk of that time goes to activities that don't benefit from real-time discussion:
  • Reading through tickets that could have been reviewed beforehand
  • Asking clarifying questions the product owner could have answered in writing
  • Waiting for the slowest reader before moving to the next item
  • Re-explaining context that already exists in the backlog but nobody looked at
For distributed teams across time zones, the problem compounds. Someone is always taking the meeting at an inconvenient hour. And a tired teammate at 10 PM isn't contributing their best thinking to capacity discussions.

What actually works async

Some parts of planning transfer well to async without losing anything:

Backlog review and context-setting

The product owner shares the candidate items for the sprint, along with the proposed sprint goal, 1-2 days before planning. Team members review on their own time, leave questions as comments, and flag anything unclear. By the time you meet, everyone has already read and digested the work.

Estimation

This is the piece that translates best to async. Tools like Kollabe's planning poker let team members estimate stories independently, without anchoring bias from hearing a senior developer's number first. Each person reviews the story, assigns their estimate, and moves on. Disagreements surface naturally when votes diverge, and those specific items can be flagged for synchronous discussion. For a deeper look at running estimation without a live call, check out our guide on async planning poker.

Capacity and availability

Vacations, training days, on-call rotations. This information can live in a shared doc or Slack thread. Nobody needs a meeting to say "I'm out Thursday and Friday."

Definition of Ready checks

Whether each backlog item meets your team's Definition of Ready is a straightforward yes/no check. Team members can review items against the criteria asynchronously and flag gaps for the product owner to address before the sync session. Team member reviewing sprint backlog items on a laptop with checkmarks and question marks appearing above different items

What still needs a live call

Going fully async is where teams usually get burned. Some parts of planning need the back-and-forth speed that only a real-time conversation provides.

Sprint goal negotiation

The sprint goal is a commitment about what the team is optimizing for this cycle. When priorities compete or the goal isn't obvious, that discussion needs to happen live. Async threads about competing priorities tend to drag on for days without resolution. When you genuinely can't resolve something asynchronously, sometimes the fastest path forward is the simplest one. Teams have been known to flip a coin to break a deadlock on low-stakes decisions rather than scheduling yet another meeting. It sounds silly, but it beats a three-day Slack thread about whether to prioritize the dashboard redesign or the API cleanup.

Scope commitment

After async estimation and review, the team needs a moment to look at the full picture together: the sprint goal, the selected items, the capacity. "Can we actually do this?" is a question best answered as a group, where someone can say "that's too much" and the team can negotiate in real time.

High-ambiguity items

If a story has unclear requirements or real technical risk, async comments won't cut it. These items need whiteboarding or at least a focused conversation where people can talk through options in real time.

The hybrid model

Do the prep work async. Reserve the live session for alignment and decisions. Here's what that looks like in practice:
Async: share the candidates (2 days before)
Product owner posts the proposed sprint goal and candidate backlog items. Team reviews, asks questions, and estimates using an async planning poker tool.
Async: flag blockers (1 day before)
Team members mark items they can't estimate confidently, share capacity, and note any concerns. Product owner resolves open questions.
Sync: align and commit (30-60 minutes)
Review the sprint goal together. Discuss only flagged items. Confirm scope against capacity. Walk away with a shared commitment.
Teams using this model regularly cut their sync planning time from two hours to 30-60 minutes. The meeting turns into a decision-making session instead of a reading-and-discussion marathon. Team on a short video call with a clear agenda board showing only three flagged discussion items

When to stay fully synchronous

Async planning isn't for every team. Keep the full meeting if:
  • Your team is new. People who haven't built shared context need more face time to calibrate expectations and build trust.
  • You're early in Scrum adoption. The structure of a full ceremony helps until the habits stick.
  • The work is mostly exploratory. If most sprint items are research-heavy, you'll spend more time discussing than estimating anyway.
  • Your backlog is a mess. Async planning assumes items arrive ready. If they don't, you'll burn the sync time sorting through half-baked tickets.

Making async estimation work

If estimation is the piece you move async, a few things help:
PracticeWhy it matters
Set a deadline for votesWithout one, estimation drags on indefinitely
Use relative sizingFibonacci or t-shirt sizes work better async than hour-based estimates
Show context with each storyAcceptance criteria, designs, and dependencies should be attached, not linked
Flag divergent votes automaticallyTools like Kollabe highlight when estimates are far apart so you know what to discuss sync
Keep rounds shortDon't dump 30 stories at once. Batch them into groups of 5-8
If you're unsure how complex a story is before estimation, the Estimation Complexity Analyzer can help you decide whether something needs a group discussion or can be estimated independently.

A realistic schedule

Here's what async-first planning looks like for a team running two-week sprints: Wednesday (2 days before sprint start):
  • Product owner shares candidate items and sprint goal draft
  • Team begins async review and estimation
Thursday (1 day before):
  • Estimation deadline
  • Team flags items needing discussion
  • Product owner addresses open questions
Friday (sprint start):
  • 30-60 minute sync session: confirm goal, resolve flags, commit to scope
  • Sprint begins
Total time investment per person: under two hours, roughly the same as a single traditional planning meeting. The difference is it's spread across three days, and most of it happens when it's convenient for each person.

Start small

Async sprint planning works when you treat it as a way to make your sync time more focused, not a replacement for conversation altogether. Move estimation and backlog review async first. Keep goal-setting and commitment synchronous. See what your team actually needs from there, not what sounds efficient in theory.

Technically yes, but most teams find that scope commitment and sprint goal discussions work better live. A hybrid approach — async prep with a short sync session — tends to produce better outcomes.

With good async prep, 30-60 minutes is usually enough. If you're regularly going over an hour, your async preparation likely needs improvement.

You need a backlog tool (Jira, Linear, etc.) paired with an async estimation tool like Kollabe's planning poker. Communication happens through your team's normal channels — Slack, Teams, or similar.

It can, though the benefits are smaller. Co-located teams mainly gain time savings by having people review items independently rather than reading together in a room.