In which a garbage can teaches us about leadership

Understanding decision-making when complexity outruns structure

I like exploring how organizations actually work and the real-life decision-making underneath. Sometimes I even prefer this to watching Netflix. Sue me 😎

Recently, that curiosity led me to the “Garbage Can Model”, a 1972 concept introduced by Cohen, March, and Olsen. The name might raise an eyebrow, but the idea is surprisingly accurate: decisions often emerge when problems, solutions, and people collide by chance inside a very metaphorical garbage can.

The model describes how decisions get made in what the authors called organized anarchies.

If you’re thinking, “How is this still relevant 50 years later?”, welcome to the club, and keep on reading.

That sounds dramatic, but it simply means environments where:

• goals are unclear or keep shifting

• cause-and-effect relationships are fuzzy

• people drift in and out of decisions

I’m quite sure that if you ever worked in academia, a startup, a fast-growing tech company, or any matrixed organization… this feels familiar.

It certainly does to me. I saw it at university. I see it in tech.

And every time I see some patterns, I want to understand whether I’m the only one noticing them.

Spoiler: Usually, I’m not.

The patterns that reveal a garbage-can-like decision system

These patterns are not signs of failure. They simply show that the environment is moving faster than the structure that supports it.

Priorities shift faster than teams can adjust

A team leaves a planning meeting with a clear direction. Two days later, another leader announces a new “urgent” priority. By Friday, both priorities compete, and people quietly choose whichever one they think will cause less trouble. Execution relies on interpretation rather than alignment.

How it feels:

“We keep planning, but none of our plans survive Tuesday.”

Decision-makers rotate unpredictably

A decision that belonged to one director suddenly gets rerouted to another. Someone new joins the meeting and changes the direction. Someone else drops out, and the group reverses its stance. The outcome depends on who happened to be available on Zoom or in the room at that moment.

How it feels:

“Who actually decides this? Anyone? Everyone? No one?”

Ideas wait for a problem

Teams keep pitching the same idea — a process improvement, a tool, a feature — but nothing happens until a fire breaks out. Suddenly, the old idea is resurrected as the solution… not because the idea changed, but because the timing (and attention) did.

How it feels:

“So… this idea was good months ago, but we needed a crisis to act?”

Problems never fully land

A recurring issue pops up every quarter: a customer problem, a build pipeline issue, a handoff gap. Each escalation triggers a fresh round of discussions, but no single person or team ever owns the fix long enough to close it. The problem keeps resetting to zero.

How it feels:

“Didn’t we talk about this already? Why is it back?”

Decision timing feels inconsistent

A major technical decision takes weeks of discussion. Meanwhile, something more complex is decided in five minutes because everyone happened to be in the room. People stop understanding which topics deserve urgency and which deserve patience.

How it feels:

“I can’t tell what actually matters or how urgent anything is.”

High dependency on windows of opportunity

A cross-functional effort only moves forward when the right trio of people has time in the same week. If one person is on vacation, in onboarding, or stuck in another fire, the entire initiative goes on pause. Momentum becomes accidental instead of intentional.

How it feels:

“This thing only moves when the stars align.”

Meetings substitute for decisions

Teams discuss an issue in planning. Then again in stand-up. Then again in a cross-team sync. Everyone can describe the problem in detail, but no one can say who will decide or when. The conversation moves, but the decision doesn’t.

How it feels:

“We talk about this constantly, but nothing changes.”

Firefighting dominates planned work

The plan for the next week looks solid on Friday. By Tuesday, half the team is pulled into escalations, hotfixes, last-minute “small asks,” or urgent alignment calls. Planned work slips quietly into next week — or next quarter.

How it feels:

“I spend more time reacting than doing my real job.”

Does this mean the organization is broken?

No. Not necessarily.

It means the complexity around you is moving faster than the structure beneath you. This happens in:

• startups and scale-ups

• innovation labs

• matrix organizations

• high-growth companies

• cross-functional environments where teams depend heavily on each other

The Garbage Can Model explains why things feel chaotic. But it doesn’t explain how to stabilize anything. Leaders sitting with only that insight end up stuck between a rock and a hard place.

That is where Padgett enters the chat eight years later.

The goal is not to eliminate chaos, it is to structure it

In 1980, John Padgett published Managing Garbage Can Hierarchies, which adds the leadership perspective that the original model didn’t include.

Padgett’s core point:

Organizations do not remove chaos. They build systems that channel it.

So… Healthy teams create:

• filters for what gets attention

