Techniques for Reviewing Team Collaboration Efficiency

Yet another reason estimates are ridiculous. One of the silliest things about time estimates is that the vast majority of time it takes for a team to finish something is spent waiting. For the average development team to create something of value, only 10-20% of the total start-to-finish completion time is spent actively working on the item. The majority of the time is spent waiting. 🔵 Waiting for Reviews 🔵 Waiting for team member hand-offs 🔵 Waiting on other teams or departments So much time is spent waiting… instead of asking, “How much time will it take WORKING to complete this?” You’d be better off asking, “How much time will it take WAITING to complete this?” This, of course, is impossible to answer since most teams have zero control (or even awareness) of waiting time. You’re far, far better off ditching time estimates entirely and focusing on reducing wait states instead. But how? 1] Use Flow Efficiency ↳ Few teams are even aware of the most critical flow metric: Flow Efficiency. ↳ Flow Efficiency tells you how much time is spent actively working on increments of value (features, assets, stories, etc.). ↳ Flow Efficiency (%) = Active Time / Total Time X 100 ↳ Any good workflow tool will calculate your Total Time (Cycle Time). 2] Determine Active Time ↳ To figure out Active Time, you need to track your wait states by adding a “Done” state to every existing stage in your workflow. ↳ For Example: Development -> Development Done -> Testing -> Testing Done -> Review -> Review Done -> Released ↳ The “Done” columns are your wait states.  ↳ Now, you can effectively determine Active Time for each item in your flow vs. Wait Time. 3] Improve Flow Efficiency ↳ Once you can visualize and track wait times, you can focus on fixing the worst offenders. ↳ Add team members, reduce work in progress, remove dependencies… there are many ways to minimize wait states. ↳ Any reduction made to any of your wait states will improve Flow Efficiency An average team will have a Flow Efficiency of 20%. Your team should achieve a Flow Efficiency of 40% or greater to be considered high-performing. Will this take some effort? Of course! But far less effort and total team time (and annoyance) than asking for estimates. Plus, the increase in productivity will far outweigh any loss in imagined predictability.

Kanban: We Should Be "Done" With "In-Progress" One of the best ways to use Kanban is by visualizing meaningful work states on your board. Thoughtfully designed boards can transform how teams deliver value, spot inefficiencies, and improve collaboration. Unfortunately, many teams miss these opportunities by relying on vague, catch-all columns like “In-Progress.” Let’s talk about why “In-Progress” is practically useless, and how breaking it into clearer work states is a smarter strategy. Why “In-Progress” Fails The term “In-Progress” might seem harmless, but it’s so broad that it adds little value. “In-Progress” doesn’t explain what’s actually happening. Is a task being coded, reviewed, or tested? Without specifics, delays and inefficiencies stay hidden. A generic column hides bottlenecks. For example, slow code reviews go unnoticed when everything sits under “In-Progress.” Vague statuses make it harder to know who should act next. Confusion leads to reduced accountability, delays, and misaligned expectations. Without data showing where tasks spend the most time, teams can’t identify trends or resolve inefficiencies. The Case for Clarity Replacing “In-Progress” with specific work states turns a Kanban board into a powerful tool for managing flow and driving improvement. For example, a software development team might use: Backlog: Items awaiting prioritization. Ready for Development: Work ready to start. In Development: Developers are actively working. Ready for Code Review: Development is complete, awaiting review. In Code Review: Review process underway. Ready for Testing: Code is ready for QA. In Testing: QA is actively testing. Ready for Deployment: Testing is complete, awaiting release. Done: Work is completed. Each state reflects a clear step in the workflow (not necessarily a handoff). This improves visibility, accountability, and makes bottlenecks easier to spot. Your team’s context might call for different states, but the goal stays the same: clarity. Spotting Bottlenecks Granular states make delays visible. If tasks sit too long in “Ready for Code Review,” reviewers may be overloaded or not prioritizing reviews. A backlog in “Ready for Deployment” could mean release processes need work. Tasks stuck “In Testing” might point to unclear requirements or a stretched QA team. Tracking time-in-state reveals where delays occur, helping teams reallocate resources or refine processes. Collaboration Benefits Meaningful work states improve collaboration. When a task moves to “Ready for Testing,” testers know it’s their turn to act. This reduces idle time and makes transitions smoother. Be Done With “In-Progress” Create columns for key steps in your workflow. Don’t overcomplicate things. Aim for enough granularity to reveal bottlenecks without overwhelming your team with administrivia. Set clear entry and exit criteria for each column. Kanban isn’t just about making work visible; it’s about making the right work visible.

