Identifying Bottlenecks in Team Processes

Can your team answer these two questions? 1) Once we commit to doing something, how long does it take for us to finish it? 2) Once we start working on something, how long does it take for us to finish it? The first measures your team’s lead time, and the second measures cycle time. They’re very different, even though many think they’re synonymous. If you can’t answer these two questions, it makes it nearly impossible to answer questions like: 🔵 Will we be able to hit promised milestones and releases? 🔵 How long will it take to deliver that new high-priority feature? 🔵 How long until that new art asset is ready for the marketing campaign?  🔵 How long will the customer wait for their support request to be answered? and most important… ⭐️ How can we improve, remove bottlenecks, and deliver faster? To start measuring lead times and cycle times: 1 - Determine and visualize your workflow in a tool like Trello, Asana, or Favro 2 - Be sure to have a clear Commitment point (Selected, Ready, Committed, etc.) and a clear In-progress point (Developing, Doing, Resolving, etc.) 3 - Determine when something is actually Done and delivered to the “customer” in your flow 4 - Measure the time it takes for each item (card) to go from Committed to Done’and Started to Done (a good tool will track this for you) 5 - Visualize your lead and cycle times in a scatter plot, histogram, and/or control chart From there, you can determine averages and probable ranges of how long your team will take to deliver something new. Your team will then be well equipped to: ✅ Better forecast delivery dates for batches of work ✅ Accurately answer: when will this be done? ✅ Begin reducing lead times and cycle times ✅ Start building a more predictable flow Remember, the difference between your lead times and cycle times can be huge, so it’s critical to understand the difference and measure both.

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.

The ServiceNow Optimization Cheatsheet What to Check When You Inherit a Mess Most leaders don’t walk into a clean ServiceNow instance. You inherit overgrown categories, broken workflows, and dashboards full of noise instead of insights. Before you burn it all down or launch a 6-month rebuild—start here. Here’s what to verify, tweak, and track first to regain control: 1. Core Config Checks These are your “pop the hood” items: ↳ Roles & Access: Avoid over-permissioning—check sys_user_role. ↳ Assignment Groups: Clarify who owns what and eliminate duplicates. ↳ Categories/Subcategories: Remove clutter so reports make sense. ↳ SLA Definitions: Match to actual team capacity, not wishful thinking. 2. Workflow Watchpoints Where most delays and escalations start: ↳ Incident Routing: Are tickets assigned to the wrong team? ↳ Escalation Rules: Are loops or bottlenecks baked in? ↳ Change Approvals: Are they misaligned or missing entirely? ↳ Task Dependencies: Are upstream/downstream steps clearly mapped? 3. Dashboards That Actually Matter Use these metrics to spot the mess: ↳ First Contact Resolution = Tier 1 effectiveness ↳ Mean Time to Resolution = Bottlenecks ↳ Ticket Aging = Burnout risk ↳ SLA Breaches = Trust killers 4. Quick Wins That Buy You Time Fix these first: ↳ Auto-routing by category ↳ Top 10 KB articles in the portal ↳ Test ticket > escalation > resolution flow ↳ “One-click” ticket filters for agents You don’t need a full rebuild to make ServiceNow work better. Just a smarter starting point. What's the first thing you check when someone hands you the keys to a messy instance? ♻️ Repost to help someone who inherited a ServiceNow nightmare. 🔔 Follow Bob Roark for no-BS ITSM leadership strategies.

When roles aren’t clear, progress stalls. A fast-growing startup I worked with had everything - talent, vision, and funding. Yet, execution dragged. Why? No one was clear on ownership. 🔹 50% of employees don’t fully understand their role (Gallup). 🔹 Unclear roles slow decisions by 25% (HBR). 🔹 Teams with defined accountability are 31% more productive (McKinsey). Work fell through the cracks. People hesitated. The leader assumed things were moving - until deadlines slipped. Some employees were overwhelmed, others were disengaged, and cross-functional collaboration felt chaotic. How We Fixed It ✅ Shift from tasks to outcomes → Instead of “handles reporting,” it became “ensures accurate, timely insights for decisions.” Employees started seeing their work as contributing to a larger goal, not just ticking off tasks. ✅ Clear accountability → Clearly define who’s responsible, for what, by when, for every key process. This eliminated bottlenecks and ensured that decisions weren’t delayed because "no one knew whose call it was." ✅ Make clarity a habit → Quarterly check-ins with two simple questions: → Do you know what success looks like in your role? → Where do you feel stuck? This helped leaders spot gaps before they became problems. Once roles were clear, execution sped up. Meetings became more efficient. Accountability improved. People weren’t just busy - they were moving in the right direction. Productivity increased. If your team is stuck, start here: What role ambiguity is slowing them down? #team #leadership #highperformance

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.

