HOW IT IS BUILT
Anyone can put up a good-looking site. This page exists so you can tell the difference between that and a system that will still be right about your money in two years. Plain version first; the engineering is underneath it for whoever you want to show.
If you have ever run one job through three apps that do not talk to each other, you already know every failure below. Here is what this does instead.
The app keeps working with no bars — he checks out, adds photos, closes the job. It syncs when the phone finds signal, and if something clashes with what the office did meanwhile, a person is told. The system never quietly picks one and bins the other.
Photos and notes attach to the work order itself, and the original is always kept. Nothing overwrites what your tech actually shot.
The job and the invoice are one record. What was quoted, what changed, what was charged and what the tech was paid all hang off the same job.
Nothing is silently edited. A correction is a new entry sitting beside the old one, so when a customer argues about an invoice you show the history instead of arguing from memory.
Stripe handles the card. We keep the amount and whether it cleared. We never see the number, so we cannot lose it.
The core of the system carries about 1,650 automated checks that re-run automatically every time the code changes, plus another 200 across the two phone apps. If a change would break how jobs move or how money is recorded, it fails there — before it ever reaches you. That is the honest difference between this and a site someone threw together.
From here down it gets technical. You do not need to read it — it is here so that if you ever hand this to someone who does, there is something real for them to check.
A request crosses six boundaries before it changes anything. Each one fails closed: if a check cannot be performed, the answer is no, not “continue anyway”.
Holds a hardware-backed P‑256 key generated inside the Android Keystore. Every action is signed on the device and queued locally, so the app keeps working with no signal. This event-signing key never leaves the device; the client certificate below is a separate keypair, issued on the host before installation.
The device presents a client certificate. No certificate is a 401 before any application code runs; a revoked one is refused at the TLS layer against a revocation list. Identity is re-emitted from the verified certificate, so client-supplied identity headers are ignored.
Who you are comes from a server-minted, HMAC-signed token — never from anything in the request body. Every state-changing form carries a single-use token bound to both the session and the specific action.
Work orders move through gated transitions. There is no “set status directly” path — not in the admin tools, not in migrations, not in scripts. Synced offline events re-run the same gates.
Every change is an immutable event carrying actor, timestamp and validation state. Events are chain-hashed to the one before them, so a record cannot be altered or removed without breaking the chain.
The projection you read is rebuilt from the event log. If the two ever disagree, the log is the truth and the mismatch is reportable.
Web identity is an HMAC‑SHA256 token issued only after someone proves control of their email address. An earlier build trusted an identifier supplied in the request — a real access-control bug, found and closed. Identity has come from the signed token ever since.
apps/http-ingress/src/session.rsThe link a customer receives is signed and carries the work order and the account it belongs to. It expires, it is compared in constant time so it cannot be guessed a character at a time, and if no signing secret is configured the server refuses to mint or accept links at all rather than falling back to trusting them.
ADR-065 · apps/http-ingress/src/customer_link.rsIf a device or account is compromised, one operation strips every operational role it holds, and it takes effect on that actor’s next request. It is append-only and reversible, so a containment made in error is undone by re-granting rather than by editing history. Revoking the device’s certificate is a second, separate layer and is currently an operator step — so the role kill is immediate, the certificate kill is not.
ADR-059 · apps/authorization/src/containment.rsThis is where most field software breaks: a technician in a basement with no signal. The usual answer is that the app stops working and the paperwork happens later from memory.
Actions are recorded and signed on the device while it is offline, then submitted in batches when signal returns. Two separate hash chains — one across batches, one across individual events — mean a dropped batch, a reordered event or a replayed one is detected rather than absorbed.
apps/sync/src/envelope.rs · apps/sync/src/reconciler.rsWhen a synced action disagrees with the server’s state, it is not applied and not guessed at. It produces a reviewable conflict. Every submitted event is re-run through the same validation gates a live action goes through — syncing is not a back door.
INV-003, INV-004, INV-007 · apps/work-orders/src/sync_applier.rsStripe handles the card. Rivet stores the amount, the fee, the net and the status — never a card number. That is deliberate: the smaller the amount of payment data a system holds, the smaller the problem a breach of it would be.
apps/http-ingress/src/payment/stripe.rsA live Stripe key is refused unless a second, independent environment flag explicitly arms it — so a production key cannot be picked up by accident in a test environment. The secret is written to redact itself, so it cannot leak into a log line, a panic message or a stack trace.
6 tests · STRIPE_LIVE_ARMEDBilling history is append-only. A correction is a new entry, not a rewrite, so what a customer was charged and why is reconstructable months later.
INV-005 · tests/inv_005_revision_history_recoverable.rsEmail addresses and phone identifiers are held as SHA‑256 hashes rather than readable text, so the database can recognise a returning person without holding a list of everyone’s contact details in plain form.
email_hash · phone_addr_hashSecurity alert lines are covered by a test that fails if the output contains an @ sign, the word “phone” or the word “email”. Log hygiene is a build failure here, not a code-review convention that erodes.
security_alert.rs::line_is_pii_cleanThe diagnostic assistant can suggest to a technician; it cannot change a work order, move money, or close a job. That is an enforced invariant, not a policy — the AI paths can only append advisory records.
INV-014 · ADR-063The invariant register is the unusual part. Each rule carries enforcement at four levels — database constraint, service logic, a test that fails if the rule is broken, and the audit log as final witness. The test names are the rules:
| Test | What it would catch |
|---|---|
| inv_007_no_state_backdoor | Any path that sets a work-order status without passing the transition gates |
| inv_004_no_silent_merge | A sync conflict being quietly resolved instead of raised |
| per_tenant_isolation | One customer’s data becoming reachable from another’s account |
| sync_envelope_signature_verify | An unsigned or tampered batch being accepted from a device |
| dual_replay_determinism | The same events replaying to two different end-states |
| engine_purity | Business rules reading the clock or randomness, making outcomes unreproducible |
| inv_008_completion_evidence | A job marked complete without the evidence that proves it was |
These were attempted against the live system with real device certificates — not reasoned about on a whiteboard. The first four were re-run on 24 September 2026 and still hold.
| Attempt | Result |
|---|---|
| Use a valid device certificate to read another technician’s jobs | Blocked — only own jobs returned |
| Forge identity headers while holding a valid certificate | Ignored — certificate wins |
| Connect with no client certificate | 401 — before app code |
| Reuse a revoked certificate | Refused — at TLS |
| Technician escalates to file a client dispute | 403 — no mutation |
These results say the controls held against the attacks we ran, and the suite says the code does what its tests require. That is evidence, not proof of a negative — nothing can prove no vulnerability exists.
Rivet is pre-launch and runs as a single-node pilot. The evidence on this page is our own suite and our own probes — there is no third-party penetration test or security certification behind it yet. Some steps that will eventually be automated, like issuing and rotating device certificates, are done by an operator today.
The terms and privacy pages are engineering-staged and not yet counsel-reviewed, and say so at the top of each page.
If you want to go further than this page: ask, and we will walk your engineer through the architecture and re-run every check above, live. Very few vendors at any stage can do that second part.