by Gary Worthington, More Than Monkeys

Autonomy is one of the most misused words in modern leadership. It’s often treated as a binary switch - either a team is “given autonomy” and left to get on with it, or they are tightly managed with every decision flowing through a leader.

The reality is more nuanced. Autonomy exists on a continuum. Not all teams are ready for the same level of decision-making freedom, and as a leader your job isn’t to declare autonomy and walk away. Your job is to lead them towards it - providing support, context, and direction as they grow.

Why autonomy matters

Autonomy done well produces higher engagement, better decisions, and faster learning cycles. Teams that own their work tend to move with more energy and adapt more quickly to changing priorities. They also enjoy the work a lot more too!

But autonomy without readiness leads to chaos. If a team doesn’t yet have the skills, context, or cohesion to make good decisions, all-out freedom simply shifts decision-making from a leader to a void. That’s when “autonomy” feels more like “no one knows what’s going on”.

Autonomy as a progression

Think of autonomy not as an all-or-nothing state but as a journey through stages:

1. Directed

What it looks like:
You set the direction, make the key decisions, and the team executes. This is often where newly formed teams or teams in crisis start.

Example:
A new cross-functional team inherits a legacy payment system with no documentation. At this stage, you as the leader create the migration plan, define the priorities, and help assign work. The goal is to create stability and reduce uncertainty before you expect the team to own large-scale decisions.

How to progress:

• Hold regular “show and tell” sessions to build shared understanding.
• Involve team members in small decision points (eg. naming conventions, branching strategies) to start building confidence.

2. Guided

What it looks like:
The team makes tactical decisions, but you set the strategic framework and non-negotiables.

Example:
A team is responsible for delivering a new API. You define the API’s core purpose, SLAs, and integration points with other systems. The team chooses their own tech stack and organises the delivery schedule.

How to progress:

• Shift from “Here’s the solution” to “Here’s the problem, how would you solve it?”
• Ask for a proposed plan before giving yours, then workshop it together.

3. Empowered

What it looks like:
The team makes most decisions. You provide guardrails, coaching, and context but are no longer the default decision-maker.

Example:
Your platform team owns cloud infrastructure. They decide when to upgrade Kubernetes, which monitoring tools to use, and how to roll out security patches. You stay close enough to ensure compliance and cost controls are met, but you don’t dictate implementation.

How to progress:

• Introduce peer reviews for architectural changes instead of leader sign-off.
• Encourage the team to present their work and lessons learned to other teams.

4. Self-directed

What it looks like:
The team owns both strategy and execution. You act as a sounding board, mentor, and connector to the wider organisation.

Example:
Your core product team sets their own quarterly goals, aligns with stakeholders without you in the room, and manages their own budget. You attend their planning sessions by invitation, primarily to offer context and challenge assumptions.

How to maintain:

• Keep lines of communication open but don’t hover.
• Periodically review alignment to organisational strategy - not to reassert control, but to ensure everyone’s still rowing in the same direction.

Your role as a leader

If you want a team to thrive at higher levels of autonomy, you can’t just “grant” it. You need to actively build the conditions for it to succeed:

• Provide clarity of purpose — Autonomy without a shared understanding of “why” leads to wasted effort.
• Build capability — Invest in skills, knowledge, and cross-functional understanding.
• Establish guardrails — Define boundaries where autonomy applies and where you still own the decision.
• Give feedback early and often — Feedback is how teams learn to make better decisions next time.
• Model trust — Show you believe in their ability to succeed, even when they stumble.

Knowing when to dial it up

A key skill in leadership is knowing when to loosen the reins and when to pull them in. This isn’t about control for control’s sake, it’s about matching the level of autonomy to the team’s current capability and the stakes of the work.

If a team is consistently delivering high-quality outcomes, understands the strategy, and takes ownership of problems, you can increase their freedom. If they’re missing deadlines, struggling to align, or making decisions in isolation, they may need more structure and support before autonomy can grow.

Autonomy is earned, not gifted

The most autonomous teams I’ve led didn’t get there because I simply “trusted them from day one”. They got there because we built the conditions for autonomy together. We iterated on decision-making, learned from mistakes, and made the rules of the game explicit.

That’s the art of the game: knowing where your team is on the continuum today, and leading them towards the next step without over- or under-steering.

Autonomy is not anarchy. It’s the product of deliberate leadership, patient development, and mutual trust. Get it right, and you won’t just have a high-performing team, you’ll have one that can thrive without you in the room.

Gary Worthington is a software engineer, delivery consultant, and agile coach who helps teams move fast, learn faster, and scale when it matters. He writes about modern engineering, product thinking, and helping teams ship things that matter.

Through his consultancy, More Than Monkeys, Gary helps startups and scaleups improve how they build software — from tech strategy and agile delivery to product validation and team development.

Visit morethanmonkeys.co.uk to learn how we can help you build better, faster.

Follow Gary on LinkedIn for practical insights into engineering leadership, agile delivery, and team performance