Strategy Execution

How to Improve Coordination in Modern Organizations

– Why Coordination Drifts

Business meeting between four team members

Introduction

Most organizations assume execution problems come from unclear strategy, shifting priorities, or lack of resources.

But in many teams, the real problem is something more subtle: coordination.

Meetings are supposed to keep teams aligned and ensure everyone understands what is happening across projects and programs. Yet in many organizations, meetings gradually become the opposite, a source of fragmentation, lost context, and execution drift.

Research shows that leaders spend a significant portion of their working time simply coordinating work. According to McKinsey, executives spend around 39% of their time in internal meetings, much of it focused on alignment and updates rather than decision-making.

At the same time, analysis of engineering teams shows that meetings consume a large share of productive capacity. A study of over 80,000 engineers and 1.5 million meetings found that engineers spend about 10.9 hours per week in meetings, while managers average nearly 18 hours per week.

When this coordination overhead grows, organizations often lose something critical: program visibility.

Meetings Are Consuming More Execution Time

In complex organizations, coordination becomes a significant part of everyday work.

Teams schedule meetings to:

share updates
align on priorities
resolve dependencies
coordinate cross-functional initiatives

The problem is not that these conversations happen, they are essential. The problem is that the outcomes of those conversations often never make it back into the systems that track work.

Over time, this creates a gap between what teams decide in meetings and what their project tools or reports show.

This is one of the most common reasons organizations experience execution drift.

Plans slowly fall out of sync with reality.

The Engineering Meeting Tax

The impact becomes particularly clear in engineering organizations where deep work is essential.

Research analyzing thousands of engineering teams found that meetings consume a significant share of development capacity. Individual contributors spend roughly 11 hours per week in meetings, while engineering managers spend close to 18 hours coordinating work.

Across a typical two-week sprint, this means that more than a quarter of engineering capacity can be spent in meetings alone.

But the cost is not just the time spent in the meeting itself.

Every meeting also introduces:

preparation time
follow-up communication
context switching between tasks

Together, these effects create what many organizations experience as a coordination tax.

Why Coordination Breaks Program Visibility

As organizations grow, work rarely happens within a single team.

Most strategic initiatives require collaboration across:

product teams
engineering
operations
leadership

This creates a complex network of dependencies. To manage these dependencies, organizations rely heavily on meetings and reporting structures.

But when coordination happens primarily through conversations rather than shared systems, visibility breaks down.

This is where many organizations experience program management visibility problems.

Teams may have:

multiple reporting tools
dashboards and documents
regular status meetings

Yet leaders still struggle to answer basic questions:

What actually changed this week?
Which risks are emerging?
Where are decisions slowing execution?

This is why many PMO leaders say that status reporting doesn’t work the way it should.

The PMO Reporting Problem

Traditional PMO reporting was designed for a slower operating environment.

Reports typically summarize:

milestones
status updates
risk registers

But modern organizations operate at a much faster pace. Decisions happen daily, often in conversations rather than formal reporting cycles.

By the time reports are compiled and shared, the underlying reality may already have changed.

This leads to a familiar pattern:

Teams make decisions in meetings.
Those decisions are partially documented.
Reports are created later based on incomplete information.

As a result, reporting becomes an approximation of reality rather than a reflection of it.

Execution Drift in Cross-Functional Work

The combination of high coordination overhead and fragmented reporting leads to a common problem in modern organizations: execution drift.

Execution drift happens when plans gradually diverge from what teams are actually doing.

It usually develops slowly:

priorities shift in meetings
dependencies change across teams
risks appear but are not recorded immediately

Because these signals are scattered across conversations, emails, and documents, the organization’s shared understanding of execution becomes outdated.

Without clear program visibility, leaders often discover problems only after delivery timelines slip or strategic initiatives fall behind.

From Meetings to Execution Signals

Organizations don’t necessarily need fewer meetings.

They need better ways to capture what happens in them.

Every meeting contains signals that shape execution:

decisions
action items
ownership changes
timeline adjustments

When these signals are captured and connected to execution systems, organizations can maintain a much clearer view of reality.

Instead of relying on manual reporting, teams gain continuous visibility into execution.

A Different Approach to Coordination

One way organizations are addressing this challenge is by connecting meetings directly to their execution systems.

Instead of treating meetings as isolated conversations, they become execution events where changes to plans are captured and reflected automatically.

At In Parallel, this idea is implemented through an Intelligent Management System that connects meeting decisions with execution plans.

An AI note-taker captures decisions and action items in real time, ensuring that updates from meetings are reflected in the shared execution view.

This helps organizations maintain something many teams struggle with today:

a single, continuously updated view of what is actually happening across programs.