Is Even Cents secure? How your data is encrypted
Short answer: your financial data in Even Cents is encrypted at rest under a key derived from your password, which means the people who run Even Cents cannot read it. Not in the database, not in the backups. Here’s the longer answer, because trust should come from understanding how something works, not from a badge.
What “encrypted at rest” actually means here
A lot of services say “encrypted at rest” and mean the disk is encrypted — which protects against someone stealing the physical drive, but does nothing if the operator (or anyone who compromises the operator) can simply read the database. The data is plainly visible to whoever holds the keys, and that’s the company.
It’s worth separating the three things that phrase can mean, because they differ enormously:
- Full-disk encryption. Protects against physical theft of hardware. Once the machine is running, the data is readable to any process on it. This is the weakest version and the most commonly advertised.
- Provider-managed encryption. The database encrypts with a key the provider holds. Protects against a leaked backup file. Does not protect against the provider, an employee, or an attacker who gets far enough in to ask the application for the data.
- Key derived from your password. The operator cannot decrypt, because the operator doesn’t have and can’t compute the key.
Even Cents does the third one.
How it works, concretely
When you sign up, a unique random 256-bit data encryption key (DEK) is generated just for your account. Everything sensitive you enter — amounts, payees, notes — is encrypted with that key using AES-256-GCM before it’s written to the database. GCM is an authenticated cipher, which means tampering with the ciphertext is detected rather than silently producing garbage. Decryption fails closed: if anything doesn’t verify, you get an error, never wrong data.
The database only ever sees ciphertext.
The key is derived from your password
The piece that makes this meaningful: your account’s DEK is itself encrypted — “wrapped” — with a key encryption key derived from your password using Argon2id, a deliberately slow and memory-hard key derivation function. Slow and memory-hard matter because they make brute-forcing the password expensive even for someone holding the wrapped key and purpose-built hardware.
Your password never reaches the database in a form that can decrypt anything. What’s stored is the wrapped DEK, and unwrapping it requires the password.
The practical consequence: we can’t read your data, because we don’t have the key. An employee querying the database sees gibberish. A breach of our backups exposes gibberish. The only thing that unlocks your data is your password, entered by you.
Where the key lives while you’re logged in
This is the part that most “zero-knowledge” marketing skips, and it’s the honest limit of the design.
To show you your own data, the server has to be able to decrypt it. So when you log in, your password unwraps the DEK, and the unwrapped key is held in server memory only — in an in-memory table keyed to your session, with a time-to-live, swept on expiry and dropped when you log out. It is never written to disk and never persisted alongside your data.
What that protects against: database dumps, stolen backups, an employee with SQL access, a subpoena served on the stored data, a compromised disk.
What it does not protect against: an attacker with live code execution on the running server while you are logged in, who could read the key out of memory. No web application that renders your data server-side can defend against that, and any product claiming otherwise is either doing all decryption in your browser or overselling.
One more party in the path: Cloudflare
Even Cents sits behind Cloudflare for DDoS protection. That means traffic reaches Cloudflare’s edge before it reaches our servers, and because Cloudflare terminates the encrypted connection there, it is technically in a position to observe requests and responses in transit — including your password at login and the decrypted data rendered into a page.
This is true of essentially every site behind a CDN or DDoS filter, and Cloudflare is contractually a service provider processing that data only to deliver and protect the service. But it’s a real party in the chain, so it belongs in an honest threat model rather than in the fine print.
What it doesn’t change: the at-rest guarantee. Your data in the database and in backups is still ciphertext under a key derived from your password, and we still can’t decrypt it.
What it does mean: “the operator can’t read your data” is a claim about stored data, not a claim that no intermediary could ever observe data in transit. If your threat model includes network intermediaries, no server-rendered web app — this one included — is the right tool; you want something that decrypts exclusively in the browser.
We’d rather state the boundary than imply a stronger one.
The honest trade-off
This is the part other apps gloss over, and we won’t. A key only you hold means a key only you can lose.
If you forget your password, you can still get back in with the one-time recovery code shown when you sign up — it’s a second key to the same lock, which is why you should store it somewhere safe. But if you lose both your password and your recovery code, your data is genuinely unrecoverable. We can’t reset it for you, because “resetting” it would require us to have had access all along — which is exactly the access we designed away.
That’s not a limitation we’re embarrassed by. It’s the cost of a design that’s actually worth something: by design, your data is readable only with your key.
A useful test you can apply to any service: if they can restore your access after you forget your password, they can read your data. Those two properties cannot both be true. Plenty of products advertise both.
Store the recovery code the way you’d store a spare house key — a password manager, or printed somewhere secure. Not an email to yourself, and not a screenshot in your photo roll.
Sharing, without handing us the keys
Household sharing works the same way. Each account also gets an RSA-2048 keypair. When you invite someone to your household, your DEK is encrypted to their public key — so their password unwraps their private key, which unwraps your DEK, and they can decrypt your data. The operator still can’t, at any point in that chain.
The trust is between you and the person you invited, never with us. Which also means: revoking access stops future sharing, but someone you previously invited had genuine access to that data, exactly as if you’d shown it to them. That’s how sharing works when the operator isn’t the gatekeeper.
Why there’s no bank linking
This follows directly from everything above, and it’s a deliberate choice rather than a missing feature.
Automatic transaction import requires a server that can read your transactions — to fetch them, categorize them, and match them against what you already have. The moment the server can do that, it can read your finances, and the guarantee at the top of this page is gone.
So it’s a genuine either/or: an operator who imports your transactions for you, or an operator who can’t see them. Even Cents picked the second, which means you enter transactions yourself. For some people that’s the wrong trade, and that’s a legitimate position — see the Mint and YNAB comparisons, both of which say so plainly.
What this doesn’t cover
For completeness, the things encryption at rest isn’t:
- It isn’t protection against a weak password. The whole chain starts there — Argon2id makes guessing expensive, not impossible.
- It isn’t protection against a compromised device. Malware on your laptop sees what you see.
- It isn’t end-to-end encryption, and we don’t claim it is. Decryption happens on the server so pages can be rendered.
- It isn’t a guarantee of availability, and it isn’t a backup. Encrypted data you can’t decrypt is lost data.
- It isn’t an audit. Nothing here has been independently reviewed, and you should weigh that.
No system is perfectly secure, and nothing here is a guarantee — but the architecture is built so that your data isn’t ours to read.
You can read more about the product on the about page, or about the concepts in the glossary — it’s free to start.