Architecture you cannot violate

Austin Wagner

Thirteen services and twenty-two shared libraries in one repository, with 47 architecture rules that fail the build, so my design decisions are enforced by CI rather than remembered in review.

Problem
Conventions in a document decay. In a monorepo, the second copy of a pattern is cheaper to write than the first is to find.
Result
A custom static-analysis framework: 47 rules across two languages, 41 Python and 6 Rust, run on every commit.
Scale
13 services, 22 shared libraries, under strict typing and full branch coverage.
Stack
Python, FastAPI, Rust, Redis, RQ, Kafka, PostgreSQL.

Why a rule rather than a review comment

Every rule in the framework exists because something went wrong once and the fix would otherwise have lasted exactly as long as the person who remembered it. A convention that lives in a document is enforced by whoever happens to read the diff; a rule that fails the build is enforced by the build.

The framework covers both languages in the repository, because an invariant that holds in the Python half and not the Rust half is not an invariant. Forty-six rules always run; the forty-seventh registers only when the config segment it polices is set, which is stated rather than hidden because a conditional rule is a rule that can silently not exist. The registration, copied, with the forty-two entries between elided:

    rules: list[Rule] = [
        ConfigRule(),
        TypingRule(),
        PassthroughRule(),
        ...
        RustProptestRule(config),
        RustExplicitMatchRule(config),
    ]
    if config.dataclass_ban_segments:
        rules.append(DataclassRule(config))

libs/monorepo_guards/src/monorepo_guards/orchestrator.py, _run_with_config; the count is the literal's entries plus that one append.

The three things worth fifteen minutes

ComponentWhat it is
ClearGBMGradient boosting written from scratch twice: a numpy orchestration layer, then a Rust core doing histogram building, tree construction and prediction, bridged with PyO3. Most engineers use a boosting library; fewer have written one
Covenant RadarThe deepest single service: multi-domain risk prediction over a pluggable backend registry, with Kafka and hyperparameter search
monorepo_guardsThe rule framework above: architecture linted at CI time rather than argued at review time

Alongside them: speech in 57 languages to English text, GPT-2 and character-LSTM training with LoRA and QLoRA, image-model LoRA training, and the corpus-construction service behind the Turkic research.

A service count that went down

There were fourteen services. I deleted a document-extraction service once the platform it fed grew its own, rather than keeping it alive in two places, which is the decision the whole rule framework exists to make automatic.

The interesting number in a monorepo is not how much it holds. It is how much it refuses to hold twice.

Record

Every figure above is bound to a named section of the wiki page api-monorepo and checked mechanically before this page can deploy. That page carries the exact command behind each count, and the note that the obvious command is wrong, because a plain directory listing counts the Makefile and the README as services.

Known limits. The rule count is the fastest-moving number here and has grown by a third in the three weeks before this was written, so treat it as a floor with a date on it rather than a fixed property. It is re-derived by parsing the registration literal rather than by text search, which over-counts by also matching constructor names that merely end in the same word. Services and libraries are directory counts: they say how the repository is divided, not how much of each division carries weight. Every count was re-derived on 2026-09-14 and none had moved in the three days since the previous reading.

Sources