09Safety is what a reviewer can see
When building is cheap, it is just as cheap to build too much process. The way configuration reaches production showed that a process is as safe as what a person can actually check at each step, however many steps it has.
A configurable product has a particular risk. The people who change its behaviour are not its developers. They change it after it has been validated, with a tool, without touching the code. In a medical device, a configuration change carries as much risk as a code change. So the path a configuration takes to production is a safety mechanism in its own right, and I designed it with care.
What protects the patient whatever the configuration?
Some of the protection does not depend on any workflow at all, and that part held. The device protects itself, whatever configuration it receives:
- Some fields are required by the application to function or to remain compliant. No configuration can hide them: if a page omits one, the application places it anyway.
- The actions a profile may perform on a page are capped by limits written into the device's own code. Configuration can restrict an action further. It can never grant more than the code allows.
- Nothing reaches the device without being drawn into an approved baseline. There is no back door.
These are floors and ceilings: whatever the configuration says, it cannot go below the one or above the other. They are enforced by code that went through the device's full verification, and they protect the patient wherever the regulatory boundary is finally drawn around the configuration tool.
Why did the process grow?
Around those limits, I built the path shown in Figure 3, with two more steps: saving work in progress, and deploying with the application stopped. Each step had a reason. Each was easy to build, because Claude built it.
AI makes every step of a process cheap to build, and that has a trap: when a step costs a few stories, it is tempting to add one whenever a risk comes to mind. The cost of a cumbersome process does not fall on the developer, who built it in an afternoon. It falls on the people who must go through it every time, and in a hospital those are the people with the least time to spare.
The approval that approved too much
On 16 October, while testing, an unintended restriction passed approval: a profile lost the right to open a record, and nobody meant it to. Every step of the process ran exactly as designed. The approver approved what was in front of them: the page as a whole. What had changed on it, a single restriction among many settings, was not shown.
What I learned is that an approval protects only what the approver can see. Adding a second approval would not have caught this one. Showing the difference would have: what this version changes compared with the one in production, line by line. The fix for the screens is recorded and waiting for its turn, and the process itself needed more than a fix.
Approval or validation?
Looking back, my process mixed two different checks. Approval answers the question: is this the change we meant to make? It is a review of a difference, by someone who understands the intent, so the difference must be visible. Validation answers another one: does the system behave correctly with this configuration? That cannot be answered by reading. It needs the configuration running, in an environment that behaves like production, tested by the people who will use it.
Today's path approves, then deploys straight to production: nobody sees a configuration working before it is used for real. So I decided to change it. A baselined configuration will go first to a validation environment, which needs a new part of the configuration tool to manage environments. It is validated there, and the validation is recorded and traced like any other verification. Only then does it reach production.
Two questions came out of this. The first I have not solved. Production must be quiet when the new configuration arrives: no transaction may ever see half of the old configuration and half of the new one. Today the application is stopped to achieve that, and I do not want to keep doing so. How a running system can be made quiet without being stopped is, at the time of writing, an open item, for the kind of brainstorming chapter 05 describes.
The second had slipped my mind. A hospital has several environments, as the figure shows, each with its own configuration and its own data. A training environment must never hold real patient data, and the prologue's second lesson returns here: plausible synthetic data, generated on demand, makes such environments safe to provide.
Changes to the software itself
Code and data-model changes follow a stricter path, and I am not trying to make it lighter. Every change, of any kind, goes through validation. It is installed during a planned window, usually at a weekend, when hospitals are quietest. The hospital prepares for it: manual procedures ready, and records caught up once the system is back. And every upgrade must be reversible. Stopping the system for these changes is a deliberate choice: one known state before, one known state after, both verifiable.
For your own project
Configurable systems are everywhere: rules engines, pricing tables, feature flags, workflow definitions. Whenever people other than developers can change how a system behaves, the same questions apply.
- Put the protections that matter in the code, as floors and ceilings that no configuration can cross, and verify them with the code.
- Make every approval show the difference being approved, and give validation an environment of its own.
- Be wary of process that is cheap to build. Count each step's cost in the time of the people who will go through it, and keep only the steps that let someone check something they could not check otherwise. Which steps stay is the team's decision.
Status as of October 2026. The new configuration path and its environments are decided; making production quiet without stopping it is an open item.