80% of workflow bottlenecks are hiding in plain sight. But most teams don’t look closely enough to see them. When I design workflows, I don’t add new tools right away or build complex systems. I start by mapping the current process. Without knowing every step, we’re just guessing at what’s slowing us down. Here’s my go-to checklist for spotting the hidden issues: 1 - Map every step Document each click, handoff, and decision. Most teams skip this, but it’s where the real insights are. 2 - Spot repetitive tasks Repeated steps often go unnoticed. They feel like “just part of the job” but usually add no real value. 3 - Measure task times Check how long each step actually takes. When times drag, it’s a sign of inefficiency that needs fixing. 4 - Look for approval delays Every extra approval is a potential bottleneck. Too many checks can slow things down more than they help. 5 - Align skills with tasks Ensure tasks fit the person’s skill level. If experts are doing routine work, it’s time to rethink the setup. 6 - Automate simple tasks Automation isn’t about flashy tools. It’s about freeing up your team’s time for critical work, not admin tasks. It’s surprising how often these basics are ignored. Do this if you want to do more with less. Or skip it if you’re okay with unnecessary delays and wasted resources.

Critique this (real) team's experiment. Good? Bad? Caveats? Gotchas? Contexts where it will not work? Read on: Overview The team has observed that devs often encounter friction during their work—tooling, debt, environment, etc. These issues (while manageable) tend to slow down progress and are often recurring. Historically, recording, prioritizing, and getting approval to address these areas of friction involves too much overhead, which 1) makes the team less productive, and 2) results in the issues remaining unresolved. For various reasons, team members don't currently feel empowered to address these issues as part of their normal work. Purpose Empower devs to address friction points as they encounter them, w/o needing to get permission, provided the issue can be resolved in 3d or less. Hypothesis: by immediately tackling these problems, the team will improve overall productivity and make work more enjoyable. Reinforce the practice of addressing friction as part of the developers' workflow, helping to build muscle memory and normalize "fix as you go." Key Guidelines 1. When a dev encounters friction, assess whether the issue is likely to recur and affect others. If they believe it can be resolved in 3d or less, they create a "friction workdown" ticket in Jira (use the right tags). No permission needed. 2. Put current work in "paused" status, mark new ticket as "in progress," and notify the team via #friction Slack channel with a link to the ticket. 3. If the dev finds that the issue will take longer than 3d to resolve, they stop, document what they’ve learned, and pause the ticket. This allows the team to revisit the issue later and consider more comprehensive solutions. This is OK! 4. After every 10 friction workdown tickets are completed, the team holds a review session to discuss the decisions made and the impact of the work. Promote transparency and alignment on the value of the issues addressed. 5. Expires after 3mos. If the team sees evidence of improved efficiency and productivity, they may choose to continue; otherwise, it will be discontinued (default to discontinue, to avoid Zombie Process). 6. IMPORTANT: The team will not be asked to cut corners elsewhere (or work harder) to make arbitrary deadlines due to this work. This is considered real work. Expected Outcomes Reduce overhead associated with addressing recurring friction points, empowering developers to act when issues are most salient (and they are motivated). Impact will be measured through existing DX survey, lead time, and cycle time metrics, etc. Signs of Concern (Monitor for these and dampen) 1. Consistently underestimating the time required to address friction issues, leading to frequent pauses and unfinished work. 2. Feedback indicating that the friction points being addressed are not significantly benefiting the team as a whole. Limitations Not intended to impact more complex, systemic issues or challenges that extend beyond the team's scope of influence.