HOW IT IS BUILT

Not a website with a database behind it.

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.

00In plain terms

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.

NO SIGNAL

Your tech can finish the job in a basement

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

Pictures live on the job, not in a second app

Photos and notes attach to the work order itself, and the original is always kept. Nothing overwrites what your tech actually shot.

INVOICING

You do not re-type the job to bill it

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.

DISPUTES

You can prove what happened six months later

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.

CARDS

Card numbers never touch us

Stripe handles the card. We keep the amount and whether it cleared. We never see the number, so we cannot lose it.

MISTAKES

The software is re-checked every time it changes

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.

01The engineering, for whoever asks

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.

The layers

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”.

DEVICE

Technician app

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.

EDGE

Mutual TLS

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.

INGRESS

Session, authorization, request integrity

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.

DOMAIN

State machine

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.

AUDIT

Append-only event log

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.

STORE

Postgres or SQLite

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.

02Identity is never something you send us

The session is minted by the server

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.rs

A customer link opens exactly one job

The 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.rs

Access can be cut in one operation

If 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.rs

03The technician’s device

This 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.

It works offline, and the record is still trustworthy

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.rs

Conflicts surface, they are never silently merged

When 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.rs

04Money

Card details never reach our servers

Stripe 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.rs

The keys are hard to misuse

A 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_ARMED

Every charge traces to the contract that authorised it

Billing 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.rs

05What we keep about people

Contact details are stored as hashes

Email 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_hash

The logs are tested for it, not just reviewed

Security 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_clean

AI assists, it never acts

The 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-063

06How we know any of this is true

1,648TESTS PASSING
0FAILING
14ENFORCED INVARIANTS
26SERVICE CRATES

The 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:

TestWhat it would catch
inv_007_no_state_backdoorAny path that sets a work-order status without passing the transition gates
inv_004_no_silent_mergeA sync conflict being quietly resolved instead of raised
per_tenant_isolationOne customer’s data becoming reachable from another’s account
sync_envelope_signature_verifyAn unsigned or tampered batch being accepted from a device
dual_replay_determinismThe same events replaying to two different end-states
engine_purityBusiness rules reading the clock or randomness, making outcomes unreproducible
inv_008_completion_evidenceA job marked complete without the evidence that proves it was

07Attacks we ran at it ourselves

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.

AttemptResult
Use a valid device certificate to read another technician’s jobsBlocked — only own jobs returned
Forge identity headers while holding a valid certificateIgnored — certificate wins
Connect with no client certificate401 — before app code
Reuse a revoked certificateRefused — at TLS
Technician escalates to file a client dispute403 — 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.

Where this is today

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.