How ITISYOU Verify was built
A factual record of what was decided, what was built, what broke, and what is still unfinished. Written as it happened. Where something has not been proven, this page says so rather than rounding it up.
Last updated: 21 September 2026.
---
The problem
An automation platform tells you a run succeeded. That claim comes from the automation itself. If the step that was supposed to create a CRM record silently did nothing, or the acknowledgement email was accepted by the sending service and then bounced, the run still reports success, because from the automation's point of view, it finished.
Agencies running workflows for clients find out days later, from the client.
The gap is not monitoring. Error alerts fire when something throws. This is about the cases where nothing throws and the outcome still is not there.
The idea
Go and look.
Read the CRM record back from the CRM. Read the email outcome back from the email provider. Check both against rules the customer set. Report what the evidence supports, and, crucially, report honestly when the evidence is missing rather than guessing.
That last part is the whole design constraint. A verification service that quietly turns "we could not check" into "passed" is worse than no service, because it manufactures false confidence.
The four statuses
| Status | What it means | | -------------- | -------------------------------------------------------------------------------------- | | Verified | Every mandatory check has supporting evidence. | | Failed | Evidence contradicts a rule, or the deadline passed while evidence access was working. | | Unverified | Access, correlation or evidence is missing or ambiguous. Not a pass. Not a failure. | | Pending | Still inside the agreed completion window. |
Unverified exists because the honest answer is often "we do not know", and collapsing that into either of the other two would be a lie in one direction or the other.
---
Decisions, and why
Why only one workflow shape
Version one checks exactly one thing: _an enquiry should create the correct CRM record and trigger an acknowledgement email_, using HubSpot and Resend.
A connector marketplace would have been more impressive and less useful. Each provider brings its own auth model, its own event semantics, its own idea of what "delivered" means, and its own rate limits. Getting one pair genuinely right, proving the evidence is independent and correlated, is a harder and more valuable thing than wiring ten providers we cannot prove anything about.
Why the rule language is deliberately small
Customers define expectations using a closed set of typed operators (exists, equals, normalised_email_equals, occurred_within, provider_status_in, one_of) over an allowlisted set of fields.
Every operator in that list is implemented in the evaluator and covered by its tests. For most of one day that was not the same as every one being used. Until 19 September 2026 the composer that turns the onboarding forms into rules emitted exists and provider_status_in only, so a real run checked that the acknowledgement carried _a_ recipient address, not that it carried _this enquiry's_ address, and a run whose acknowledgement went to the wrong person could come back verified. The reason was structural: a rule's expected value is a literal shared by every run a version judges, so "the address _this_ enquiry named" could not be written down at all.
The fix widened the language by exactly one thing, and it is not an expression: a rule may now name one of two values from the run's own signed event, its correlation reference or its expected recipient, as a closed, typed reference (expected_from). Server code resolves it; nothing is parsed or executed. The composer now binds the recipient check to the enquiry's address with normalised_email_equals, and the correlation check to the enquiry's reference with equals. A run whose event carries nothing to compare with is _unknown_ on that check, never a pass. This is tested against the in-process harness: the wrong address fails the run. It has not been exercised against a live Resend account, because no credential exists yet.
The alternative was a general expression language. It was rejected: a general language lets a customer rule become an unbounded computation or a network request, and it makes the distinction between "failed" and "could not be checked" impossible to prove. A small language is a feature here, not a limitation we plan to remove.
Why email addresses are not "normalised" the way you might expect
The email comparison lowercases, trims, and strips display-name brackets. It deliberately does not strip +tags, and it does not strip dots.
Stripping +tag would mean boss+anything@corp.com, an address the customer controls, could satisfy a rule about having emailed boss@corp.com. Verification must never widen an equivalence class. Dot-stripping is a Gmail-specific convention and is simply wrong for other providers.
That reasoning is a property of the normalised_email_equals operator. For most of one day it was documented here while no customer workflow emitted the operator, so the paragraph above described a protection no real run had. Since 19 September 2026 the composer binds the recipient check with that operator to the address each enquiry named, so the safeguard applies to a real run: proven against the in-process harness, not yet against a live provider account.
The line between "wrong" and "unknown"
This took the most care to get right.
- The provider answered, and the value is wrong → contradicted.
- The provider answered, and the field was not in the answer → unknown. We cannot call
a value wrong when we do not have it.
- The provider answered and the field is genuinely empty → contradicted. That is an
authoritative empty.
- We could not reach the provider → unknown, always. Our outage is not the customer's
failure.
Only two situations can turn a missing outcome into a failure at the deadline: the CRM authoritatively reporting that no such record exists, and the email provider authoritatively reporting that no such event occurred. A timeout never qualifies.
Why your own automation's word is not evidence
Evidence carries an origin: we asked the provider ourselves, the provider called us and we verified its signature, or the customer's own system told us.
The third can never support a mandatory check. The result says so in plain language, and deliberately does not imply the customer is lying. It says what _we_ do: we check everything against the connected systems ourselves, and a system reporting on its own work is not something we can count as proof either way.
What this cannot detect
If a workflow is supposed to run and never starts, and the workflow is the thing that tells us a run was expected, we will not know a run was missing. Every result shows its coverage mode, and "no runs received yet" is displayed as exactly that, never as a perfect score.
Being straightforward about this costs us a better-sounding pitch. It is the correct trade.
---
Architecture
One Cloudflare Worker serves the site, the customer application, the owner dashboard and the API. Cloudflare D1 holds the data, in EU-West because the business is in the UK. Background work runs from a one-minute cron trigger over a single indexed query.
Cloudflare Queues were considered and not used. A due-job table with a partial index is deterministic, testable without a network, and adds no delivery semantics we would then have to design around. The service runs whether or not any developer machine is switched on. That was a requirement, not an aspiration.
---
What broke, and what it taught us
The allowance reservation that silently did nothing
Admitting a source event has to do three things atomically: record the event, reserve one run from the customer's allowance, and queue the follow-up work.
The obvious implementation guards the reservation with a conditional UPDATE. On D1 that is wrong in a way that does not announce itself: a conditional update inside a batch cannot abort the batch. It reports zero rows changed, after the inserts have already committed. The event would have been admitted without consuming an allowance.
The fix writes the reservation so that exhausting the allowance violates a NOT NULL constraint, which does roll the whole batch back. It reads oddly. It is correct, and there is a test that fails if anyone "tidies" it.
A credential binding that bound nothing
Stored provider credentials are encrypted with the workspace, provider and purpose mixed into the authenticated data, so ciphertext moved to another tenant will not decrypt.
The independent security review found the flaw: the function that opens a credential accepted the expected binding as an _optional_ argument. Any helper that looked a credential up by its id and forgot to pass it would decrypt any tenant's row, because the stored binding travels with the row and satisfies the check on its own.
The binding was real. The API made forgetting it easy. That is the same thing as not having it.
Push protection caught us
GitHub's push protection blocked a push because test fixtures were shaped like real API keys. They were synthetic, all zeros, but shape is what a scanner sees.
The fixtures were rewritten so they are assembled at runtime and no credential-shaped literal is committed. The alternative, clicking "allow this secret", would have trained us to dismiss the one warning that will one day be real.
33% that displayed as 100%
The demo page shows a workflow health card: a big "33%" with a progress bar underneath. The bar was rendering full width and solid green.
The markup was right the whole time: style="width:33%". What was wrong was the Content-Security-Policy added an hour earlier. A strict policy with no unsafe-inline blocks inline style attributes as well as inline stylesheets, so the fill fell back to its default width, which is all of it.
Of every bug this project could have shipped, this is the one that most directly contradicts what it sells. The entire argument for the product is that a partial or unknown result must never be displayed as a pass. A bar inflating 33% to 100% does exactly that, on the page written to demonstrate the opposite.
Nothing in the code review would have found it. The template was correct, the test asserted the template was correct, and the policy was correct in isolation. It took deploying the page and looking at a screenshot.
The first fix was a narrow exception: permit inline style _attributes_, keep blocking inline scripts and injected stylesheets, and write into the policy why the exception existed and what would have to change before it could be removed.
That exception is gone. The better fix was to stop needing it: the computed width moved out of a style attribute and into a small set of predefined CSS classes, so the policy went back to refusing inline style attributes entirely. The classes round down: 33% draws as 30, 99% draws as 95, and only a true 100% fills the bar. On a product whose whole argument is that a partial result must never look complete, a bar that errs generous is worse than one that errs mean.
The deployed page was checked afterwards rather than assumed: style-src-attr 'none' in the response header, zero inline style attributes in the markup, and the meter rendering as meter__fill--30.
_(This paragraph previously described only the exception. It was caught during a later audit of the deployed site against the documentation: the story was underselling its own fix, which is a smaller sin than the reverse but the same class of drift.)_
A pinned action that did not exist
The CI workflow pins every GitHub Action to a full commit SHA, because a tag can be repointed at new code by whoever controls the action.
One of the pinned SHAs resolved to no commit at all. It was caught by checking all three against the GitHub API instead of trusting the list. Pinning without verifying is a ritual, not a control.
A customer paid, and was returned to a 404
The first real payment went through on a deployment: £29.00, a sandbox card, through a checkout button that had not existed that morning. Stripe took it and redirected the browser to the return path, which answered 404.
The billing configuration had named that path since the day it was written, along with a second one for a cancelled checkout. Neither route existed. Every test drove the checkout request and asserted on the redirect it produced, so the journey ended at the provider's front door and nothing followed the customer home.
That is this codebase's dominant defect (correct code, thoroughly tested, reached by nothing), arriving at the worst moment it had available.
The page that now exists deliberately does not say the subscription is active. It is reached the instant the provider redirects, which can be before any webhook has arrived; on that day the webhook was in fact being rejected for a signature mismatch, so a congratulation would have been false for hours. It says the payment was accepted, shows the real subscription state, and explains that a redirect is not evidence that anything was confirmed. That is the rule this service applies to other people's automations, applied to itself.
A visitor counter with nothing behind it
The launch objective is ten genuine external visits. After a full day of real requests to production, the visit table held zero rows.
The counter was complete. Its contract was written out in six numbered rules. An in-memory implementation satisfied them and the suite ran against it, green. The middleware was mounted on every request. And the mount passed nothing where the database should have been, above a comment correctly arguing that mounting the in-memory one would report plausible numbers that were silently wrong.
Both halves of that reasoning were right. Nobody wrote the real one. Ten people could have arrived that day and the figure would still have read zero, with nothing to show for it either way.
It was found by querying the live database. Reading the code would not have found it, because every part of the code was right.
Three new rules that matched nothing, invisibly
The owner's approved designs were swept through this repository's own claim scanner, which reported 34 findings across nine rule classes: a compliance attestation this business does not hold, monthly prices that are not the plan price, a trial period that is not offered. Three new rules were written for gaps the scanner did not already cover.
That count of 34 was wrong, and the scanner was why. It matched each rule against the raw markup line, while a comment four lines above it said tags were stripped first: they were stripped into a variable used only for the exemption check. A claim split across two elements was therefore invisible, and that is the ordinary shape of a price on a designed page: the figure in one element, the period in its sibling. The real count is 109 in the screen files. The gate reported two wrong monthly prices where the rendered text carries eighteen.
They matched nothing at all. A mangled escape had left invisible control characters inside all three patterns: invisible in an editor, invisible in search output, and enough to stop them matching anything. The scanner reported a clean sweep over content carrying four wrong prices, and it would have been believed.
It was caught only by refusing to accept that a new rule works because it did not error. The cases that guard them now read each pattern live, assert it fires on the designs' own wording, assert it stays silent on our own true sentences, and assert the pattern contains no control character. The second half matters as much as the first: the real plan price must still pass, and a sentence denying that a trial exists must stay sayable.
The header that fixed the progress bar blocked the checkout
The strict Content-Security-Policy that stopped a 33% bar drawing as 100% carried form-action 'self', with a comment beside it saying Stripe's redirects were not its concern. On 21 September the owner pressed "Continue to secure checkout" on production for the first time. The server did everything asked of it: created the order, created the Checkout Session in Stripe's sandbox, answered 303 to Stripe. The browser stayed on the review page and said nothing, because Chrome enforces form-action on the redirect that follows a form submission, and ours forbade it. No customer could ever have paid. The directive now names Stripe's two pages and nothing else, a test reads the header as it is actually served, and the comment says what the browser does rather than what we hoped.
The same afternoon the connect page was found telling every customer that the address a Resend webhook should call "does not exist in this deployment yet". It existed, and the id was assigned the moment a key was checked; the sentence was simply never conditional. The card now shows the real address. With both fixed, the checkout completed: three signed events, one active subscription, one allowance of 500 runs, and a replayed event that changed nothing.
Every control was correct, and none of them could be reached
On 20 September the owner tried to sign in on production and the page said "we tried and the attempt failed". Reading the production database instead of the page gave the sequence that follows, and each step was invisible to the tests that existed.
The sign-in request had never sent anything. The port passed the notification sender a request in a shape it did not read, behind a type cast that hid the mismatch; the recipient was undefined, .trim() threw, the throw was swallowed as "failed" before any row was written, and the test for this path asserted the failure message, so it enshrined the bug. Fixed, a real message reached the owner's inbox (Resend: delivered) within a minute.
Then the tables said what the page could not: 0 users, 0 platform owners, 0 workspaces, 11 sign-in links issued and 0 redeemed. Three absences, all structural. Signup is closed and the seed script refuses production by design, so no path could create a workspace at all. enrolTotp, the function that enrols an authenticator, was written, tested, and called by nothing, so the two-factor gate in front of every consequential owner action could never be passed. And /admin/verify called the TOTP check without a session id, so a correct code was accepted, audited as accepted, and stamped nothing the gate could see.
Each control was right. Each was unreachable. The fix was never to loosen a control: an owner-panel action creates a workspace (consequential, needs a fresh code, audited, and structurally absent from the automation identity's capabilities); an enrolment page shows the seed and recovery codes once on a response that is never cached; and the verify route now resolves the session it is stamping exactly the way the login-complete route does. One test (AUTH-452) keeps the old defect as a tripwire: a correct code with no session id must still stamp nothing, so the fix cannot quietly regress into "the code was right, therefore let them through".
What remains is the owner's, and it is listed in docs/owner-actions.md in order: set the bootstrap address and a token on the deployment, claim the owner account, enrol, create the isolated test workspace, sign in as it. Nothing in that list can be done from this side, and nothing in it should be.
An approved design almost nobody would have seen
The owner commissioned a design, approved it, and asked for it. The first implementation made the approved appearance the default and let a light operating-system preference switch away from it: the conventional, polite choice, and one that meant that on most machines the deployed page was indistinguishable from the page before the change.
An approved redesign implemented so that almost nobody would see it is a change that reports success without producing the outcome. That is the defect this product exists to find, in the form of a media query. The approved appearance is now unconditional. The light palette is not deleted: it stays complete, stays measured by the contrast suite, and stays reachable through the explicit toggle.
One value in the approved palette was not taken as drawn. Its resting status colour measures 6.7:1 on a badge tint dark enough to sit in this palette, against a floor of 7.8:1 this project set for itself. The choice was to lower a measured accessibility minimum to fit a palette, or to lighten the shade until it cleared. It was lightened.
---
How the work was organised
Twelve specialist roles, each given a bounded task, a set of files it alone owns, and the specific facts it needed rather than the whole repository. They reported back with the commands they ran and the real output.
Some findings only exist because the reviewer was a different agent from the author. The security review was told to challenge the implementation, not confirm it, and it wrote tests that fail against real defects rather than a document full of reassurance. Six such tests were committed red, on purpose, and closed one at a time.
One deliberate duplication: the security reviewer and the data specialist independently implemented webhook signature verification for Stripe and for Resend, from the vendor specifications, without seeing each other's code. Both implementations were then tested against each other. Two separate readings of a specification agreeing is the strongest evidence available without a live provider call, and it is not the same as a live provider call, which is why the report says both things.
Models were chosen by risk rather than by default. Architecture, payments, tenant isolation and security review went to the strongest available model. Product copy and competitor research went to a cheaper one. Bounded scripting tasks went to cheaper ones still. Counting tests, validating a schema and scanning for secrets are done by code, not by a model. Those are exactly the jobs where a model would be slower, dearer and less reliable.
---
Where it stands
Built and tested. The verification engine, the data layer, the security primitives, the connectors, payments, the customer journey, support and privacy handling.
Live. verify.itisyou.app, serving over TLS, with a health check that actually probes the database instead of returning a hard-coded "ok". The owner's approved colour system, type scale, elevation and shared layout, unconditional rather than offered to whoever's machine happens to be set dark. A visit counter that now writes to the database the launch objective is measured by.
Not yet a count of strangers. That counter currently holds two sessions marked external, and both fall inside this project's own working window, on the pages it was checking at the time. A browser cannot send the header that marks internal traffic, so the classifier has no way to recognise the person building the thing. The objective is ten genuine external visits; until the operator is recognisable, the figure is not yet measuring that, and this page says so rather than letting the number speak for itself.
Real evidence, on a deployment. Read out of staging: one VERIFIED run backed by a provider read-back, and two UNVERIFIED runs backed by provider webhooks. The two that resolved to "could not check" are the more important half: absence of evidence landing on unknown rather than on a pass is the entire product.
Paid once, in sandbox. A real Checkout Session created by the deployed service and paid with a test card, £29.00. No live payment has been taken, and live charges stay disabled.
The payment did activate, in the end. The paragraph that stood here said the provider delivered six events and both deployments rejected all six, and that no subscription existed. That was true when it was written and stopped being true on 20 September: the signing secret was present the whole time and the fault was ours: a trailing newline the resolver never trimmed. Resent, the events were accepted, and staging holds one active subscription and one allowance of 500 runs, granted exactly once, unchanged by a replay.
Both providers have now answered real calls. Resend on 19 September, HubSpot on 20 September: a contact read back from a live portal supported a verified run, and a run whose retrieved record belonged to a different enquiry was contradicted on the correlation reference rather than merely reported missing. Against our own accounts and our own synthetic records, which proves the providers answer us and nothing about your portal.
The product can be entered through its own buttons. /app and the first onboarding step rendered a permanently disabled control, so the seven setup steps could only be reached by knowing the form routes and posting to them by hand. The reason the disabled control gave was about buying the product (live payments off, signup closed), and it was being shown to people already signed in to a workspace that exists. Both controls now render on the same condition the server enforces on every setup write: the reader is a workspace admin. A viewer sees the sentence the server would have answered their first write with. A new test walks from the workspace page to the checkout step using only controls the served page offers, submitting the forms, and stops at the checkout step because that step needs two connected providers, asserting that the page states a reason rather than dead-ending.
The design exclusions are now enforced by tests, not by good intentions. The owner gave a list of twenty-four visual devices this product may not use. Eight of them were shipped: a gradient headline, a blurred orb behind two panels, drop shadows, a glass header, soft rounded corners, an excluded typeface in the font stack, a pure-white surface, and coloured left-border callouts. Every one had arrived with a comment explaining why the approved design wanted it, which is the point: each was defensible alone, and the list was nobody's job. They were removed at the token and stylesheet layer so the fix reaches all nineteen screens at once. Five new cases assert a device is absent from the whole stylesheet, and two more check what a reader actually sees on five rendered pages. Three older cases had been written to hold two of those devices in place, and now assert the opposite.
This paragraph said "nine of them" and "six new cases … absent from the whole stylesheet" until a later audit counted both. Nine included two dead custom properties, which are residue rather than one of the twenty-four; and of the seven cases, only five are stylesheet-wide. The same audit found two breaches the original count had missed, em dashes in copy and a three-column card grid on the security page, both since fixed. A paragraph about enforcing a list is worth very little if the count in it was never checked.
You can now find out whether your connection still works, and what that does not tell you. A Test connection button beside each provider makes a fresh, bounded check and reports three things separately: whether the provider answered our read just now, whether a correctly signed callback has ever arrived, and whether your workflow is verified. The third is always "not checked", because nothing about a healthy credential can tell us whether your automation reports its enquiries to us. The code that performs this check had existed for days, fully tested, and was called from nowhere at all. A provider we cannot reach never costs you a re-pasted key.
And you can test the whole thing end to end, without the test flattering you. Describe one enquiry using four values that must already exist: a CRM record, the correlation value on it, a message id, and the address it should have reached. We create nothing and send nothing. The event is admitted through exactly the same door a real one uses and decided by the same engine reading the same providers, so it starts as pending and can come back failed or unverified: that is the check working. It costs one run from your allowance, and the page says so above the fields rather than after the button, because a free side door would be a different code path and a result from a different path would tell you nothing about the one your automation uses. Test runs are marked, and excluded from both your verification rate and our own figures, so testing cannot make either of us look better than we are.
The site moves now, carefully. One motion language rather than scattered effects: content settles in, controls respond, disclosures expand, pages cross-fade. It adds no JavaScript at all, and anyone who asks their system for reduced motion gets none of it. Two things deliberately do not move: the large verdict readout, because a verdict that fades in reads as an effect rather than as a finding, and this page, which tells you nothing is animated and is held to that by a test.
A fix that a lower layer was quietly undoing. The billing portal used to open on a session that had already been spent, so the first thing a customer saw was that their session had expired. The obvious cause was fixed days ago: the session is now created when the button is pressed rather than when the page is drawn. Running the journey against a deployed service rather than reading the code showed it happening anyway. One layer further down, every opening was sent to Stripe with the same idempotency key, and Stripe answers a repeated key by replaying its stored response for a day: the second press got the first session back, already used. The key is now unique for every opening, and two presses on the deployed service produce two different sessions. A test that stubs the payment provider could never have seen this, and did not.
The design references were read properly for the first time. The exported images turned out to be 351-pixel thumbnails, which is why nothing had ever really been compared against them; each design is now rendered in a browser at the same widths the site is built to, beside ours. Three things came out of that and are live: the comparison this product is about now takes the space it deserves on the home page instead of three compressed lines, each setup step shows the exact shape of what you would send rather than describing it, and the administrative panel navigates by a column of sections instead of thirteen links wrapped across the top. Several ideas in the references were refused on purpose, and the reasons are written down: a centred opening that pushed the argument off the screen, a wall of fourteen integration logos for a product that reads two, and every invented number on the administrative design. One real defect fell out of the comparison: a reader who asks their system for less motion was being shown a card that never became visible. Eleven screens have been rendered and captured but not yet compared, and they are listed as such rather than counted as done.
The site moves, and now something holds it to that. The motion was already there: content settling in, controls responding, disclosures expanding, pages cross-fading, and none of it for a reader who asks their system for less motion. What was missing is the part that makes it last. Nothing tested it, and neither failure shows up in a screenshot: a transition that has quietly stopped working looks like a design choice, and so does one that has grown too pleased with itself. There are now five checks that describe the occasions rather than the taste, and the behaviour was measured in a real browser rather than read off the stylesheet. Two gaps turned up while writing them: one disclosure opened instantly while the one beside it glided, and a form error appeared between frames. Both fixed.
Not yet true. Live customer payments, because that needs the owner's approval, and live objects in the real Stripe account; the decision page lists each with its evidence. A paying stranger: the only workspace on production is the owner's own test workspace, and public signup stays closed. Ten genuine external visits, the honest count is still zero. Four of nineteen screens remain uncomposed; /security has no owner-approved reference to compose against, which is why it cannot simply be built. The demonstration page's runs are still fixtures. Advertising: paused on 21 September 2026 at 08:50 UK by the owner's own account, deliberately, visible in the campaign's change history, not under review and not delivering; £12.25 total budget, 0 impressions, £0.00 spent.
Spent so far: £0.00 confirmed against the £100 budget: no campaign activated, no new paid resource, and the £30 contingency untouched and separately gated. That figure rests on one assumption the owner has not confirmed: that model usage is a development cost rather than a charge against the £100. docs/spend.md states the assumption rather than burying it, because a budget figure that depends on an unconfirmed reading is not the same as a measured one.
---
_This page is generated from the same record as the machine-readable story in docs/development-story-events.json. If the two ever disagree, that is a defect in this page._