The Balanced Coupling Model

A comprehensive reference for understanding the Balanced Coupling model as described by Vlad Khononov. This document synthesizes the full model from the companion blog at coupling.dev, covering its foundations, dimensions, balancing mechanics, relationship to prior coupling models, and connections to domain-driven design.

1. Foundations: Why Coupling Matters

1.1 Coupling Is Not the Enemy

The term "coupling" has long been synonymous with bad design. The balanced coupling model challenges this assumption. According to the dictionary, coupling is simply a device for connecting parts. If a system is a set of components interacting to achieve a goal, then coupling is what connects those components and makes it possible to achieve those goals. Coupling is what makes the value of a system greater than the sum of its parts.

You cannot build a system out of fully independent components — that would go against the very definition of "system." The question is not whether to couple, but how to couple. Some forms of coupling lead to modularity; others create complexity. The balanced coupling model treats coupling not as a nuisance to eliminate but as a design tool to wield deliberately.

1.2 Complexity (via Cynefin)

The model adopts the Cynefin framework's definition of complexity:

• Clear (Simple): You make a change and know exactly what the outcome will be.
• Complicated: You don't know the outcome, but an expert does and you can consult them.
• Complex: The only way to determine the outcome is to make the change and observe what happens. Cause and effect can only be identified in hindsight.
• Chaotic: No identifiable relationship between actions and outcomes, even in hindsight.

In software design, complexity means a system where the outcomes of changes are unpredictable. The goal of modular design is to avoid situations where the effect of a change can only be identified in retrospect.

Crucially, complexity is subjective — it is a function of both system design and our cognitive limits:

complexity = f(system design, cognitive limits)

Studies suggest humans can hold only 4 +/- 1 units of information in working memory simultaneously. When the information required to make a change exceeds this cognitive capacity, the design is complex.

1.3 Modularity: The Opposite of Complexity

If complexity makes change outcomes unpredictable, modularity is its opposite. A modular design satisfies two criteria:

1. It is clear what parts of the system need to change.
2. The outcome of the change is clear and predictable.

Modularity extends a system's goals into the future. It doesn't mean preemptively implementing future requirements — that's impossible. It means making the implementation of reasonable future changes easy by minimizing the cognitive load required.

A system is a set of components interacting to achieve goals. Even a "big ball of mud" can achieve its current goals. Modular design extends the system's goals by ensuring it can continue to achieve goals as they evolve.

1.4 The Shared Cause

Complexity and modularity are contrasting concepts driven by the same fundamental cause: coupling. The way components are connected determines whether the system is modular or complex.

2. The Three Dimensions of Coupling

When two components are coupled, the connection between them — not the components themselves — is what determines modularity or complexity. The balanced coupling model evaluates this connection along three dimensions: integration strength, distance, and volatility.

2.1 Integration Strength (Knowledge)

Integration requires components to exchange knowledge about each other. The more knowledge is shared, the higher the probability that a change in one component will trigger cascading changes in others.

Rather than trying to "measure" knowledge quantitatively, the model categorizes types of knowledge. Each type involves significantly different amounts of shared knowledge. This is the Integration Strength model, which identifies four levels (from strongest/most knowledge to weakest/least):

Intrusive Coupling (Strongest)

Occurs when private interfaces or implementation details are used for integration — internal databases, private objects, undocumented APIs. We must assume all knowledge about a component's implementation is shared. Intrusive coupling is both fragile and implicit — the authors of the "intruded" component may not even know the integration exists.

Corresponds to content coupling (pathological coupling) in the classic module coupling model.

Functional Coupling

Shifts focus from how a component is implemented to what it implements: its functional requirements. Occurs when multiple components share knowledge of their business requirements and must change together when those requirements evolve.

An extreme case is duplicated knowledge — the same business rule implemented in both frontend and backend. If a specification change isn't reflected in both simultaneously, the system enters an inconsistent state.

Like intrusive coupling, functional coupling can be implicit: duplicated business logic in components that are not explicitly coupled yet still need to change together.

Corresponds to common, external, and control coupling in the classic module coupling model.

Model Coupling

Occurs when components share knowledge of a business domain model. If the model changes — due to new domain insights — all coupled components must change accordingly.

Domain-driven design emphasizes working with multiple specialized models rather than one massive all-encompassing model. Model coupling arises when components share one of these models.

Corresponds to stamp coupling in the classic module coupling model.

Contract Coupling (Weakest)

The lowest level of shared knowledge. An integration contract encapsulates implementation details, functional requirements, and business models, making integration explicit and stable.

Design patterns that introduce contracts include: Facade, Open-host service / Published language (DDD), Anti-corruption layer (DDD), Data transfer objects (DTOs).

Corresponds to (and refines) data coupling in the classic module coupling model, distinguishing between internal models and explicit integration contracts.

The Implicit-Explicit Spectrum

The four levels of integration strength also reflect how implicit or explicit the shared knowledge is:

• Contract coupling = most explicit
• Model coupling = explicit but broader
• Functional coupling = can be implicit
• Intrusive coupling = most implicit and fragile

Degrees of Integration Strength

Within each level, finer-grained comparisons are possible using the levels of connascence:

• Static connascence levels (name, type, meaning, algorithm, position) can compare degrees of contract and model coupling.
• Dynamic connascence levels (execution, timing, value, identity) can compare degrees of functional coupling.

2.2 Distance

The physical and logical distance between coupled components affects the cost of change. It is significantly easier to co-evolve two methods in the same file than two objects in different microservices or separate systems.

Distance increases through levels of abstraction: methods -> objects -> namespaces/packages -> (micro)services -> systems. At each level, the cognitive effort and coordination cost of simultaneous change increases.

Distance Is Relative to the Observed Level of Abstraction

Distance is not an absolute measure — it is relative to the level of abstraction being analyzed. The model is fractal: the same balance rule applies whether you are looking at methods within a class, classes within a module, modules within a service, or services within a system.

At any given level