Certificate of Analysis · plain-language guide
Every closed trade gets a certificate. It grades the decision, not the money. A trade that made a fortune can come back off plan; a trade that lost can come back on plan. This page explains the whole thing — what it reads, who decides, and what each verdict word means.
The idea in one page
A pharma lab tests a product against the specification its own manufacturer declared, before that product is released for people to consume. The question is "is this batch what its maker said it would be?" That is a release, not a diagnosis.
You are the manufacturer. The trade is the batch. The exit you named at entry is the registered spec. The certificate asks one thing — did the batch match what you declared — and has no opinion at all about whether your declaration was any good.
The consequence is the app's most important rule: it will never hand you the spec. No suggested stop distance, no typical hold time, no comparison to other traders. The moment the tool supplies the plan, it stops testing you and starts testing its own opinion of the market — and that opinion is worthless. You write the spec. The certificate only ever checks it against what you did.
The rest follows from the same model: the record keeps two clocks (when the market did the thing, when you wrote it down), and nothing is released on the machine's word — a person signs, the way a batch is released rather than merely tested.
Why not just grade profit?
Profit at one trade is mostly noise. Whether you followed your own plan is dense, low-noise signal you generate on every trade. Grading process is the only way to tell skill from luck.
A batch that misses spec in pharma is not condemned on the spot — it is marked out of specification and investigated. Same here, and stronger: a trade is never defective. The battery establishes something narrower and more useful — a difference between what you declared and what you did. So the certificate never says pass or fail. It says:
Off plan is a description, not a verdict on you. It says the exit and the spec disagreed — which is exactly the thing worth looking at. Everywhere below, read on plan and off plan as the words on the screen; the words "pass" and "fail" survive only as internal keys inside the code, where they cross to the server and the sort order.
01 · The pipeline
Four things feed a certificate: the plan you named before the outcome existed, the machine's record of what happened, the sentence you wrote about why you got out, and a rulebook if you declared one. Facts are graded by code. Meaning is proposed by an AI and settled by you.
02 · The battery
Three are mechanical — a field is filled in or it isn't. Two need a judgment about what a sentence means. One is neutral and can never hurt you. Only the two judgment tests decide on plan or off plan.
| # | The question, in plain terms | Kind | What it reads | Possible results |
|---|---|---|---|---|
| 1 | Did you name an exit before you entered? A stop, a target, or the thing that would prove the idea wrong. Any one is enough. | code | stop · target · invalidation | named not named |
| 2 | Did you write it down before the outcome was known? A plan written after the fact isn't a plan. The system timestamps the moment a field first gets text in it. | code | authorship timestamp | on time unverified delayed |
| 3 | Did you exit at the condition you named? If an alert fired, the machine states the fact — you closed, you dismissed it and held, or you moved the level. It never convicts you on it. | judgment | alert record, then a grade | honored held past level moved exited late |
| 4 | If you deviated, had you planned that deviation in advance? This is the one the AI grades: your exit sentence against your named levels, the alert record, and your rulebook. | judgment · AI | your exit reason | pre-named rationalized defensible |
| 5 | Did you write down why you got out? Any sentence at all. Without one, there's nothing to grade and the certificate stays incomplete. | code | exit reason present | recorded pending |
| 6 | Was a question raised at entry that you never answered? Only appears when a challenge was raised, ignored, and the trade went badly. It's a mirror, not a charge. | neutral | entry challenge + outcome | skipped — never affects the verdict |
03 · The three categories
Test 4 sorts every exit that left the named plan into exactly one of three buckets. This is the whole rubric — the AI gets these three choices and nothing else.
✓ Pre-named → on plan
The exit matched something you committed to before the trade: a stop, a target, an invalidation — or a standing rule you already follow, like always scaling out of a green option.
"Target hit at 237, sold the position."
✗ Rationalized → off plan
The reason wasn't in the plan and nothing forced your hand. Discretion dressed up as discipline: locking in a round number, fear, boredom, or moving the goalpost after your level printed.
"Felt prudent to take profit here."
◐ Defensible → flagged
Something outside your control removed the choice: a liquidation, a broker or alert failure, no visibility while the level printed, expiry mechanics, or a liquidity gap. Not a discipline failure.
"Couldn't see the position intraday; no way to act on the level."
The boundary that trips everyone
A market opinion is not an operational constraint. "Macro looked shaky," "sold ahead of earnings," "rotating out of the sector," "selling to buy back lower" — those are choices, however sensible. If they match no condition you named, they grade as rationalized.
04 · The verdict ladder
Not every trade is owed a grade. Before any verdict is issued, the certificate runs down a ladder of exclusions — trades where no decision existed, trades on venues you never journal, trades from before the grading line. Each of those exits the ladder with an honest non-verdict rather than a bad grade.
05 · The rules people get wrong
The AI writes a proposal. If you grade the same test yourself, your grade wins — regardless of which came first, and the classifier will never write over it. That's deliberate: the machine states facts and proposes meaning; a person certifies.
If your stop printed, you dismissed the alert, held, and later closed near that same price — the grade is on the hold, not the closing price. An honored level can never be used to mask a level you held past.
Most trades have no alert record at all, because the monitor wasn't watching. That silence is never read as "no level ever printed." With no record, your stated reason is taken at face value and the decision it describes is what gets graded.
Test 2 is deliberately lopsided. A late write can be proven late; a timely write can't be proven timely just because the row is old. So an early record with no witnessed timestamp reads unverified — never on time. The flag is only worth having if it can be trusted.
Your standing rulebook counts on test 4, where it can rescue a deviation you'd planned for in advance. It does not satisfy test 1 — most rulebooks resolve their own exit to "the named invalidation," so crediting the book would let the plan point at the empty field it assumes you filled. And a rulebook only counts forward, from the day you declared it. A rule written after the exit isn't a commitment; it's a retrofit.
06 · What actually moves a grade
The annotation form has thirty-odd fields. Most feed the setup classifier, the entry challenge, or a display. They cannot change a verdict. This is the entire grade-bearing set:
| Field | What it does | Filled on |
|---|---|---|
| exit_reason | The sentence the AI reads word for word — tests 4 and 5 | 26% |
| stop_loss_planned | Satisfies test 1; arms the alert monitor | 10% |
| take_profit_planned | Satisfies test 1; arms the alert monitor | 5% |
| invalidation | Satisfies test 1; the built-in black-swan clause | 3% |
| take_profit_final | Turns the target into a band, so anywhere inside is on plan | <1% |
| named_exit_written_at | Stamped automatically — you never type it; drives test 2 | auto |
| rulebook | Injects your standing exit rule into test 4, forward-only | 4% |
The uncomfortable number
The two most decisive fields are the thinnest. Invalidation is filled on 3% of the book. Test 1 fails by default across most of it — which is not a bug in the grader, it's the finding.
07 · The second read
The battery asks one broad question about your exit: did it match the plan. Underneath it, the certificate now runs a second, separate read. It takes the rulebook this trade was graded against, breaks its exit rules apart, and gives each rule its own answer.
So instead of one word about the whole exit, you get a short list — this rule held, this one didn't, this one never came up.
This read does not change your grade. A certificate can show four rules marked not followed and still read on plan. That is deliberate, not a bug.
The reason is simple. The verdict word comes from a test that was run against your own grading, side by side, until the two agreed. The rule-by-rule read has not been through that yet — nobody has checked how often it gets the answer right. So it is shown to you as evidence, and it is kept away from the verdict until it has earned a say. Where the two disagree, the older one wins.
| Result | What it means |
|---|---|
| followed | The rule's condition came up in this trade, and you did what the rule says. |
| not followed | The condition came up, and you didn't. |
| didn't come up | The record positively shows the condition never arose. There was nothing to follow. |
| can't tell | The record doesn't say. Not a pass, not a fail — the honest answer when nothing was watching. |
| can't be graded | The rule is too vague to check, or it's a definition rather than an instruction. Never sent for judgment at all. |
Why "can't tell" is so common
Most rules key on something nobody was watching — a moving average, a candle close, a level printing while you were asleep. Silence there is not proof the level held and not proof it broke. Reading it either way would manufacture a clean certificate out of a blind spot, which is the one thing this whole system exists to prevent. So it says can't tell, and it says it often.
One certificate tells you about one exit. The same read stacked across every graded exit tells you something no single certificate can: whether your rulebook is written in terms the app can actually check. A rule that has never once returned a readable answer is a problem with the rule, not with your trading.
| The rule | Followed | Couldn't tell | Reading |
|---|---|---|---|
| Exit only at the named invalidation | 2 of 9 | 2 | Read clearly on most exits |
| Early exit only on a named structure event | 2 of 8 | 1 | Read clearly — same habit, other side |
| Scale out at least ⅓ by 0.65× target | 2 of 6 | 8 | Read on fewer than half the exits |
| A stop hit is a stop hit | 2 of 2 | 1 | Only came up twice |
| Structure break, defined: … | — | — | can't be graded — a definition, not an instruction |
| Sector rule — semis, SMH vs its 50-day | — | 14 of 14 | Never once readable |
What the last row actually means
That rule asks about two things the app does not store: whether a position is a semiconductor, and where SMH sits against its 50-day average. It has never produced an answer, and as written it never will.
That is not fourteen failures. It is one rule nobody can measure. When a rule comes back unreadable across enough exits, the app files it as a finding and leaves it open until you decide — reword the rule so it points at something the app can see, or accept that it will never be graded.
The top two rows are the opposite case. Those did read, and what they read is a habit of closing on judgment instead of on a level you named in advance. That one isn't the app's to fix.
08 · The other half
Every test above is about the exit. All five of them. The battery asks what you said you would do to get out and whether you did it, and then it stops. Nothing on the certificate has ever asked whether you got in where your own rules said to.
That was not a decision anyone made. It was an assumption — that checking an entry meant reading a chart, and reading a chart meant you typing what you saw. So the design sat waiting for prose that never arrived. Across forty-six recent closed trades, eleven carried a written entry thesis. The entry half went ungraded because the evidence for it was believed to be unavailable.
It was available the whole time. The app already pulls a year of daily candles for any ticker on any past date, and it has always taken a past date. Price against the 200-day. RSI. Where in the 52-week range the fill actually landed. Average true range, realized volatility, distance from the high — all of it as it stood on the day you entered, not as it stands today.
The reason it never got used
The reading was fetched when you expanded a trade row, and only then. Across 1,142 annotations it had been fetched seven times — every one of them on the one screen that has a row to expand. Nothing was broken. No fetch failed. The column simply held a record of which trades somebody had been curious about, which is not the same thing as a record of the book.
Since 2026-08-31 it runs on a clock instead. A nightly job reads the entry date off the trade — never today's date — pulls the tape for that day, and files it. Vendor down, unknown ticker, a window too short to have a 200-day average: the field stays empty and the job tries again tomorrow. It never guesses, and it never overwrites a reading it already has.
Take a real rule. Buy LEAPs near the bottom, when they are cheap, at the end of the accumulation. As a sentence it cannot be graded — "the bottom" names no level and "cheap" names no number, and the app will refuse to save it for exactly that reason. Rewritten so it points at things that exist, most of it turns into arithmetic:
| The clause, written to be checkable | Where the answer comes from |
|---|---|
| Entry in the bottom third of the 52-week range | The entry-day reading. Arithmetic, not a judgment call. |
| Price below its 200-day average at entry | Same reading. |
| RSI under 40 at entry | Same reading. |
| Expiry at least nine months out | The contract itself. |
| Position no more than 2% of the account | The ledger. |
| Bought into an accumulation base | can't tell — nobody has defined a base in terms the app can measure. |
| A higher low off that base | can't tell — same reason. |
Five of seven compute. Two do not, and they stay marked can't tell rather than being guessed at — the same discipline the exit rule-by-rule read already follows. An unreadable clause is a fact about the rule, not about the trade, and reading it either way would manufacture a clean answer out of a blind spot.
Nothing, and that is deliberate. When the entry read arrives it lands where the exit rule-by-rule read already sits: a separate list, shown as evidence, kept away from the verdict word until somebody has checked how often it is right. The five-test battery is the calibrated instrument. A new one does not get a vote on the day it ships.
It is also forward-only, and for the same reason the rulebook is. A trade entered before you declared a rule cannot be measured against that rule — grading it would be a retrofit wearing the clothes of a test. The entry read starts on the day you declare an entry rulebook and covers what comes after it. Which means it is empty on the day it ships and fills up as you trade.
Where this stands today
The evidence is being collected. The verdicts are not being computed yet. Every trade captured from 2026-08-31 onward gets its entry-day reading filed automatically; the clause-by-clause read on top of it waits until there are enough graded trades behind a declared entry rulebook to be worth trusting. This page will say so when that changes.
09 · Worked example
Two Snowflake calls. Three reasons to be in it: a chart pattern with a measured target at 237, an earnings catalyst, and a longer-term sector thesis. Named exit: 237.
Earnings beat. The target hit on day one. One contract was scaled out at +100% — legitimate de-risking. The second was held past 237 and closed near +250%. The stated reason was "prudent to take profit." The real trigger was locking in a screenshot-worthy number. The stock ran for another week or two after the exit.
| Test | Result | Why |
|---|---|---|
| Named an exit at entry | named | 237, written before entry |
| Exited at the named condition | off plan | held past it |
| Deviation was pre-planned | off plan | decided in the moment |
| Exit driven by the thesis | off plan | a milestone, not the thesis |
| Sized and scaled to plan | on plan | scaled the first contract at +100% |
| P&L | recorded | large win — not a process test |
You cannot hold for a multi-quarter rotation and exit to bank a screenshot. The exit reason reveals which thesis was actually load-bearing. That's the product: not the profit, the discrepancy between the plan and what you did.
10 · Reading the words
What comes next
One certificate is one data point — it says what happened on one trade and nothing about you. A hundred of them make the process audit: pass-rate per test, the weakest habit, and what following your own rules actually paid. When a pattern in that roll-up holds, the app opens a finding — a note that waits for your verdict and never closes itself. Those two surfaces have their own guide.
The honest caveat
A certificate backfilled from memory proves the format works — you certified it, not the system. A certificate from a live trade, where the spec was written before the result existed, is the one the system earned. The whole thing is finished the day a live trade comes back off plan and the next trade goes differently.