• boundaries for who decides what

• decision arenas* where decisions are made intentionally, not accidentally

• buffers that absorb ambiguity

• rhythms that give timing some predictability

*Decision arenas are dedicated places where real decisions get made, not whatever Slack DM or hallway someone happened to be standing in.

Chaos doesn’t disappear. It becomes contained. Clarity doesn’t emerge magically. It becomes supported. But if you’ve ever worked in a modern tech environment, you probably know this isn’t enough.

Because once you start structuring chaos, you also create new challenges.

Where theory meets the messy reality of real teams

This isn’t theory living on a whiteboard. It’s what shows up the minute you work across Product, Engineering, Operations, Support, or any team that depends on another team to get anything done.

These are the places where the model stops being a concept and starts feeling uncomfortably familiar.

Fast-moving tech companies (startups, scale-ups, hypergrowth)

Everything moves faster than the structures designed to support it.

This is where you’ll see:

• goals shifting weekly as new insights or pressures emerge

• metrics changing mid-quarter (and sometimes mid-sprint)

• people being pulled into new initiatives because “you’re the only one who can do this fast”

• solutions appearing before the problem is fully defined

• tools and frameworks being adopted because they’re trending, not because they’re needed

It’s not dysfunction.

It’s the byproduct of speed outpacing alignment.

The lived experience:

“Are we still doing what we agreed on Monday, or did the world change again overnight?”

Matrix organizations (multiple bosses, dotted lines, dual accountability)

This is where clarity goes to retire.

You’ll see:

• a PM’s “yes” becoming Engineering’s “maybe” and Ops’ “it depends”

• two people thinking they own a decision and three people thinking no one owns it

• decisions depending more on who is in the room than on job titles

• meetings where alignment seems achieved… until a stakeholder joins the next meeting and resets everything

• participation that fluctuates based on availability, not ownership

Matrix orgs create participation drift: people float in and out of decisions like characters entering and exiting a stage.

The lived experience:

“I thought we agreed… but apparently we didn’t agree enough.”

Innovation teams, R&D, skunkworks, labs

Here, ambiguity isn’t a bug — it’s the operating system.

You’ll see:

• problems being reframed weekly as new insights surface

• solutions wandering freely until they latch onto something useful

• experiments that spawn new experiments

• timing that depends on curiosity, not sequence

• collaboration that looks like organized improvisation

Creativity thrives here, but clarity needs to be coaxed into existence.

The lived experience:

“What exactly are we building? Depends on the day — and honestly, that’s part of the fun.”

Cross-functional, interdependent teams (anything involving Product + Eng + Ops + Support)

This is where Garbage Can dynamics go pro.

You’ll see:

• conflicting priorities landing at the same time

• decisions that require five teams but only two can attend the meeting

• problems being escalated from different sides with different narratives

• solutions proposed before anyone fully agrees on the problem

• timing bottlenecks because one team is in planning, another is in delivery, and another is in crisis mode

Everyone’s doing their best — but they’re doing it inside different calendars, different rhythms, different pressures.

The lived experience:

“We’re aligned in theory… but reality didn’t get the memo.”

Why this matters

None of this is abnormal. It’s what the model was built to describe. This is the world many modern teams work in — whether they like it or not.

Seeing these patterns is useful, but knowing they exist isn’t enough. The real value comes from understanding what leaders can actually do inside environments that behave this way.

Five lessons from the model that leaders need today

Here are a few things this model clarified for me. Not theory, just the patterns I’ve observed in real teams.

1. Recognize when you’re in a garbage can

If goals keep shifting, the root cause is unclear, and people move in and out of decisions, trying to force a perfect linear plan usually makes things harder.

Sometimes solutions really do find their problems later. Sometimes timing shapes the outcome more than logic.

Noticing you’re in this environment is half the job. It helps you adjust your expectations, not your standards.

2. Control access intentionally

Who is involved in a decision often matters more than the agenda itself.

Smaller groups bring clarity. Bigger groups bring perspectives. And both can be useful — as long as you’re intentional. Make the circle too small and you miss context. Make it too big and decisions drift.

It’s less about the “right size” and more about choosing the size that fits the decision.

3. Treat attention like a scarce resource

Everyone’s attention is limited, especially in high-change environments.

When every problem finds its way to every decision-maker, urgency becomes the default, and everything feels important.

A few gentle filters go a long way:

• what gets routed where

• who genuinely needs visibility

• what can wait

• what needs escalation

