Most people describe a system. I hand you one that runs. This is a real pipeline with nine stages, twenty passing tests, and a rule that says nothing leaves the building without a named human signing it off. You can watch a single record travel through it and see exactly where it stops.
Every stage has one job, and you can inspect each of them on its own. The point is not that the machine is clever. The point is that you can always say what happened to any given record, and why.
Records arrive and are logged with an identifier. Nothing enters the machine without a trace of its arrival.
SystemRecords are selected into a working batch. Fixed layouts and column mapping. Plain code, no model anywhere near it.
SystemRequired fields, eligibility rules, duplicate checks. This stage decides pass or fail with no model at all, and it records a machine readable reason for every single failure.
SystemAnything that fails leaves the happy path and lands in a queue with its reason code attached. Every code is counted, so the volume is visible instead of guessed at.
SystemOne scoped job. Take the record and its evidence and draft the response. It does not send, does not decide, and does not retry past its limit.
AgentA named person approves, rejects, or corrects. Nothing proceeds without that. The agent can raise a block, but it can never send.
HumanThe output is produced to a test sink. In this build that is a local file, never a live recipient, and the system says so out loud rather than leaving you to assume otherwise.
SystemEvery transition writes an entry. Stage, actor, timestamp, model, tokens, request identifier, outcome. Each entry carries the previous entry's hash, so the record cannot be quietly edited afterwards.
SystemThe pipeline computes its own numbers. Volume, exceptions, cycle time, straight through rate, cost per record. Computed by the system, never typed into a slide by a person.
SystemHere is the point of the whole thing. Validation is a pure function with a test per rule. It returns a machine readable reason code for every failure rather than stopping at the first, and it never touches a model. That means I can prove what it does, and I can explain any single record it rejects, on the spot, without opening a black box.
The system enforces the things that cannot be undone. A person decides the things that need judgement. That asymmetry is deliberate, and it is where most automation quietly goes wrong.
HARD BLOCKCannot be overridden. No human signature clears it. This is what the machine refuses to do even when it is told to.
An ineligible record. An identity that cannot be verified, because a rule that cannot run must fail closed rather than open.
FLAGSurfaced to a human with its reason code attached. The person weighs it and decides. The decision is recorded against their name.
A duplicate contact. A status that is not sendable as it stands. A record that appears in the history and needs a look.
Try the rule first. Escalate only the residue to a model. If a competent person could write a rule for the case and agree with it every time, then it is a rule and not a prompt.
same input, same output, every time
The log proves what the system did without becoming a second copy of the data. It records that a draft happened, how long it was, and which actor produced it. It does not record what it said.
stage · actor · model · tokens · outcome
There is a script that breaks the pipeline three ways on demand. A member smuggled into the pool, the audit log tampered with, and a field the rules depend on removed. Each one shows what the system does when it fails.
python break_it.py
No figure in the output is typed in by hand. The pipeline reads its own logs and computes its own rates, so the person presenting the result is not the person who chose the result.
measured ≠ asserted
Interviewers test whether you know the difference between a measured figure and an assumed one. Most candidates do not, and it shows. So the distinction is written on the artefact rather than buried in it.
| Figure or capability | Status |
|---|---|
| Nine stages, each independently inspectable | Built and running |
| Twenty tests, one written per design rule | Passing |
| Hash chained audit log that detects editing | Verified |
| Membership exclusion check that fails closed | Built and tested |
| Hard blocks that no approval can override | Built and tested |
| The agent drafting step | Template, swappable |
| Any figure describing a client outcome | Not on this page |
On the agent step. In this build the drafting stage is a deterministic template rather than a live model call, so the run is reproducible and costs nothing to repeat. It is one function. Swap the body for a model call and the receipt picks up the model name and the token count automatically, with nothing else in the pipeline changing. I would rather tell you that than let a screenshot imply more than it shows.
The sprint is a fixed scope engagement for a vendor with a live enterprise opportunity stuck in review. We build the evidence, map who owns what, and put a reusable approval library behind it. Twenty one days, one pursuit at a time.