# configuration/principle/data/coordination.data.json

> 329 lines of code and 0 definitions.

Tree: GovLab Context
Language: json
Layer: domain
Canonical: https://banes-lab.com/anatomy/context#file-context-configuration-principle-data-coordination-data-json
Source text: https://banes-lab.com/source/context/configuration/principle/data/coordination.data.json.txt

Listed in [configuration/principle/data](https://banes-lab.com/api/source/context/configuration/principle/data.md), after [configuration/principle/data/contract.data.json](https://banes-lab.com/source/context/configuration/principle/data/contract.data.json.md) and before [configuration/principle/data/correctness.data.json](https://banes-lab.com/source/context/configuration/principle/data/correctness.data.json.md).

## Contained in

- [configuration/principle/data](https://banes-lab.com/anatomy/context/folder-context-configuration-principle-data.md)

## Source

```json
{
    "category": "Control / Coordination / Centralization",
    "check": {
        "population": "every node, service and workflow step that shares configuration, identity, logs, leadership or agreement",
        "freshness": "a verdict stands until membership, topology or the coordinating policy changes",
        "refusal": "the workflow test or the platform policy rejects a participant that bypasses the coordinator or the agreed value",
        "observation": "the control plane's recorded state compared with each participant's reported state",
        "evidence": "none: the catalog states this check as a class, so a watched run belongs to each system that adopts it",
        "authority": "the control plane's recorded state, which each participant's reported state is compared against"
    },
    "records": [
        {
            "id": "control-plane",
            "name": "Control Plane",
            "definition": "Descriptive data about the desired state of a distributed runtime, held in one place and applied to every node through a management interface.",
            "type": "artifact",
            "scope": [
                "platform",
                "infrastructure",
                "distributed system"
            ],
            "requires": [
                "Management API",
                "Policy"
            ],
            "reinforces": [
                "Governance",
                "Orchestration"
            ],
            "enables": ["Centralized Control of Distributed Runtime"],
            "conflicts_with": ["Fully Decentralized Control"],
            "tensions_with": ["Availability"],
            "violated_by": ["lexicon:scattered-configuration"],
            "detected_by": ["manual node/service control"],
            "measured_by": [
                "control coverage",
                "control-plane availability"
            ],
            "refactored_by": [
                "lexicon:management-api",
                "architecture:policy-as-code"
            ],
            "enforced_by": ["platform architecture"],
            "severity": "contextual",
            "exemplar": {
                "before": "for (const node of fooNodes) {\n  node.configure({ retries: 3, timeoutMs: 500 });\n}",
                "after": "controlPlane.apply(\"foo-service\", {\n  retries: 3,\n  timeoutMs: 500,\n  rollout: \"progressive\",\n});",
                "lang": "ts"
            }
        },
        {
            "id": "orchestration",
            "distinctFrom": [
                {
                    "id": "lexicon:coordinator",
                    "reason": "Orchestration is the mechanism of driving a workflow from one place, while the coordinator is the component that plays that role."
                }
            ],
            "name": "Orchestration",
            "definition": "A mechanism that runs a multi-step workflow from one coordinator, which calls each step in order and tracks its outcome.",
            "type": "mechanism",
            "scope": [
                "workflow",
                "deployment",
                "services"
            ],
            "requires": ["Coordinator"],
            "reinforces": [
                "Control Plane",
                "Saga"
            ],
            "enables": ["Ordered Multi-Step Execution"],
            "conflicts_with": ["Pure Choreography"],
            "tensions_with": ["Centralized Coordinator Coupling"],
            "violated_by": ["lexicon:pure-choreography"],
            "detected_by": ["unclear workflow ownership"],
            "measured_by": ["workflow observability/completion"],
            "refactored_by": [],
            "enforced_by": ["workflow tests"],
            "severity": "contextual",
            "exemplar": {
                "before": "await fooService.create(foo);\nawait barService.create(bar);\nawait bazService.create(baz);",
                "after": "await orchestrator.run(\"CreateFooFlow\", {\n  steps: [\n    step(\"foo\", () => fooService.create(foo)),\n    step(\"bar\", () => barService.create(bar)),\n    step(\"baz\", () => bazService.create(baz)),\n  ],\n});",
                "lang": "ts"
            }
        },
        {
            "id": "centralized-configuration",
            "name": "Centralized Configuration",
            "definition": "A design pattern that keeps every service's configuration in one versioned store the services read from.",
            "type": "pattern",
            "scope": [
                "service",
                "platform",
                "runtime"
            ],
            "requires": [
                "Config Store",
                "Access Control"
            ],
            "reinforces": [
                "Governance",
                "Consistency"
            ],
            "enables": ["Unified Config Management"],
            "conflicts_with": ["Scattered Configuration"],
            "tensions_with": ["Central Dependency Risk"],
            "violated_by": ["lexicon:scattered-configuration"],
            "detected_by": ["config drift"],
            "measured_by": ["config drift count"],
            "refactored_by": ["architecture:schema-validation"],
            "enforced_by": ["config policy"],
            "severity": "contextual",
            "exemplar": {
                "before": "const fooConfig = loadLocalFooConfig();\nconst barConfig = loadLocalBarConfig();\nconst bazConfig = loadLocalBazConfig();",
                "after": "const config = await configService.readVersioned(\"platform/v3\");\nfooApp.apply(config.foo);\nbarApp.apply(config.bar);\nbazApp.apply(config.baz);",
                "lang": "ts"
            }
        },
        {
            "id": "centralized-authentication",
            "name": "Centralized Authentication",
            "definition": "A design pattern that verifies identity once, at a shared identity provider, and passes the result to each service.",
            "type": "pattern",
            "scope": [
                "identity",
                "system"
            ],
            "requires": ["Identity Provider"],
            "reinforces": [
                "Security",
                "Governance"
            ],
            "enables": ["Unified Identity"],
            "conflicts_with": ["Scattered Auth Implementations"],
            "tensions_with": ["Identity Provider Availability"],
            "violated_by": ["lexicon:scattered-auth-implementations"],
            "detected_by": ["duplicated credential stores"],
            "measured_by": ["auth centralization coverage"],
            "refactored_by": ["lexicon:identity-provider"],
            "enforced_by": ["security policy"],
            "severity": "recommended",
            "exemplar": {
                "before": "fooService.verifyToken(token);\nbarService.verifyToken(token);\nbazService.verifyToken(token);",
                "after": "const identity = await identityProvider.authenticate(token);\nawait fooService.handle({ identity });\nawait barService.handle({ identity });\nawait bazService.handle({ identity });",
                "lang": "ts"
            }
        },
        {
            "id": "centralized-logging",
            "name": "Centralized Logging",
            "definition": "A design pattern that ships structured logs from every instance to one aggregated store.",
            "type": "pattern",
            "scope": [
                "services",
                "platform"
            ],
            "requires": ["Log Aggregation"],
            "reinforces": [
                "Observability",
                "Auditability"
            ],
            "enables": ["Cross-Service Analysis"],
            "conflicts_with": ["Local-Only Logs"],
            "tensions_with": ["Cost/Personal Data Exposure"],
            "violated_by": ["lexicon:local-only-logs"],
            "detected_by": ["missing log shipping"],
            "measured_by": ["log ingestion coverage"],
            "refactored_by": [
                "lexicon:log-aggregation",
                "architecture:canonical-data-model"
            ],
            "enforced_by": ["observability policy"],
            "severity": "recommended",
            "exemplar": {
                "before": "fooService.writeLocalLog(event);\nbarService.writeLocalLog(event);\nbazService.writeLocalLog(event);",
                "after": "const sink = new CentralLogSink();\nfooService.useLogger(structuredLogger(sink));\nbarService.useLogger(structuredLogger(sink));\nbazService.useLogger(structuredLogger(sink));",
                "lang": "ts"
            }
        },
        {
            "id": "decentralization",
            "name": "Decentralization",
            "definition": "A design rule that decisions and runtime control sit with the teams and services that own them, joined by contracts.",
            "type": "principle",
            "scope": [
                "system",
                "team",
                "service"
            ],
            "requires": [
                "Autonomy",
                "Contracts"
            ],
            "reinforces": [
                "Microservices",
                "Resilience"
            ],
            "enables": ["Independent Ownership"],
            "conflicts_with": ["Centralized Control"],
            "tensions_with": [
                "Governance",
                "Consistency"
            ],
            "violated_by": ["lexicon:centralized-control"],
            "detected_by": ["centralized team/service dependency"],
            "measured_by": ["decision/deployment dependency count"],
            "refactored_by": [
                "lexicon:assign-owner",
                "lexicon:management-api"
            ],
            "enforced_by": ["ownership model"],
            "severity": "contextual",
            "exemplar": {
                "before": "const coordinator = new GlobalFooCoordinator();\nawait coordinator.approveEveryFoo(foo);",
                "after": "await fooNode.validate(foo);\nawait fooNode.commit(foo);\nawait fooNode.publish({ type: \"FooCommitted\", fooId: foo.id });",
                "lang": "ts"
            }
        },
        {
            "id": "leader-election",
            "name": "Leader Election",
            "definition": "A mechanism that lets a group of nodes agree on one coordinator and replace it when it fails.",
            "type": "mechanism",
            "scope": [
                "distributed system",
                "coordination",
                "availability"
            ],
            "requires": ["Consensus"],
            "reinforces": [
                "Control Plane",
                "Fault Tolerance"
            ],
            "enables": [
                "Single-Writer Coordination",
                "Automatic Failover of Leadership"
            ],
            "conflicts_with": ["Split-Brain Coordination"],
            "tensions_with": ["Availability"],
            "violated_by": ["lexicon:split-brain-coordination"],
            "detected_by": ["concurrent leader actions / split-brain"],
            "measured_by": ["split-brain incident rate"],
            "refactored_by": [],
            "enforced_by": ["distributed-systems review"],
            "severity": "contextual",
            "mandatoryFor": "distributed systems",
            "exemplar": {
                "before": "if (process.env.IS_LEADER === \"true\") runFooScheduler();",
                "after": "const lease = await fooCoordinator.acquireLeadership(\"foo-scheduler\", { ttlMs: 10_000 });\nlease.onAcquired(() => runFooScheduler());\nlease.onLost(() => stopFooScheduler());",
                "lang": "ts"
            }
        },
        {
            "id": "consensus",
            "distinctFrom": [
                {
                    "id": "architecture:leader-election",
                    "reason": "Consensus commits one value across a quorum, while leader election uses it to agree on one coordinator and replace it when it fails."
                },
                {
                    "id": "architecture:total-order-broadcast",
                    "reason": "Consensus agrees on one value, while total-order broadcast agrees on the order of every message."
                }
            ],
            "name": "Consensus",
            "definition": "A mechanism that lets a quorum of nodes commit one value, so every correct node ends up with the same value.",
            "type": "mechanism",
            "scope": [
                "distributed system",
                "agreement",
                "consistency"
            ],
            "requires": ["Quorum"],
            "reinforces": [
                "Consistency",
                "Fault Tolerance"
            ],
            "enables": ["Agreed Single Value Across Nodes"],
            "conflicts_with": ["Independent Node Decisions"],
            "tensions_with": [
                "Latency",
                "Availability"
            ],
            "violated_by": ["lexicon:independent-node-decisions"],
            "detected_by": ["divergent committed state across replicas"],
            "measured_by": ["agreement-violation rate"],
            "refactored_by": [],
            "enforced_by": ["distributed-systems review"],
            "severity": "contextual",
            "mandatoryFor": "distributed systems",
            "exemplar": {
                "before": "fooNodeA.setValue(value);",
                "after": "const committed = await fooCluster.propose(value, { quorum: majority(fooNodes) });\nif (!committed.accepted) throw new NoQuorumError();",
                "lang": "ts"
            }
        },
        {
            "id": "choreography",
            "name": "Choreography",
            "definition": "A mechanism that coordinates a cross-service flow through events, with each service reacting to the previous one's event.",
            "type": "mechanism",
            "scope": [
                "distributed system",
                "coordination",
                "event"
            ],
            "requires": ["Event-Driven Architecture"],
            "reinforces": [
                "Decentralization",
                "Service Autonomy"
            ],
            "enables": ["Central-Orchestrator-Free Coordination"],
            "conflicts_with": ["Central Orchestrator Bottleneck"],
            "tensions_with": ["Traceability"],
            "violated_by": ["lexicon:central-orchestrator-bottleneck"],
            "detected_by": ["a central coordinator coupled to all participants"],
            "measured_by": ["orchestrator fan-out coupling"],
            "refactored_by": [],
            "enforced_by": ["architecture review"],
            "severity": "contextual",
            "exemplar": {
                "before": "await orchestrator.run(\"CreateFoo\", [\n  () => createFoo(foo),\n  () => reserveBar(foo),\n  () => notifyBaz(foo),\n]);",
                "after": "fooEvents.on(\"FooCreated\", event => barService.reserve(event.fooId));\nbarEvents.on(\"BarReserved\", event => bazService.notify(event.fooId));",
                "lang": "ts"
            }
        }
    ]
}
```