Protecting attention isn’t avoidance, it’s what keeps teams moving without burning out. Protect attention, or everything becomes a fire.

4. Use timing as a leadership tool

Timing sends a message, even when you don’t intend it to.

You’ve probably done this without naming it:

• “Let’s not decide this during launch week.”

• “These three topics belong together.”

• “Let’s wait until X is back with context.”

Choosing when to decide something shapes how well it lands. It’s not about delaying. It’s about choosing the right moment so the decision sticks.

5. Create healthy escape valves

Not every conversation is ready to become a decision. Some topics need a separate discussion, some need time, and some become clearer once something else moves first.

This is where structured avoidance comes in. It’s not procrastination; it’s being thoughtful about when a decision will actually lead to progress instead of forcing it at the wrong moment and making everything worse.

Understanding these dynamics helps, but applying them in real teams is another story entirely. Even the best intentions can create unexpected chaos. Ask me how I know.

Where good intentions create unexpected chaos

Even with the best intentions, the tools that bring order can easily create a new kind of chaos. Every helpful intervention has a shadow side.

1. When you limit access too much

Keeping decision-making circles small does create clarity — until it doesn’t.

What leaders intend: Reduce noise, create focus, avoid never-ending discussions.

What actually happens:

• People feel decisions are happening behind closed doors

• Teams question legitimacy because they weren’t included

• Critical information is missing because the person with the context wasn’t invited

• Others re-argue decisions because they don’t understand the “why”

Instead of alignment, you get quiet pockets of resistance.

Every leader has heard the dreaded: “Wait, who decided that?”
That’s the symptom.

Disclaimer:

This one sets me off every time. Every. Time. When someone chooses what I should or shouldn’t know, they’re not saving time — they’re creating avoidable fires. And guess who ends up cleaning up the chaos they didn’t see? Exactly. That’s my personal villain origin story.

For me, it’s simple: if someone decides what I “need to know,” they just volunteered to handle the consequences.

Spoiler: they rarely do.

2. Filter attention too hard

Leaders often try to protect their teams by being thoughtful about what they expose them to. They think they’re shielding them from noise.

What leaders intend: Reduce distractions, keep people focused, maintain momentum.

What actually happens:

• Teams lose sight of how their work connects to others

• Important dependencies stay hidden until they blow up

• Multiple teams unknowingly solve the same problem in parallel

• Work streams collide because two teams make progress that contradicts, blocks, or rewrites each other

What “work streams collide” really means in tech:

• Engineering builds something Product didn’t expect, and the plans have to change

• Two teams ship features that break each other’s assumptions

• Operations rolls out a process that makes Support’s workflow harder

• A new service launches, but no one told the team managing the integration points

• One team introduces a new tool that another team isn’t ready for

Everyone is doing good work. Just… not the same work. Filtering helps, but over-filtering blinds people.

The result is uncoordinated brilliance that produces company-wide confusion… usually visible right before a release, a deadline, or (everyone’s favorite) a customer escalation.

Ooops.

3. When timing becomes a message you didn’t mean to send

Leaders communicate through timing all the time, without realizing teams are reading that timing as meaning.

What leaders intend: Wait for better context, avoid making a rushed call, or time a decision when the right people are available.

What actually happens:

• Teams think leadership is stalling or avoiding tough calls

• Problems get worse while everyone waits

• Decisions pile up and create artificial urgency

• Work is blocked because no one knows whether to proceed

• People start guessing the “real reason” things aren’t moving

In tech companies, timing is often louder than the decision itself:

• PMs wait weeks for leadership “alignment” and assume priorities changed.

• Engineering pauses work because a decision keeps getting delayed, and assume it’s out of scope.

• Operations holds off on improving a process because they think leadership lost interest.

• A sudden decision appears, and everyone assumes a crisis happened behind the scenes.

People don’t just react to “what” leaders decide. They react to “when” leaders decide.

Timing communicates intent, even when you say nothing. A perfectly reasonable decision delivered at the wrong moment still feels unreasonable.

Leaders often think the content of the decision is the communication. But teams read the timing around it, too. Speed, delays, urgency, silence, “we’ll come back to it,” or “we need more time” — these become signals about priority, trust, risk, or pressure.

4. Create too many escape valves

Healthy organizations create space for conversations that aren’t ready to be decisions yet. That’s good. But many “let’s park this for now” moments never come back. Sometimes parking lots turn into landfills.

What leaders intend: Give teams breathing room, reduce pressure, avoid forcing a premature decision.

What actually happens:

