Quality

Tested Before You See It

Three gates, run on our own machines, before anything leaves them.

Every change passes through checks that run where the change is made: before it is pushed, before it ships to a store and before it reaches the server. The numbers below are counted from the code.

Zistil Insights screen showing an organization health score, what you own by category and how many items each storage space holds
The Zuzzle hub, showing today's daily puzzle and the Space Age era card, Decimal, Base 10.
The Zupply list on an iPhone: one shared grocery list grouped by category, with Bakery, Beverages, Cleaning Supplies and Dairy, and the household member who added an item named under it.
Zistil OURS
Zuzzle OURS
Zupply OURS
  • 24,000+

    Flutter tests

  • 1,500+

    Flutter test files

  • 6,600+

    Cloud tests

  • 43

    Packages

30,000+ automated tests in all, across the apps, the shared packages and the cloud code. Counted from the test definitions in our source code each time this site is built. They are tests written, not a pass report, and the cloud count leaves out the suites that need a live server. Last counted November 13, 2026.

The gates

Three gates, three moments

Each gate runs on the machine making the change. A failure stops the change right there: nothing is committed, released or deployed on top of a red check.

Before every push

The push gate

One command, called stone, sorts what changed, runs the checks for it, and only then commits and pushes.

  1. It sorts the change: shared package, app, cloud code, website, or documentation only. Documentation-only changes skip the tests.
  2. A changed shared package runs its full test suite.
  3. A changed app runs the analyzer over the whole app.
  4. Changed cloud code gets its database schema validated and its offline test suite run. Suites that talk to a real server never gate a commit.
  5. A changed website runs its lint and format checks, or its production build.
  6. A changed store product catalog stops the commit and asks whether the App Store, Google Play and billing dashboards match the change.
  7. Any failure stops everything. Nothing is committed and nothing is pushed on top of a red check.
  8. When it passes The commit is made, the changelog gets its entry, the latest main is brought in, and the push goes out.

Before every store release

The pre-ship gate

A hard go or no-go that runs before the changelog is stamped, the release is tagged or any build starts.

A single no-go stops the release. Overriding the gate takes an explicit decision, and the report still lists everything it bypassed.

  1. The version has not been released before.
  2. The analyzer is clean.
  3. The app's full test suite passes.
  4. The release notes have entries and pass our writing rules.
  5. By hand For paid apps, every upgrade promise a user can see is checked against what the server really grants.

Before every cloud deploy

The cloud pre-deploy gate

Cloud files reach the server one at a time, and the server reloads after each one. So the order matters, and the checks run before and after.

The offline cloud tests have already run at the push gate.

  1. Before The deploy order is worked out from the code's require graph, new files first, so every in-between state still loads.
  2. Before Each live file's checksum is compared with the local copy, so we know what is really running before we replace it.
  3. Blocks the deploy A syntax check over the cloud files, because one syntax error can stop every later module from registering.
  4. Blocks the deploy A load smoke test: the cloud entry point has to load, and the functions it registers must match the committed manifest exactly.
  5. Blocks the deploy Schema validation: every class and field the cloud code uses must exist in the database schema file.
  6. Blocks the deploy A security check on class permissions, which refuses a world-open write.
  7. After The live server is asked what it actually loaded, and the answer is compared with the committed manifest and schema. A broken load raises an alert to roll back.

By risk

Testing by risk

Not every change needs the same ceremony. We size the checks to what could go wrong.

Small changes

The test comes first. Then the change, then the analyzer on the files that changed, and a screenshot when the change is visual.

Changes that touch a named risk

These areas get two extra checks before the change moves on.

  • Money and payments
  • Sign-in
  • Privacy
  • Child safety
  • Deletion
  • Concurrency
  • An independent review

    A separate Claude Code review, which did not write the change, reads the change and its tests looking for what the author's tests miss.

  • Mutation runs

    We break the rule on purpose, for example by removing an ownership check or flipping a payment condition, and run the tests. If they still pass, they were not guarding that rule, and the missing test is added before the change moves on.

The guards

What the tests guard

Three kinds of test carry more weight than the rest, because they catch what a normal unit test cannot.

  • Model tests against real server payloads

    Every model that reads a server response is tested against fixtures shaped like the real thing: full, sparse, with unknown fields, with missing nested data and in legacy shapes. This catches the bug where the server sends a list and the app expected text, before it reaches a phone. Our rule is that a change to a response shape runs these tests before it deploys.

  • Compliance tests that enforce the design system

    Design rules are tests, not guidelines. Every visual component must ship a loading skeleton or say why it needs none, every standard screen must use the shared screen scaffold unless it is on a justified exemption list, and every paid app must wire the same trial and tier chrome. A new screen that skips one fails the suite.

  • Cache merge-law checks

    Data that follows a person across devices is merged by a rule, and we check that rule against the laws that make a merge safe: merging a record with itself changes nothing, the order of two merges does not matter, and the grouping does not matter. When those hold, two devices that edit offline settle on the same answer.

The walk

A walk of every changed flow

Tests prove the rules hold. They do not prove the screen works. Before a release we walk every flow the change touched and look at the result ourselves.

  • On a simulator or a device

    Apps are tapped through the way a user would use them, flow by flow, on a simulator or a real phone.

  • In a browser

    Web changes are opened in a browser and walked the same way.

  • In stages

    Builds go to TestFlight and Google Play internal testing first. Going live in a store is a separate decision, made after that build has been used.

Client projects

For clients

Every client project gets the same baseline and the same gates.

  • The baseline that fits your stack is copied into your repository: the analysis, lint and format rules, the model-test rules, the pre-ship gate for apps and the pre-deploy gate for cloud code.
  • You own that copy, so the checks keep working after handover.
  • Updates to the baseline are pulled in deliberately, never pushed into your code.