Everyone wants autonomous teams. Few agree on what autonomy actually means.

In the previous posts, I explored how trust and compliance emerge from structure rather than control, how facts and decisions form the real seams in a system, and how change becomes safer when it is made visible in the model. All of these ideas point toward a question that is often answered too quickly: if systems are inherently connected, what does autonomy actually mean — and where does it truly live?

In practice, autonomy is often described in terms of independence: owning a service, owning a database, deploying without coordination, being left alone. Yet many teams that meet all of these criteria still find themselves blocked, negotiating constantly, or afraid to change anything without asking around.

Independence, it turns out, is not the same thing as autonomy.

Independence tries to remove dependency. Autonomy assumes dependency, but makes it workable. Autonomy only matters where interaction exists. If a team never interacts with others, autonomy is irrelevant. It becomes meaningful precisely when teams must rely on one another and still be able to act with confidence.

This is why autonomy does not live in services or systems. It lives in decisions.

A team is autonomous when it can make certain decisions without asking for permission, and when others can rely on those decisions being made consistently. The boundaries of autonomy are therefore not technical boundaries, but decision boundaries.

In a life and health policy lifecycle, this shows up very clearly. The decision whether a policy can be issued belongs to underwriting. That decision depends on facts produced elsewhere: the product selected in the sales journey, the disclosures provided by the customer, the outcome of pricing and risk assessment. Underwriting depends on all of these, yet it remains autonomous because none of those upstream teams decide on its behalf. They publish facts. Underwriting decides.

This distinction matters more than it first appears. Underwriting is not autonomous because it owns a system or a database. It is autonomous because it owns the decision to accept or decline a policy, and that ownership is understood by everyone involved.

Autonomy breaks down when this clarity disappears.

Many policy platforms struggle not because teams interact, but because authority is implicit. A shared policy record is updated by sales, underwriting, billing, and claims, each adjusting status fields or flags as part of their local logic. No single team owns the meaning of those transitions, yet all of them depend on them. Coordination becomes invisible, embedded in data structures rather than discussed openly. Teams slow down, releases become coupled, and “just checking” turns into a permanent way of working.

In these situations, autonomy is not lost through collaboration. It is lost through shared state without shared understanding.

Publishing facts instead of mutating shared state changes the dynamic. When teams communicate through facts, dependencies become explicit and authority remains local. Sales can state that an application was submitted. Underwriting can state that it was approved. Billing can state that a premium was collected. Each team acts autonomously within its decision space, while still contributing to a coherent policy lifecycle.

This is where the model plays a quiet but critical role. Autonomy cannot be negotiated ad hoc, release by release. It has to be visible. The model makes decision boundaries explicit. It shows which facts exist, which decisions are made, and who owns them. It does not enforce autonomy, but it makes autonomy inspectable.

This matters not only for teams, but also for trust and governance. In regulated domains like life and health insurance, autonomy is often seen as being in tension with compliance. In practice, the opposite is true. When it is clear who can decide on a policy cancellation, under which conditions, and based on which facts, auditors do not need to inspect code paths or process documents. They inspect decision ownership.

Autonomy without authority, on the other hand, fails quietly. Teams are told they are autonomous, but their decisions are overridden later, or require informal approval to be effective. Responsibility is pushed down, while authority remains elsewhere. The result is not empowerment, but escalation, defensive behavior, and an ever-growing layer of process to compensate.

Autonomy is not the absence of coordination. It is coordination that no longer needs negotiation. It is a social contract defined by decisions, sustained by published facts, and protected by clarity. When autonomy is designed this way, teams can change, systems can evolve, and trust can grow without constant intervention.

And that is why autonomy is not a property of teams alone. It is a property of the system they operate in.

Originally published on LinkedIn (2026-01-31): https://www.linkedin.com/pulse/what-autonomy-actually-means-doesnt-gabriel-n-schenker-ajdne