Scaling Decision-Making: How to Stay Collaborative Without Losing Authority
As engineering organizations grow, decision-making becomes one of the hardest things to scale. Too centralized and you become a bottleneck. Too distributed and you lose coherence. The answer is a model where collaboration is genuine, authority is clear, and the reasoning behind hard calls is transparent enough that people can commit even when they disagree.
3–5 min read
Key Takeaways
- Collaboration and authority aren't in conflict — they're complementary
- Clear decision ownership at each level prevents escalation debt
- Resource and priority trade-offs belong at the manager level — not with leads
- Transparency about reasoning builds long-term trust and decision-making capability
- Managing upward is part of the system, not separate from it
The Tension Every Growing Org Faces
As engineering organizations grow, decision-making becomes one of the hardest things to get right.
Too centralized and you become a bottleneck — every call travels up the chain before it can be acted on. Your leads lose agency, your ICs lose confidence, velocity slows. Too distributed and you lose coherence — teams optimize locally, priorities drift, and when something goes wrong, accountability is everywhere, which means it's effectively nowhere.
The answer isn't choosing a side. It's building a model where collaboration is genuine, authority is clear, and everyone knows where decisions live at each level.

Collaboration Is Real — But It's Not Consensus
I'm collaborative by nature. When Product and Engineering disagree on timeline or approach, my default is to sit down together, surface the constraints on both sides, map the trade-offs, and work toward something everyone can commit to.
But collaborative doesn't mean consensus-driven. That distinction matters enormously.
Consensus-driven decision-making requires everyone to agree before you move. In an engineering org, that's a recipe for paralysis. Not every decision can wait for full alignment. Not every stakeholder will agree.
My model: I listen to every viewpoint. I take the expertise in the room seriously. And then the decision is mine.
People can disagree with an outcome and still commit to it — if they trust the process was genuine. That trust is built one decision at a time.
Everyone has a voice. Not everyone has a vote. The leader who genuinely listens and then decides clearly earns more respect than one who pretends to consult but has already made up their mind — or one who can never make up their mind at all.
Where Decisions Live at Each Level
Scaling decision-making requires being explicit about who owns what — before there's a conflict about it.
ICs own technical decisions within their feature scope: how they implement, what patterns they use, how they structure their solution. That's their domain. A manager who routinely overrides IC technical decisions without good reason has sent a message — and it's not a good one.
Leads own decisions that span their team — prioritization within a sprint, technical approach across features, team-level process. They also own cross-team collaboration: when there's a dependency or conflict with another team, leads work it out between themselves before escalating.
Managers own decisions that require org-level authority: resource trade-offs when teams compete for capacity, priority conflicts with multiple legitimate stakeholders, cross-department issues, and anything a lead genuinely can't unblock alone.
The key: this is a routing system, not a gatekeeping system. Most decisions should never reach the manager. They should be made by the person closest to the problem, at the level where the relevant context lives.
Escalation Is a Feature, Not a Failure
One of the most important cultural norms I establish: escalation is expected, and using it isn't a sign of weakness.
Leads resolve what they can. When they hit something genuinely outside their authority — a cross-department conflict, a resource constraint requiring a trade-off decision above their level, something with political implications — they bring it to me. That's not a failure of leadership. That's exactly how the system is supposed to work.
The failure is the absence of early escalation. Leads who absorb problems they shouldn't own — either out of fear or because nobody made the boundary clear — turn small, manageable issues into large, urgent ones.
I make the expectation explicit: the things you can't unblock are mine to handle. Bring them early, with context, and we'll move fast. Don't sit on something for two weeks hoping it resolves, then surface it the day before it breaks.
Transparency Is What Makes It Scale
The piece most leaders underinvest in: explaining the reasoning behind hard calls.
When I make a difficult decision — one that affects timelines, resources, or competing priorities — I tell my leads why. Not a polished rationale. The actual reasoning: here's the constraint, here's the trade-off, here's why this path over the alternatives.
This does three things. It builds trust even when people disagree — a team that understands the reasoning can commit even if they'd have chosen differently. It teaches leads how to think about trade-offs themselves, so they start making better decisions at their level without escalating everything. And it creates a culture where decisions are understood, not just handed down.
people can disagree with a decision and still commit to it — if they trust the process and understand the reasoning. Transparency isn't just respectful. It's how you build an org that executes even when it doesn't unanimously agree.
Managing Upward Is Part of the System
Scaling decision-making inside your org is only half the equation.
I loop my director in early on anything significant — performance issues before they escalate, resource constraints before they become crises, competing priorities before they need a decision I can't make alone. That advance notice is what gives leadership the ability to support rather than block when the hard call comes.
Proactive upward communication is a standard worth holding regardless of whether it's reciprocated. It builds credibility, creates the standing to ask for the same in return, and keeps the entire decision-making system functioning end-to-end.
Related
Why I Don't Do Technical Interviews for Senior Engineers
By the time someone has a decade of experience on their resume, I already know they can code — and write correct code at that. What I don't know, and what actually determines whether they'll thrive on my team, is whether they're curious, passionate, and wired to build great things. That's what the interview is for.
Read more ArchitectureTaming 50 Million Callbacks with Event-Driven Architecture
A legacy .NET HttpHandler buried inside the customer portal was processing webhook callbacks synchronously — and at 20M+ messages a month, vendor retry storms inflated that to 75 million callbacks with 90-second processing latency. We replaced it with an Azure Function that acknowledges in milliseconds and routes to channel-isolated processors via Service Bus, dropping latency to sub-second and eliminating the retry cascade entirely.
Read more