So You Want To Adopt Scalable Agility In Your Project Management
Most people I talk to are drowning in project management tools. They've got Jira tickets for everything, a notion dashboard for the dashboards, and a standup that could've been an email. The trend right now is "scalable agility" — the idea that you can keep small-team speed while growing into something more structured. Lauren Schermerhorn has been vocal about this space, and her work touches on how teams actually keep it together when they stop being five people in a room. Her approach isn't particularly novel if you've been doing this for a while. The core idea is that agile processes need to scale without turning into bureaucracy. That means designing workflows that add minimal overhead at each level of growth. It sounds simple, which is exactly why most people do it wrong. I ran a project last year where we tried to implement something similar for a team that went from eight people to thirty in six months. The framework we used was loosely based on what she describes publicly. Here's what actually happened versus what the theory says should happen.
The theory says: set up clear roles, maintain iteration cycles, use lightweight documentation, and let communication flow through established channels. The reality: by month three, we had so many "agile champions" and "process owners" that nobody knew who actually made decisions. We lost about two weeks of throughput trying to reorganize roles that weren't even that important in the first place. The workaround was brutal but straightforward. We stripped everything back to three actual responsibilities: who owns the product direction, who owns the delivery schedule, and who unblocks the team when something breaks. Everything else — the fancy role titles, the secondary processes, the additional ceremony — went away. Productivity recovered within a sprint.
How Scalable Agility Actually Works In Practice
There are a few mechanics that matter more than the buzzwords. First, decision boundaries. Every team member needs to know what they can decide without escalation. When I worked with a mid-size engineering org, they had a simple rule: anything under two days of effort, you handle it. Above that, you tag someone. That's it. No forms, no approvals. It cut our average decision latency from four hours to about forty minutes. Second, information density per meeting. Most teams I see running agile processes have meetings that could be asynchronous updates. A daily standup that runs twenty minutes instead of fifteen is usually a process problem, not a communication problem. The fix is almost always restricting attendance. If someone doesn't need to make or receive a decision in that meeting, they shouldn't be there. We saw a infrastructure team reduce their sync time by sixty percent just by applying this rule. Third, and this one surprises people: scaling documentation inversely to team size in some categories. When you're small, you document heavily because you need the institutional knowledge. As you scale, certain types of documentation become noise. Runbooks for common operations should actually get shorter, not longer. The assumption is that more people means more edge cases to cover. In practice, the edge cases were already being handled by senior people informally. Writing them down in full detail just created maintenance burden with little benefit.
Get the Full Details
The counter-intuitive part most beginners miss is that scalable agility requires you to deliberately leave gaps. You can't process-everything from day one. If you try to build perfect visibility into every workflow before you hit twenty people, you'll be building process for process's sake. The gaps are where the actual work happens. You fill them in reactively when they cause real problems, not proactively when you think they might. I learned this the hard way with a client who wanted to implement full sprint retrospectives across four distributed teams. Four hours of meeting time per week, minimum, for eighty people. The retrospectives were technically "done," but nobody felt like they produced anything actionable. We replaced them with a single shared document where anyone could flag process issues, and we reviewed it together every two weeks. Same outcome, thirty-five hours of meeting time saved per month.
Common Pitfalls That Will Slow You Down
One thing I see constantly: teams adopting scaling practices from organizations ten times their size. What works for a hundred-person engineering department often breaks a twenty-person team. The practices assume certain levels of complexity that simply don't exist yet. You'll be managing process instead of managing work. Another pitfall is treating agility as something you "implement" rather than something you cultivate. You can't roll out a scalable agility framework the way you roll out a new software tool. It requires repeated small adjustments based on actual team feedback. The teams that succeed are the ones that adjust their processes every couple of weeks, not the ones that design a perfect system upfront. Here's a specific scenario where scalable agility breaks down completely: highly regulated environments where every change must be auditable. I worked with a fintech startup that tried to apply these principles while also maintaining SOC 2 compliance. The tension between fast iteration and documented change management made the standard agile approach impossible. They ended up using a hybrid — strict change control on production systems, lightweight iteration on everything else. It wasn't elegant, but it worked.
A Practical Starting Point
If you're looking to adopt something along these lines, here's where I'd suggest beginning. Pick one team. Run two-week cycles with a clear definition of done. Hold a brief retrospective at the end of each cycle where the only question is "what should we change next cycle?" Don't overthink the answers. Implement the top suggestion immediately, even if it's small. Track your cycle time — how long it takes from starting work on something to actually delivering it. This number will tell you more about your process health than any dashboard. When cycle time starts creeping up, that's your signal that process is accumulating. Strip something away. The goal isn't to build the perfect system. It's to build a system that improves itself. That's the part that actually scales. The specific practices matter less than the feedback loop that lets them evolve.
There are resources online if you want to explore this further. The general concept of scalable agility isn't tied to any single person's framework, though Lauren Schermerhorn has contributed to the conversation around how project management adapts as teams grow. Look for practical examples rather than theoretical models. The people who've actually done it tend to write about what broke, not what worked. Good luck with it. You'll probably need to adjust your approach halfway through anyway.
