Holding investment decisions to a plan written before the decision, and measuring the gap from the broker’s record

The Situation

TradeLog was built around a single futures account, my own. Each day it does three jobs. It holds the investor’s Rules, written in advance. It reads every execution the broker recorded. And it grades each Rule on each day as kept or broken, next to the investor’s own grade for the same day.

Investors with a written plan usually grade themselves afterwards. They grade from memory, after the pressure has passed. The decisions most worth reviewing are the ones taken outside the plan and disowned on review. Those are the least likely to be recorded at all.

So a self-reported adherence figure shows what the investor meant to do. Care makes this worse. The more carefully someone writes up their decisions, the more believable their number looks, even for the sessions their notes never covered.

The record that would settle it already exists. The broker writes down the entry, exit, size, fees and timestamps of every execution as it happens. Nothing needs remembering, only reading. Then something has to be willing to disagree with the investor about it.

What I Did

TradeLog computes Verified Adherence by checking every execution the broker recorded against the investor’s Rules. Each Rule is written in advance, in the ruleset, as a condition a computer can check. The figure comes from the ruleset and the broker’s record alone, and nothing the investor types reaches it.

A simpler product would delete the self-report at this point. TradeLog keeps it. Claimed Adherence, the investor’s own account of the same session, sits beside the computed figure, and the difference is shown for review instead of reconciled away. The record knows what happened and can never know why. The investor knows why, and has every reason to be generous. The gap shows where belief has drifted from behavior, which is what a record of decisions is for. Averaging the two into one score is the one step that destroys it.

Three decisions hold Verified Adherence up.

Decision 1: one calculation produces every number. The evaluator is a single function. It takes the executions, the ruleset, the account, the investor’s notes and the date as inputs, and returns every number on every screen. It does not look up the time or read saved data for itself. Because the date is an input, re-running a session from March today gives the answer it gave in March. Nothing else recomputes adherence, so every screen shows the same answer.

Decision 2: Rules are stored as versioned configuration. The investor has to be able to edit them, or they are the system’s rules and not the investor’s. But a threshold edited in place rewrites its own history: last month’s adherence silently becomes a claim about this month’s rule. So every edit saves a new version, and every day records the version it was graded under. A rule changed today changes how tomorrow is graded and leaves graded days alone.

The rubric that scores the investor’s notes is versioned the same way, one level finer. A Rule version is recorded per day, because a clean day is a claim about the whole day. A rubric version is recorded per note, the single entry it scored.

Decision 3: order placement is rejected outright. The appeal was real. The system knows when the budget is spent, so it could block the next order instead of only objecting to it. I rejected it because a block works only if it cannot be bypassed, and the broker’s own platform is one keystroke away. It would buy no enforcement while adding two failure modes that did not exist before: a bug that moves money and a failed request that leaves a position open. What is left is a read-only broker integration. It runs on the server, keeps the key out of the browser, and reads without ever writing. When the connection fails, the system says so loudly. A stale count shown as a current one is worse than no count, because it gets believed.

Indy is the charting half: a set of chart indicators whose job is to remove drafting labor, not to supply judgment. Where it could either present evidence or resolve it, it presents, and it carries no direction readout at all. Its link to TradeLog is an export of what a chart showed at a point in time. The export is structured data, imported through TradeLog’s existing import as a chart record that makes no claim a trade was placed.

Indy began as an inherited script that did a fraction of what I wanted, and did that fraction wrong. The first work was not the rewrite. It was saying exactly how the script failed. One readout had never displayed once in months of use. A four-digit time was being handed to an argument expecting an hour, so every comparison fell through to the same branch. I deleted it instead of repairing it. It existed to make the script look elaborate, nothing depended on it, and a requirement nobody has is not a requirement.

A second defect had two possible behaviors and nothing to tell them apart. A daily reset was keyed to a timezone where it needed a session. So either the overnight levels were cleared before the investor’s active session, or they were never cleared at all. Neither reading the code nor using it had settled which. Naming both defects turned a vague intention to rebuild into a specification of fifty numbered requirements.

The charting platform’s shared-library feature publishes its source code to anyone, without exception. So the shared logic could not be published there as a library, and that one decision shapes the architecture for good. The code lives as modules in a private repository, and a build step joins them into the three scripts that run on the charts. All three are built from the same private code, and none of that code is published.

What Changed

TradeLog stopped being a place to type once executions arrived by import and became the record. Journaling became adding notes to rows that already exist, limited to what the broker cannot know. The headline figure changed with it. It used to be a score of how completely the journaling form was filled in. Now it is how much room the account has left before it ends.

Indy changed the weekly review the same way. A week’s review became reading records instead of opening dated folders of screenshots.

Pending Result Whether holding decisions to a written plan this way improves them is not answered here. TradeLog is designed to improve three things: commitment to a plan before a decision, honest review after it, and the ability to see drift between intention and action. Whether it does so, for anyone, would take a long run of decisions read against the same account before and after the change, and that record is not published. Returns are out of scope.

Withheld What the committed Rules would have done across the account’s history has been computed exactly, from executions that already happened. It is not on this page. That figure is a personal profit-and-loss number. A number about my own account is not evidence about my engineering, and it is what a reader would remember instead. A check in the site’s build now fails if a dollar figure of that kind appears in any page. So this is enforced by the build, not left to my restraint.

What I Learned

I wrote TradeLog’s interventions from a story about the user, not from the user’s record. Each one was plausible, and that was the whole of the evidence behind it. When I finally pointed the same import that produces Verified Adherence at the trigger list, one trigger turned out to be watching for a pattern the record did not contain. I retired it.

The uncomfortable part is that the check cost nothing, and the data for it had been there from the first day. I had built the instrument that could check my own product before it occurred to me to point it there. Indy taught the same thing from the other end: a readout dead from the day it was written sat on the chart for months, unnoticed because nothing depended on it. “I use it and it works” is not evidence that it works.

Where Else This Applies

The framework is not specific to one account. Any investor, adviser or investment committee held to a written plan faces the same gap. It appears wherever the plan is committed in advance, someone else records the executions, and the people who made the decisions report their own adherence. An adviser’s recorded rationale could be read against the client’s executed trades, or a committee’s investment policy statement against the portfolio’s transactions. Adherence would be computed from the execution record and kept beside the adherence reported, and the gap would be reviewed instead of reconciled.

Self-report measures intention, and it fails hardest where it matters most. Control attestations, training completion, time recording and safety checklists all ask the person who did the work to confirm they did it properly. Each is least reliable in exactly the cases worth catching. Where a system already holds a record of the behavior, compliance can be computed from it. The distance between claim and record is then a second measurement, and most organizations throw it away by reconciling it.

A rule that changes needs versions. Change a credit policy, a risk limit, an eligibility criterion or a service-level definition in place, and last quarter’s compliance rate silently becomes a statement about this quarter’s rule, with nobody told. Versioning the rule, and recording which version graded each case, costs almost nothing at design time and cannot be added afterwards.

Refusing a capability is an architecture decision. The broker integration is not read-only because writing was hard. It is read-only because the write path added risk to a system whose whole purpose was to reduce it. A decision recorded with the alternative it was chosen over survives the next person to notice the gap, even when that person is me, six months later, with a plausible reason.