Scaling federated networks and codebases: A human-centred balance

To put this into a social path, scaling is a double-edged sword – it can be both good and bad, depending on how it’s done.

• Good, because when things scale well, people don’t have to worry, systems run smoothly, communities thrive, and services become accessible.
  
• Bad, because the strength of a healthy network lies in staying small-scale, transparent, and human. The moment something becomes too big, it starts to lose the relational dynamics that gave it value in the first place.

So, how do we balance this? The idea is that codebases and networks need to scale just enough, not infinitely, but to the point where they can support a human-scale community. After that point, it’s not only acceptable but preferable if they start to strain or fail under pressure. That friction is a feature, not a bug, it nudges people to move to federate rather than stay and centralize.

What does “enough” mean? “Enough” isn’t a fixed number, but a pattern, a community of a few hundred to a few thousand accounts. Of these, perhaps 15–25% are very active, contributing most of the content, moderation, and tagging. This scale is large enough for rich conversation and diverse activity, but still small enough for shared context and trust, low moderation overhead, organic relationships and accountability. Once a community grows beyond this range, organic moderation and social cohesion break down, leading to noise, exploitation, or the #mainstreaming call for reliance on impersonal algorithmic solutions, the very things OMN path wants to avoid.

Federation is the healthy scaling path we need to take. Rather than “scaling up” in a single, monolithic instance, the sustainable way is to scale, is out through federation. That is, build many interconnected human-scale communities, each managing itself. Using shared protocols, metadata flows, and trust tagging to connect communities meaningfully. Respect local autonomy, while allowing content, trust, and culture to flow between nodes. This model mirrors healthy ecosystems, small habitats working together rather than being swallowed by a single “concrete” system.

Why this matters for #FOSS codebases? Software should be designed to reflect and reinforce this human-scale path. Keeping systems lightweight and maintainable for small teams, to enable interoperability and modular design, so communities can fork, adapt, or remix code to suit local needs. It’s core to this path to accept that codebases don’t need to scale infinitely, they only need to scale enough to support the next healthy layer of federation.

The right question isn’t “Can this scale to millions?” but “Can this be easily cloned, modified, and federated by others?” By embracing “ENOUGH” as a limit and a guide, we ensure our networks stay rooted in trust, flexible in form, and resilient by design. Growth becomes a matter of spreading seeds, not building towers.