Lessons from balancing autonomy, architecture and ownership in a monolithic SaaS product.

It was late on a Thursday evening when I joined yet another “final” release sync.
Four teams were on the call: database, backend, frontend and infrastructure.
Everyone was tired. Everyone had done their part.
And yet, the feature still wasn’t ready to ship.

One team was waiting for an API change, another was debugging deployment scripts and someone else mentioned that the database migration had to be rolled back — again.

That was the moment it clicked for me:

Our problem wasn’t technical. It was organizational.

We had talented engineers, clear priorities and solid code, but we didn’t have accountability.

Lack of Ownership

Many organizations that started with a monolithic product have naturally evolved into a structure of component teams. This type of team is responsible for a narrow slice of the system, usually defined by technology or architecture, not by customer value.

For example:

  • A frontend team that owns the UI layer.
  • A backend team that builds APIs.
  • A database team managing data models and queries.
  • An infrastructure team handling deployments and environments.

It looks efficient. Everyone becomes an expert in their area.
But here’s the catch: no single team can deliver a feature end-to-end.

In a monolithic architecture, this pattern becomes the default.
Each new feature requires at least two, sometime even four teams to collaborate: frontend, backend, database and infra.
That means endless coordination, delayed releases and diluted ownership.

Photo by Zoltan Tasi on Unsplash
Photo by Zoltan Tasi on Unsplash

The Illusion of Ownership

On paper, every team has its own “module.”
Each owns a clear part of the stack.
It looks tidy on an org chart and even cleaner in the codebase.

But in practice?
No one truly owns anything end-to-end.

Our teams deliver code, but they don’t own deployment.
They build features, but they can’t release them independently.
They’re responsible for “their part,” yet the success of the product always depends on three other teams moving in sync.

It creates what I call the illusion of ownership: people feel responsible, but they’re never truly accountable.
And that’s a problem, both technically and culturally.

When two teams share responsibility for the same feature, they both are equally accountable for it at the same rate of 45%. The remaining 10% quietly falls through the cracks.

Over time, the absence of ownership accumulates as lack of stability and performance, fixing what no one feels responsible for, compensating for unclear boundaries.
It breeds a subtle but dangerous culture of avoidance:

“We built our part; the rest isn’t really ours.”

That’s the hidden cost of shared ownership, it feels collaborative, but it erodes accountability.

From Component to Microservice Teams

For many organizations, the next logical step after component teams seems obvious:
If we’ve divided our architecture into parts, why not go one step further and make them independent — with microservices?

After all, microservices promise exactly what we’re missing — autonomy, independent releases, clear ownership.
Each team could own a service end-to-end: from code to deployment, from metrics to monitoring.

But the reality isn’t that simple.

Every company that has migrated from a monolith knows this pattern:

You fix the organizational bottlenecks only to create two technical ones.

For some applications, that approach truly works.

Microservices can enable faster delivery cycles, clearer team boundaries, and give more accountability — especially in large, multi-domain organization.

Nevertheless experience has shown that it’s not a universal answer.

Common challenges include:

  • Fragmented domain models — data consistency becomes a nightmare.
  • Increased operational overhead — CI/CD pipelines, infrastructure as code, monitoring, incident response.
  • Cross-service dependencies — now you debug distributed systems instead of code.
  • The need for platform maturity — observability, deployment pipelines, and DevOps culture must come first.
  • Smaller silos instead of real collaboration — you decentralize architecture but not necessarily accountability.

As one of our engineers put it:

“We’d just be building a microservice version of our current org chart.”

Exactly. And that’s not the goal. That’s not what Conway wanted us to understand.

The Missing 10%: Where Accountability Disappears in Engineering Teams

For many mature products, especially those built over years with a tightly coupled UX or shared state management, the cost can easily outweigh the benefits.

In those cases, evolving the way teams collaborate — not the way code is divided — often delivers better results.

Sometimes, the real solution lies not in splitting the system, but in aligning people and processes around clearer accountability.

Building Autonomy Without Microservices

The challenge with the Thursday release I mentioned earlier wasn’t an isolated incident, it was a pattern.
I started to notice similar situations repeating across different projects:

  • releases delayed by cross-team dependencies,
  • unclear ownership during handoffs,
  • accountability that faded whenever multiple teams had to move in sync.

Over time, these moments revealed something deeper about how our teams were structured.
It wasn’t just about a single project or delivery cycle, it was about how ownership was distributed across the system.

Recognizing that pattern made it clear to me that change was needed.

So instead of rewriting the architecture, I began rethinking how we can improve accountability.
I brought my ideas to my team and together we started discussing what could actually work in our environment.
That’s how we began introducing small but meaningful changes, aimed at strengthening accountability within the monolith, without adding unnecessary complexity.

Here’s how we’re approaching it:

Build a culture of shared accountability

We emphasize end-to-end responsibility, not individual heroics. Ownership isn’t about controlling a piece of the system — it’s about caring for the outcome.
That cultural shift is what ultimately makes autonomy possible inside a monolith.

Redefine boundaries and collaboration

Even inside a monolith, you can design for ownership.
We’re redefining how teams share and guard boundaries, both technical and organizational.
Each team owns a specific domain, but collaboration across domains is encouraged instead of prohibited.
That means fewer “holy territories”.

Reduce dependencies

Dependencies created by component teams generate a lot of cost. We’re systematically identifying and removing unnecessary ones, both in the codebase and in the organization.
That means simplifying internal APIs, decoupling shared modules where possible and challenging every “you must ask team X for that” rule.

Set measurable outcomes

Every team now has clear, measurable outcomes that reflect product success rather than internal activity.
We use metrics like time to release, stability of key modules and adoption of user-facing features.
Metrics bring clarity and clarity brings accountability.

Empower teams to own more of the delivery pipeline

We’re clarifying where platform and infrastructure support stops and where product ownership begins.
This helps teams take on more of the deployment, monitoring and performance responsibility within shared systems.
It’s not full DevOps yet, but it’s a step toward real operational ownership.

Photo by Antonio Janeski on Unsplash
Photo by Antonio Janeski on Unsplash

What’s Next: From Components to Stream-Aligned Teams

Our long-term goal is to evolve into stream-aligned teams, groups that own an entire flow of value to the customer, not just a fragment of code.

That shift doesn’t require microservices first. It requires trust, clarity and a gradual expansion of team autonomy.

We’re working on:

  • Defining what end-to-end ownership means in our context.
  • Developing full-stack and DevOps capabilities within every team, so that accountability naturally extends across the entire delivery pipeline.
  • Building a stronger metrics culture to reinforce accountability.
  • Giving teams visibility into the impact of their work.
  • Reducing organizational dependencies before we break architectural ones.

Because the truth is:

Autonomy isn’t granted by architecture — it’s earned through accountability.

And that’s what we’re building now.

Summary

Component teams can make organizations efficient and scalable, but they often fragment ownership. From my experience true accountability comes from clear boundaries, measurable outcomes, and a culture that connects engineering work to real product value.

Microservices alone don’t create autonomy; people, structure and trust do. It’s entirely possible to build autonomy within a monolithic system — as long as teams are empowered to own outcomes, not just components.

In the end, architecture and organization must evolve together. One without the other will always limit how far a team, and a company, can truly go.

If you’re struggling with the same dilemma — stuck between a monolith and a dream of autonomy — don’t rush to microservices. Start with clarity. Accountability is the foundation of every scalable system, human or technical.