---
title: "Modularity"
description: "Modularity is building the product as independent units with a fixed way of fitting together, so any unit can be replaced, added or made by someone else…"
canonical: https://moa.giglabo.com/strategies/modularity/
locale: en
---

# Modularity

> Markdown twin of https://moa.giglabo.com/strategies/modularity/ — the same content as the HTML page, a fraction of the bytes.
> Every page of this site has one: append `.md` to any URL, or `index.md` to a directory URL.
> Site structure and the full page list for agents: https://moa.giglabo.com/llms.txt

Category: Speed and scale · Role: Holds · Depth: 3

Gist: independent units usable in combinations

## Moats

- [#20 Developer ecosystem](https://moa.giglabo.com/moats/20/) (direct, depth 3 · Drill rig) — A fixed joint lets outsiders make units for your system; the units they make are their capital sunk into your interface, and that is the Developer ecosystem.
- [#6 Integrations](https://moa.giglabo.com/moats/6/) (direct, depth 2 · Excavator) — Every unit that connects your system to a tool outside it is an Integration carried by the system, written by whoever made the unit rather than by you.

## Summary

Modularity is building the product as independent units with a fixed way of fitting together, so any unit can be replaced, added or made by someone else without touching the rest. The edge is that third parties can make units and buyers can combine them. It holds through a Developer ecosystem of unit makers and through the Integrations each unit carries.

## How it works

The mechanism is a fixed joint. A brick has one way of locking to another brick, so a brick made this year fits a set from decades ago and a brick made by a stranger fits both. Once the joint is fixed and public, the number of things that can be built with the units grows faster than the number of units, and anyone can add a unit without asking. The product stops being a thing you make and becomes a system others extend.

That is where the edge lives: the value of your units is set by all the other units they fit, and most of those you did not make. A rival offering a better single unit with a different joint competes against the whole system, not against the unit. The cost is the joint itself. It has to be decided early, kept stable for years and tolerated even when it is no longer the best design, because changing it strands every unit already made.

## Why it holds — or only takes

Modularity holds because a fixed public joint invites others to make units, and every unit they make is their investment locked to your system. That is a Developer ecosystem: plugin authors, module makers, theme builders, each with a sunk cost that moves with you. Each unit that plugs into a tool outside the system is an Integration you got without writing it. The ecosystem is a drill rig and resists AI; the integrations are an excavator, and an agent can now regenerate them. The condition the hold rests on is the stability of the joint — a module system that breaks its interface every year has no ecosystem, only a changelog.

## Do you have it

- Units made by people you have never met sell alongside yours and fit without adaptation.
- Your interface specification has not broken in years, and third parties cite that as the reason they build.
- A buyer can replace one unit and keep the rest running, and does.
- The units others make outnumber the units you make.

## How to dig it

- Define the joint before the units: the interface between parts is the product, the parts are the proof.
- Publish the specification and keep it stable; a module system is trusted for its history, not its design.
- Make the first units yourself, well enough that a buyer can assemble something useful from your parts alone.
- Give unit makers a place to be found — a directory, a store, a registry — so their work sells.
- Keep the joint open to strangers; a licence that requires your approval per unit kills the ecosystem before it starts.

## How it erodes

- A rival publishes a competing joint and enough unit makers adopt it that the two systems split the market.
- You change the interface and every unit already made stops fitting; the makers do not come back.
- Integrated designs beat modular ones on size, cost or performance, and buyers stop valuing the choice.
- The unit makers consolidate, and the biggest of them becomes a rival with its own system.

## Solo, without capital

One person can design a joint and ship the first units, and can build the Integrations side alone: a plugin format, a stable file schema, a small registry. The Developer ecosystem is the part that needs other people, and other people need a reason — users, or a niche nobody else serves. Alone, the realistic move this quarter is a module system with three good modules and a specification that promises not to break. The rest arrives with the audience or not at all.

What the matrix says of its moats:

- [#20 Developer ecosystem](https://moa.giglabo.com/moats/20/) — Solo: ~ partly · Capital: ◐ medium · AI: ↑ AI-resistant · Rent: ~ partly
- [#6 Integrations](https://moa.giglabo.com/moats/6/) — Solo: ✓ solo-reachable · Capital: ◐ medium · AI: ↓ under attack · Rent: ~ partly

## In nature, in business

Nature: —

Business: LEGO, prefab buildings

- **LEGO** — Has kept the brick's geometry unchanged for decades, so a brick from any set locks into any other and every old set adds value to a new one.
- **WordPress** — Fixed a plugin and theme interface early and kept it, so most of what a site does is made by third parties and not by the project.
- **Framework** — Sells a laptop whose ports, mainboard and keyboard are swappable modules, so a buyer upgrades one part and keeps the rest.

## Combines with

- [Composability](https://moa.giglabo.com/strategies/composability/) — Units are the parts and composability is what makes their assembly in many configurations worth building; the two are the same dig from different ends.
- [Standardization](https://moa.giglabo.com/strategies/standardization/) — A joint that has become a shared standard is one every unit maker already knows how to fit.
- [Malleability](https://moa.giglabo.com/strategies/malleability/) — A product that is easily modified is one where the units can be swapped; modularity is how that is built.

[This strategy on the map](https://moa.giglabo.com/strategies/?view=lanes&hl=modularity)
[Map this combination](https://moa.giglabo.com/strategies/?view=lanes&hl=modularity,composability,standardization,malleability)

## Fights with

- [Craftsmanship](https://moa.giglabo.com/strategies/craftsmanship/) — Craft fits each piece to its neighbour with time and care; modularity fits everything to a standard joint.
- [Simplicity](https://moa.giglabo.com/strategies/simplicity/) — Every joint is a seam and every seam a point of failure; a minimal design with few parts pulls against making each part replaceable.

[Map this tension](https://moa.giglabo.com/strategies/?view=lanes&hl=modularity,craftsmanship,simplicity)

## Source

Strategy taxonomy © kepano (Steph Ango), paraphrased with attribution. Role and moat mapping © Moat Atlas. https://stephango.com/

## Related

- HTML version of this page: https://moa.giglabo.com/strategies/modularity/
- Русский: https://moa.giglabo.com/ru/strategies/modularity/
- Previous: Composability — https://moa.giglabo.com/strategies/composability/
- Next: Iteration — https://moa.giglabo.com/strategies/iteration/
- Atlas: https://moa.giglabo.com/
- Catalogue: https://moa.giglabo.com/moats/
- Calculator: https://moa.giglabo.com/calculator/
- Strategies: https://moa.giglabo.com/strategies/
- Site map for agents: https://moa.giglabo.com/llms.txt