In short
- Every place that holds personal data is listed in one register, measured from the code rather than written from memory.
- Each privacy feature ships with server tests that run it against realistic records, including the awkward cases.
- A reviewer who did not build the feature reads it fresh, looking for ways it could fail.
- We plant deliberate bugs to prove the tests would catch them.
Start with a map you can trust
You cannot erase a person from places you do not know about. Moirova keeps a register of every collection that can hold personal data: what it holds, why, how long it is kept and how each privacy right applies to it.
The links between records and people are not written from memory. A tool reads every place in the code that writes data and records which fields tie a record to a person. If someone adds code that stores personal data somewhere the register does not know, a test fails before it can ship.
Test the hard cases, and the normal ones
Each privacy feature comes with server tests that run it against realistic records. The interesting tests are the awkward ones:
- Two contacts who share an office email address: erasing one must not touch the other.
- A phone number written three different ways: all of them must be found, and unrelated numbers left alone.
- An erasure interrupted halfway: it must finish, not start again or stop with half the work done.
- A restore from a backup after an erasure: the person must not come back.
We also test that the normal path works. A check that refuses everything would pass every "refuse this" test and still be broken, so every guard has a test that ordinary input passes.
A fresh pair of eyes
The person who builds a feature knows how it is meant to work, which is exactly why they miss how it can fail. For every high-stakes privacy feature, a separate reviewer who has not seen the work reads it from scratch, looking for data that could leak, records that could be missed and checks that could be skipped. Their findings are fixed and each fix gets a test of its own.
Plant bugs on purpose
A test suite can pass because the code is right, or because the tests are too weak to notice it is wrong. To tell the difference, we deliberately break the code in small ways - remove a check, swap a condition, skip a step - and run the tests again. Each planted bug must be caught. When one is not, we write the test that was missing.
Check what people see
Finally, an automated browser opens the screens in the dark and light themes, on a desktop and a phone, and checks them: no errors, nothing cut off, the words the guide promises actually on screen. The guides in our Help center describe only what those tests show the product does today.
What the numbers look like
Tests are only as good as what they cover, so here is the size of it today. The server tests for the privacy features - finding a person, exporting their data, correcting and restricting, erasing with approval, team-member requests and retention - run close to seven hundred checks against realistic records. Every release runs every earlier test suite again and compares the results with the release before, so a change in one feature cannot quietly break another.
Planted bugs are counted too. In our most recent release, which keeps the files clients attach to their emails, 14 deliberate bugs were planted - a size limit removed, a type check skipped, a counter left out - and all 14 were caught by the tests before the release went out.
Every guard is tested both ways
A guard is a check that refuses something: an erasure without approval, a file that is not what its name says, a request from another workspace. The easy mistake is to test only that the guard refuses. A guard that refuses everything passes that test and is still broken, because ordinary work stops.
So each guard in Moirova has two kinds of test. One proves it refuses what it should. The other proves that ordinary, correct input passes straight through. Only when both pass do we consider the guard done.
Restores are rehearsed, not assumed
A backup you have never restored is a hope, not a plan. We rehearse restores of a single workspace from a backup, and the rehearsal checks that an erasure made before the restore is applied again, so the person does not come back. A restore that would bring back personal data that was erased is treated as a failed restore.
Reproduce first, then fix
When a customer reports a problem, the first job is to make it happen again, on purpose, in a test. A report describes what someone saw; the cause can be somewhere else entirely. A fix written from the description alone can leave the real fault in place.
So every reported privacy or security problem gets a test that fails because of it, before any code changes. The fix is done when that test passes - and it stays in the suite, so the same problem cannot return unnoticed.
What we do not claim
Testing is not the same as an independent audit. We have not yet been through a formal third-party security audit, and we do not say otherwise. Our Trust center lists where data is kept, which sub-processors handle it and how backups and restores work, and it says plainly which independent audits we have not completed yet. When we complete one, it will be listed there with its date.
Tests that read the reads
Some promises are about what the software does not do. When Moirova links a customer workspace to our own records, for example, it must carry account details only and never read the customer's clients, deals or invoices. A test that checks the result cannot prove that, because a hidden read leaves no trace in the result.
So those tests record every read the code makes against the database while it runs, and fail on any read of a collection it has no business touching. It turns a promise in a policy into something a machine checks on every release.
Small changes, each one checked before it lands
Every change to Moirova ships as one small, reviewable update. Before it writes anything, the update checks that each file it changes is exactly the version it was made for, and stops without changing anything if one is not. It keeps a copy of every file it replaces, and running it twice does nothing the second time. That discipline matters for privacy: a change that half-applies is how a check disappears without anyone noticing.
After each update, the full set of tests runs again on the result and is compared with the run before, so the only differences are the ones the change meant to make. A difference nobody planned is treated as a failure until it is explained.