Every transaction tells a story. Don't just read the first and last chapters. 𝗙𝗶𝗻𝗱 𝘆𝗼𝘂𝗿 𝗯𝗼𝘁𝘁𝗹𝗲𝗻𝗲𝗰𝗸𝘀 𝘄𝗶𝘁𝗵 𝗘𝟮𝗘 𝗧𝗿𝗮𝗻𝘀𝗮𝗰𝘁𝗶𝗼𝗻 𝗔𝗻𝗮𝗹𝘆𝘀𝗶𝘀. A delayed approval. A mismatched invoice. A system glitch. These tiny hiccups in the middle can snowball into massive headaches—delays, upset customers, and endless firefighting to get things back on track. That’s why End-to-End Transaction Analysis matters. It forces you to stop and look at the entire process—not just the highlights—and figure out where things slow down or break. Here are some tips that have worked for me: 𝟭. 𝗦𝘁𝗮𝗿𝘁 𝗦𝗺𝗮𝗹𝗹. Pick one process, maybe vendor payments or procurement, and map out every step. Look for the obvious bottlenecks. 𝟮. 𝗔𝘀𝗸 𝘁𝗵𝗲 𝗥𝗶𝗴𝗵𝘁 𝗤𝘂𝗲𝘀𝘁𝗶𝗼𝗻𝘀. Where do things slow down? Who’s always waiting on who? What’s the one step everyone complains about? 𝟯. 𝗨𝘀𝗲 𝗗𝗮𝘁𝗮 𝘁𝗼 𝗦𝗽𝗼𝘁 𝗣𝗮𝘁𝘁𝗲𝗿𝗻𝘀. Track what’s happening, not just what went wrong. Look for trends in delays or errors. 𝟰. 𝗔𝘂𝘁𝗼𝗺𝗮𝘁𝗲. If the same problems keep happening, find a way to streamline the process. Tools like Germain UX give you visibility across the whole process to pinpoint and fix inefficiencies. Smooth workflows don’t just happen. They’re built by paying attention to the things most people ignore. What's your tip for keeping transactions running smoothly? #SessionReplay #CustomerExperience #ProcessMining #DigitalExperience #Observability #UX Follow me for weekly updates on the latest tools and trends in UX and productivity.

If your internal processes aren’t clearly defined, custom software won’t fix the chaos - it will just automate the confusion. Companies know things aren’t running efficiently, but when dig deeper, here's what is happening: – Same processes vary from team to team – The same task is performed five different ways depending on who’s doing it – There’s no clear agreement on what “efficient” actually looks like In this environment, building custom software doesn’t solve the problem - it just locks in broken processes and makes future changes even harder. So what’s the solution? Standardize first. Automate second. Here’s a simple 3-step framework to help you prepare for custom software the right way: Step 1: Map Your Current Workflows Don’t aim for perfection, aim for visibility. Start by documenting/drawing how work is actually done today, even if it’s messy. This will reveal inconsistencies, redundancies, and gaps you might not even realize exist. Step 2: Identify the Inefficiencies Where are things slowing down? Look for repetitive manual tasks, excessive handoffs, duplicated data entry, and areas where spreadsheets are being used to “patch” broken systems. These are the bottlenecks that custom software should eventually solve. Step 3: Define the Ideal Future State Clarify what the standard process should look like moving forward. This doesn’t mean over-engineering every workflow. It means aligning teams around a clear, repeatable way of doing things. Once that’s in place, software can scale and support it. _____ Even though we build custom solutions, the truth is, custom software isn’t a magic fix. It’s a powerful tool to scale what’s already working but it can’t design your processes for you. If your team is struggling to stay aligned and operational headaches keep popping up, focus on process clarity first. Then invest in technology that will take your efficiency to the next level. #enterprisedevelopment #construction #processautomation

