Nine modules that talk through events

A modular monolith, not microservices

Nine modules with explicit boundaries, published as separate packages, compiled and deployed as a single application.

What I ruled out: microservices. In an operation this size they would trade a code organization problem for a network problem, with distributed transactions, contract versioning and tracing across services, all of it with nobody on call to look after it.

The boundary between modules exists in the code and the compiler enforces it. The operational cost of a distributed application does not come with it.

Modules publish events instead of calling each other

An approved proposal fires an event, and whoever is listening reacts: the project module creates the handoff, and finance builds the payment plan. A completed project triggers purchasing. Available material opens the work order with its six stages. A finished installation registers the warranties, and the signed invoice releases the payment.

What I ruled out: direct calls between modules. That works with three and turns into an impossible graph with nine, where adding a new module forces you to edit the old ones.

A new module starts listening to an event that already exists, and none of the other eight is touched.

Multi-tenant from the first table

The column that identifies the company that owns the record has existed since the first migration, and the company filter is checked in CI on every new query. There are six access roles per company, from the owner to the installer.

What I ruled out: leaving it for later. Doing it at the start costs one column. Doing it later means rewriting every query in the system, and living with the risk of forgetting exactly one of them, which is the one that leaks one customer's data to another.

A form field is born in a single file, and a script checks all three ends

The site survey is filled in on the computer and on the phone, in screens written separately. The field is defined in a single source file and implemented in both screens, and a script checks all three ends.

What I ruled out: agreeing with the team that everyone will remember to change both sides. A rule that depends on nobody making a mistake, every day, for months, does not hold.

A registry declares the true source of each business field

There is a file that maps, field by field, which is the canonical source of the data and which copies are allowed.

Why: without it, two places start answering the same question with different numbers, and there is no way to know which one is right. In a system that calculates commission and cash flow, that is more than an inconvenience.

End-to-end tests without starting a server

The integration tests call the tRPC router directly, in process, instead of bringing up the application and hitting it over HTTP.

What I gain: the suite runs on every change without depending on a free port, on startup time or on cleaning up a hung process. A slow test is a test someone turns off.