• Issues get postponed so many times that no one knows who owns them

• Teams lose trust that leadership will ever address uncomfortable topics

• People slow down because they don’t want to invest in work that might change

• Escalations return bigger and messier than before

• Parked topics haunt unrelated decisions because they never truly closed

In tech companies, black holes look like:

• A cross-team dependency that never gets clarified

• A platform upgrade “we’ll get to next quarter”… for six quarters

• A role or ownership question no one wants to commit on

• A recurring customer problem everyone keeps discussing, but no one closes

• A tech debt decision that moves sprint to sprint like a ghost

A good escape valve relieves pressure. A bad one becomes organizational limbo.

5. When local clarity becomes someone else’s chaos

This is the silent trap: a team improves its own system… and unintentionally makes life harder for everyone else.

What leaders intend: Clean up their area, clarify ownership, streamline decision-making.

What actually happens:

• Other teams don’t know the process or timeline changed

• Assumptions change in one group but not in another

• One team’s “clarity” becomes another team’s confusion

• Local improvements break cross-team workflows

• Conflicts surface only after the work is already done

This is painfully common in tech, for example:

• Engineering adds “just a few steps” for efficiency. Product doesn’t know. A two-week feature becomes a four-week grind. The deadline evaporates, Product gets grilled, and you get dragged in behind them.

• Product tweaks requirements mid-implementation. Engineering never hears. Halfway through, someone announces a “small update” that requires a not-so-small refactoring of the code. Yay.

• Operations introduces a new workflow to “streamline things,” and Support learns about it when their queue slows to a crawl, and Engineering gets dragged in to figure out why.

Everyone is optimizing in good faith.

When teams optimize in isolation, even the best improvements turn into accidental friction for everyone else. Without shared context, optimization becomes fragmentation.

Everything is connected (whether we plan for it or not)

The Garbage Can Model explains the chaos inside a single decision or a single team.

But real organizations aren’t isolated. They’re ecosystems.

• Engineering affects Product

• Product affects Operations

• Operations affects Go-to-Market teams

• Strategy affects all

This is why “we fixed it in our team” rarely fixes anything.

If other teams don’t know:

• who owns what

• what decisions are already in motion

• what assumptions others are making

• how issues are getting routed

… then your “local clarity” quickly becomes someone else’s chaos.

I’ve seen this so many times I could write a textbook about it. With case studies. And probably a sequel.

The glue that holds cross-functional chaos together

It’s not heavy processes that keep teams aligned. It’s a few lightweight practices that quietly connect the dots.

Clear routing so teams know who owns what and why

A simple ownership map on Confluence or Notion for things like API decisions, customer escalations, or production issues, so no one has to guess who to talk to.

Lightweight cross-team check-ins

A 10–15 minute weekly Product–Engineering sync or an Ops–Support touchpoint, often as a recurring Slack huddle or short calendar slot, to catch conflicts before they hit sprints or customers.

Shared context about where decisions get made

A small Confluence page that spells out which decisions happen in roadmap reviews, architecture reviews, or leadership discussions, so everyone knows the “right room” for each type of decision.

Fast feedback loops when something changes

A quick Slack post in the relevant channel (“Heads up: requirements updated” or “New workflow starting next Monday”) so changes don’t arrive as surprises when the work is already in motion.

Clear escalation paths for cross-team impact

A visible “where to escalate what” list or Slack workflow for when dependencies threaten a launch or customer issues need broader visibility.

Dials, not switches

When these lightweight connectors exist, work moves with less friction and far fewer surprises. And the surprising part is how often it doesn’t take a grand redesign — just a small adjustment in how information flows or how people sync, and then sticking to it. The real skill is being calibrated enough to notice those small shifts. These aren’t switches. They’re dials.

This sets the stage for the real leadership work: building the conditions where good decisions can actually happen.

Build conditions instead of relying on heroics

Most leadership advice focuses on the “right” decision. The Garbage Can Model and Padgett’s extension point to something deeper:

Good decisions don’t come from perfect logic. They come from good conditions.

Conditions where:

• the right work reaches the right people

• attention goes where it matters

• timing is deliberate

• participation is intentional

• ambiguity is absorbed instead of amplified

Great decisions come from great conditions, not lucky moments.

Clarity isn’t accidental. It is built on purpose. Chaos is real. Good leadership is intentional.

If you’ve met your own version of organized anarchy, I’d love to hear about it. Some days it feels like half our decisions end up in the same can anyway — at least we can compare notes.