Stop Optimizing Everything: Focus on What Actually Moves the Needle There’s this default belief in engineering: “We should always be optimizing.” Tune the database. Rewrite the query. Refactor the function. It feels productive—but often, it’s just motion, not impact. I worked with a team that spent two full sprints optimizing database indexes to speed up search. Query performance improved by 40%. On paper, a huge win. But for users? Nothing changed. Turns out the real problem was the front-end: clunky filters, poor defaults, and no ability to sort results. Users had to redo the same search over and over. The actual bottleneck had nothing to do with the database. This is where the Theory of Constraints comes in. You don’t make a system better by optimizing everything. You make it better by identifying and addressing the single most limiting factor—the constraint. So, how do you find the constraint? Here’s what’s worked for me: Start with the customer journey. Where are users dropping off? Where are support tickets piling up? Where’s the frustration? Look at your system metrics—but only in context. High CPU or slow queries aren’t always a problem unless they’re affecting customer outcomes. Follow the flow of work. In delivery systems, this could mean tracking the time from idea to production. Where does work sit waiting? That’s a constraint. Ask better questions. “What’s the slowest part of our process right now?” “If we fixed only one thing this quarter to help customers, what would it be?” And most importantly: Don’t optimize anything until you know what you’re optimizing for. The goal isn’t cleaner code or faster queries—it’s better outcomes. That could mean faster checkouts, fewer abandoned carts, quicker releases, lower churn. So next time someone says “we should optimize X,” ask: “Is that our constraint?” Because optimizing everything is wasted motion. Optimizing the right thing? That’s how you build real momentum.

Blink-182 says, "Work sucks, I know." Most of us just accept this. We don't have to. The truth? The daily task you dread is a symptom of deeper organizational issues—issues that quietly drain your energy, productivity, and passion. Here’s how to fix what sucks at work, starting small but scaling big: 1️⃣ Identify the Everyday Thing That Sucks – Manually downloading the same report every morning – Sending identical status-update emails each week – Hosting 70-person Zoom calls where almost every camera is off – Keying data from one system to another, line-by-line – Calling Tom from Accounting every third Wednesday to get numbers 2️⃣ Understand Why It Sucks (Diagnose) – No clarity of purpose: “Wait, why am I even doing this?” – Unclear ownership: “Whose job is this supposed to be?” – Zero visibility: “Does anyone realize how much time we're wasting?” – Lack of automation: “Surely there's a better way—API, macro, webhook?” 3️⃣ Connect the Small Pain to a Bigger Organizational Breakdown (Zoom Out) Use a thoughtful systems-thinking approach to map symptoms to root causes: – Example: – Symptom: Manually downloading a report every morning. – Root cause: No coherent organizational data strategy, causing bottlenecks as junior staff manually scrape data to satisfy ad-hoc executive requests. – Example: – Symptom: Hosting frequent, oversized Zoom meetings with disengaged attendees. – Root cause: Lack of clarity around decision-making structures or clear team accountability, resulting in endless “alignment” meetings without actionable outcomes. – Example: – Symptom: Regularly chasing data from other departments (like Accounting). – Root cause: Poor cross-functional collaboration processes and absence of transparent knowledge-sharing tools or culture. 4️⃣ Find People Who Also Hate That it Sucks (Build Your Coalition) – Who else is frustrated by this dysfunction? – Who else feels the pain downstream? – Who would immediately benefit from addressing the root cause? 5️⃣ Go from Suck → Scale (Solve & Improve) – Clearly articulate the deeper pain & impact – Form a compelling business case with colleagues who share the pain – Prototype and showcase a small fix (e.g., automated reporting) – Expand your fix to address the systemic issue, causing multiple related frustrations to fade away Great teams don’t just accept what sucks. They identify root causes, collaborate on solutions, and scale their impact. 🔍 What's one thing you'd fix at work tomorrow if you could? 👇 Comment below & tag someone who's ready to fix it with you.

✅ Flow Fix Checklist How to uncover hidden capacity—before buying new machines or hiring more people 1. Calculate Your Takt Time 📌 Takt Time = Available Time ÷ Customer Demand This gives you the pace your process should run to meet demand without overproduction. 2. Measure Actual Process Times 🎯 Track the real time each task takes—not what’s on paper. 3. Identify Workload Per Operator 🛠️ Add up each person’s total task time. Who’s overloaded? Who’s waiting? 4. Compare to Takt Time 📏 If task time > takt time → imbalance. If task time < takt time → possible underutilization. 5. Balance the Line 🔄 Adjust task assignments so each operator stays just under takt time. 6. Watch WIP (Work in Progress) 👀 High WIP = broken flow. Check where it piles up—it often points to the bottleneck. 7. Look for Small Wins ✅ A 30-second fix repeated 100 times = hours saved. Start with low-effort, high-impact changes. 💬 Want help applying this? DM me “FLOW” on LinkedIn and I’ll show you how to apply these steps in your own process—with zero fluff and high ROI.