Moopro: end-to-end encrypted personal finance app

Presentation

Moopro is an app I implemented from scratch to manage all my personal finances.

Built for all platforms (web, Linux, Windows, macOS, Android, and can technically build for iOS but I don’t have an Apple developer account required to publish iOS apps). Backend hosted in the cloud.

This article focuses on the implementation details specific to moopro: end-to-end encryption, financials concepts I had to define, frontend implementation, and tradeoffs I had to decide about. Backend infrastructure is adapted from my other projects, thus it is mentionned but not detailed.

Requirements

Tech stack

Architecture overview

Before I dive deep into the implementation details, here is a high level summary of how moopro technically works:

WorkWhere it runsWhy
Encryption / decryptionOn the deviceThe server must never hold a key
Balances, charts, forecastsOn the deviceThey need plaintext
OCR / statement parsingOn the deviceStatements never leave unencrypted
Market & FX price fetchesOn the device, straight to public APIsThe server must not learn which assets you hold
Storing and versioning recordsServerIt only sees opaque ciphertext blobs
flowchart LR
    subgraph Device["Your device (trusted)"]
        direction TB
        UI["Flutter UI"]
        Dom["Domain logic<br/>balances, charts, forecasts"]
        Crypto["Crypto<br/>Argon2id + AES-256-GCM"]
        Cache[("In-memory plaintext cache<br/>never written to disk")]
        Disk[("On-disk store<br/>ciphertext only")]
        UI --> Dom --> Cache
        Dom --> Crypto --> Disk
    end

    subgraph Server["Server (untrusted)"]
        Blob[("Opaque ciphertext blobs<br/>+ wrapped key")]
    end

    Market["Public market / FX APIs"]

    Disk <-->|"ciphertext only"| Blob
    Dom -->|"direct, never proxied"| Market

The backend is a pure encrypted blob store with a sync REST API. It contains no financial logic.

Moopro trades convenience, server-side intelligence and password recovery for a system where the server cannot read, alter-undetected or profile your finances, and it keeps the limits of that trade off written down instead of hidden.

Financial concepts

Everything that holds value is represented by an asset

There is no special “currency” type. EUR, USD, AAPL, BTC, bonds and shares are all assets. Assets each have a kind property telling what sort of asset (fiat, stock, etf, crypto, realEstateBond, other). kind is locked after creation because it drives precision and price-linking, while the name and symbol stay freely editable because every other record refers to an asset by its id, never by its symbol.

The app defines one main currency that will be used to display value of other assets over time.

realEstateBond is the odd one out: unlike a stock, where everyone holding AAPL holds the same thing, each bond asset is exactly one real-world project. Its balance reads as “still invested in this project” and reaches zero when fully repaid.

By following this concept, I can for example define buying a share with a trade transaction between some amount of an asset of kind currency and one unit of an asset of kind stock.

Assets are stored in containers

This is the central idea of Moopro. A container is anything that holds quantities of assets, and there are exactly two kinds:

HolderBudget
MeaningWhere the money physically isWhat the money is for
ExamplesBank account, brokerage account, crypto walletHousing, Savings, Investments
Real?Yes, matches an external accountNo, a user-defined virtual allocation

Holders are enforced to be a flat list to simplify their management, but budgets (actually the container data model itself) are designed to also have child containers. Which means budgets can be seen as a tree (budgets nest into sub-budgets). For example. Budget Spendings may contain sub-budgets Holidays, Food and Bills.

A bank account and a brokerage account are the same concept: both are just “where assets are held”. There is no separate “broker” type. One holder can hold EUR cash and AAPL shares at the same time (a brokerage account with uninvested cash is the normal case), and a budget can hold a mix too (a “Savings” budget that is part cash, part ETF).

The holders and the budgets are two different slicings of the same pile of value:

flowchart TB
    subgraph H["Holders: where it is"]
        BA["Bank A<br/>1,200 EUR"]
        BR["Broker X<br/>300 EUR + 10 AAPL"]
    end
    subgraph B["Budgets: what it is for"]
        direction TB
        INC["Income"]
        HOU["Housing<br/>800 EUR"]
        SAV["Savings<br/>400 EUR"]
        INV["Investments<br/>300 EUR + 10 AAPL"]
        INC --> HOU
        INC --> SAV
        INC --> INV
    end
    H <==>|"same total, per asset"| B

Both sides always add up to the same:

\sum \text{holder balances} = \sum \text{budget balances}

This equality is enforced by the transaction data model, and doesn’t need to be reconciled.

Any change in containers content is represented by a transaction

Defintion

Every change (money out/in, trades, transfers) is a transaction. Value entering or leaving the tracked world (a salary arriving, a coffee bought) goes through two reserved sentinel containers, externalHolder and externalBudget, which are never shown in the UI.

KindWhat happensHolder sideBudget side
incomeMoney inexternal → Bank Aexternal → “Income”
expenseMoney outBank A → external“Spendings” → external
holderTransferMove between accountsBank A → Bank Bnone
budgetTransferReallocate between budgetsnone“Income” → “Housing”
tradeSwap one asset for anotherBroker X: EUR → AAPL“Investments”: EUR → AAPL

Rules that make the invariant hold

Transaction date

Transactions have 2 date fields:

FieldMeaning
effectiveDateThe calendar day the movement actually clears the account. All balances are computed from this.
postedAtThe instant it was recorded. Kept as real data (bank-statement times on import), never overwritten to encode ordering.

effectiveDate is a pure calendar day (YYYY-MM-DD, no time, no zone), so “March 1” is the same March 1 on every device. Mixing it up with an instant was a real bug source: a transaction entered at UTC+2 could land on the previous day on a UTC−5 device.

Recurring transactions

A recurring transaction template is a dateless pattern (a rule such as “every 3 months from Jan 31”) that can produce real transactions or be projected forward.

The concept of recurring transaction together with the possibility to create transactions in the future lets the end user plan their accounting months or even years in advance, making sure all banks and budgets always have enough money.

Balance, value and price

A container’s balance of an asset at a given time is everything that came in, minus everything that went out. Its value converts those balances into one display asset by multiplying each by that asset’s price and adding them up.

\mathrm{balance}(c, a, T) = \sum_{q \in \mathrm{in}(c, a, T)} q \;-\; \sum_{q \in \mathrm{out}(c, a, T)} q
\mathrm{value}(c, T, d) = \sum_{a} \mathrm{balance}(c, a, T) \cdot \mathrm{price}(a, T, d)

where c is a container, a an asset, T a point in time and d the display asset. \mathrm{in}(c, a, T) is the set of quantities of a moved into c by transactions up to T, and \mathrm{out}(c, a, T) the same for quantities moved out of c.

A price snapshot says “asset X was worth Y (in asset Z) on date D”. It comes either from an on-device fetch against a public API (AlphaVantage today) or from manual entry, which is a first-class path, not a fallback, because some assets will never have public price data. Fetching is manual and per-asset for 2 reasons: the AlphaVantage free tier allows only 25 requests a day, and since moopro was designed to be a privacy-friendly app, it should never perform API requests without the end user being aware of it.

Because this lets you split a change in investment value into two causes, Moopro can answer “why did my portfolio change?”:

flowchart LR
    D["Change in value<br/>between two dates"] --> Q["Quantity-driven<br/>you bought or sold"]
    D --> P["Price-driven<br/>the market moved"]

Data model

Entities

Here is a sumary of the data classes moopro relies on:

erDiagram
    ASSET {
        u64 id
        enum kind "fiat stock etf crypto realEstateBond other"
        string symbol
        string name
        string alphaVantageSymbol "nullable"
        string displaySymbol "nullable"
    }
    CONTAINER {
        u64 id
        string name
        enum containerType "holder or budget"
        u64 parentId "budgets nest"
        string icon "nullable"
    }
    TRANSACTION {
        u64 id
        datetime postedAt
        date effectiveDate
        enum kind "income expense holderTransfer budgetTransfer trade"
        string note
        int manualOrderRank
    }
    LEG {
        u64 containerId
        u64 assetId
        decimal quantity
        decimal balanceAfter "cache"
    }
    PRICE_SNAPSHOT {
        u64 assetId
        date date
        decimal price
        u64 currencyAssetId
        enum source "fetched or manual"
    }
    RECURRING_TEMPLATE {
        u64 id
        enum kind
        RecurrenceRule rule
        date lastGeneratedOccurrenceDate
        bool active
    }
    SETTING {
        u64 id "fixed per key"
        string value
    }

    CONTAINER ||--o{ CONTAINER : "parent of (budgets)"
    TRANSACTION ||--|{ LEG : "has 2 or 4"
    LEG }o--|| CONTAINER : "moves in or out of"
    LEG }o--|| ASSET : "of"
    PRICE_SNAPSHOT }o--|| ASSET : "prices"
    RECURRING_TEMPLATE ||--o{ TRANSACTION : "may generate"

Notable details:

The unit of storage is the record

Every entity above is serialized to JSON and encrypted independently, as one vault record, with one of these routing tags: asset, container, transaction, price_snapshot, setting, recurring_transaction_template.

One transaction is one record. That keeps conflicts small (see Sync and conflicts): a rejected push loses at most one entity.

Fast balance computation without replaying full history

Recomputing everything from first transaction on each edit does not scale, so the device keeps derived caches. None of them are authoritative; all are rebuildable from the transaction log.

flowchart LR
    Log[("Transaction log<br/>(synced, encrypted)")]
    CP["Monthly balance checkpoints<br/>(local only)"]
    BA["Per-transaction balanceAfter<br/>(travels inside the record)"]
    PS["Price snapshots"]
    SS["Step series<br/>(in memory)"]
    Chart["Charts / net worth / forecast"]

    Log -->|"replay"| CP
    Log -->|"replay"| BA
    BA --> SS
    PS --> SS
    SS -->|"binary search<br/>at any date"| Chart

End-to-end encryption

Threat model

The server operator, a compromised backend process, and a stolen database file must not be able to read financial data and must not be able to forge transactions. The server is trusted only to authenticate users, store opaque bytes, and route and version records correctly. It is not trusted with plaintext, names, amounts, tickers or record contents.

What E2EE does not cover: a compromised or unlocked device, a weak master password, a user who reuses it as the account password, and a malicious server replaying old data (see Security properties and limits for tradeoff information).

The key hierarchy

Two keys, deliberately separate:

flowchart TB
    PW["Master password<br/>(never leaves the device)"]
    SALT["kdf_salt + kdf_params<br/>(not secret)"]
    KEK["KEK<br/>256-bit"]
    WRAP["wrapped_dek<br/>AES-256-GCM(KEK, DEK)"]
    DEK["DEK<br/>random 256-bit"]
    R1["Record 1 ciphertext"]
    R2["Record 2 ciphertext"]
    RN["Record N ciphertext"]

    PW -->|Argon2id| KEK
    SALT -->|Argon2id| KEK
    KEK -->|wraps| WRAP
    DEK -->|"is wrapped into"| WRAP
    DEK -->|"AES-256-GCM, per record"| R1
    DEK --> R2
    DEK --> RN

Argon2id defaults are memory-hard: 64 MiB, 3 iterations, 4 lanes. The exact parameters are stored per user so they can be strengthened later without breaking existing accounts.

Why two layers instead of encrypting records straight from the password? Changing the password becomes cheap and safe. You derive a new KEK, re-wrap the same DEK, and upload the new wrapped key. No record is re-encrypted.

Record encryption

TEXT
nonce      = random 96 bits, fresh for every encryption
ciphertext = AES-256-GCM(key = DEK, nonce, plaintext = JSON, aad = "<recordId> <type>")

AES-GCM is authenticated: tampering is detected, not silently decrypted to garbage. The additional authenticated data binds each ciphertext to its record id and type tag, so the server cannot swap ciphertext between records or relabel a record’s type without the client noticing (wrapping the DEK also uses GCM, avoiding the unauthenticated-mode key wrapping)

What the server can and cannot see

flowchart LR
    subgraph Visible["Visible to the server"]
        v1["random 64-bit record id"]
        v2["type tag (~10 coarse values)"]
        v3["version number + updated_at"]
        v4["deleted flag"]
        v5["ciphertext size & timing"]
        v6["wrapped_dek, kdf_salt, kdf_params"]
    end
    subgraph Hidden["Inside the ciphertext (hidden)"]
        h1["amounts and quantities"]
        h2["dates"]
        h3["names, notes, tags"]
        h4["tickers and asset kinds"]
        h5["which container a leg touches"]
        h6["settings incl. API keys"]
    end

The type tag tells the server “this is one of about ten known record shapes”, nothing about content. It is needed so a client can fetch or replace caches by type without decrypting everything first. Record counts, sizes and activity timing are inherently visible, hiding them (padding, dummy traffic) is out of scope.

Life of a write

sequenceDiagram
    participant U as You
    participant D as Device (DEK in memory)
    participant L as Local ciphertext store
    participant S as Server

    U->>D: Add transaction
    D->>D: Validate, update plaintext cache and balances
    D->>D: Serialize to JSON, encrypt with DEK (fresh nonce, AAD = id and type)
    D->>L: Save ciphertext, mark dirty
    D->>S: Push (id, type, ciphertext, nonce, baseVersion)
    alt baseVersion matches
        S-->>D: Accepted, new version assigned
        D->>L: Mark clean
    else stale baseVersion
        S-->>D: 409 conflict, nothing applied
        D->>L: Flag record as conflicted (visible in UI)
        D->>S: Pull latest, reconcile
    end

What a record looks like on the wire

Every push and pull moves the same small envelope. The server stores it without ever looking inside the encrypted part.

FieldWho can read itMeaning
idServer16-character hex id, chosen by the client
typeServerCoarse routing tag (transaction, container, …)
ciphertextNobody but youThe encrypted JSON, with its 16-byte authentication tag appended to the end as one blob
nonceServer (not secret)The 96-bit value used for this encryption, sent separately
baseVersionServerThe version the client last saw for this id, or empty for a record it believes was never synced
version, updated_atServerAssigned by the server on write, returned to clients
deletedServerSoft-delete flag; a deletion is an ordinary update with a placeholder payload

How the pieces behave:

Sync and conflicts

Each record carries a server-assigned monotonic version. A device remembers the highest version it has pulled and asks for everything newer. A cheap “latest version” probe is polled to learn whether a real pull is worth doing. Deletes are soft (tombstones that sync like any record).

The server is the single source of truth, and a stale push is rejected, never silently overwritten. Every upsert states the baseVersion the client last saw. If any item in a batch is out of date, the whole batch is rejected with HTTP 409 and nothing is applied. The client must pull and reconcile.

This is intentionally not a CRDT or automatic merge: a 409 means “ask the user”, never “the server merged both edits”. That is acceptable because:

On the client, a conflict is made visible: abandoning a push after a 409 sets a local conflictedAt flag that survives the immediate re-pull, because in a finance app the user must be able to tell “saved on the server” from “silently discarded”.

Statement import

Statement import parses bank/broker PDFs, CSVs and spreadsheets entirely on the device with per-institution heuristics (no LLM in the parsing path). Parsed rows become staged candidates in memory; the user reviews and assign holders, budgets and assets, and nothing is committed until user accepts.

Automated unlock, offline vaults, multiple vaults

Automated unlock is opt-in. By default the DEK exists only in memory, so each session needs the master password. If you tick “Save master key on this device”, the DEK goes into the OS secure store (Keychain, Keystore, libsecret) and, on platforms that support it, is gated by a biometric or device PIN. The opt-in is per vault, revocable in Settings, and never done silently. On Linux and web there is no real interactive gate, so the app says so plainly instead of implying a prompt that never appears.

Offline-only vaults use no server at all. The same four values the server would normally hold (kdf_salt, kdf_params, wrapped_dek, wrap_nonce) are stored on the device. That is no weaker than before: wrapped_dek is itself ciphertext, and the salt and params are not secret by design, so an attacker with the disk still needs the master password.

An offline vault can later be attached to a new server account. It is the same operation as a password change: re-wrap the already-unlocked DEK under the account’s password, upload it, push every local record, then delete the local key material. Attaching to an account that already has a vault is refused rather than trying to reconcile two independently encrypted vaults.

Several vaults can coexist on one device. This is useful for, say, a personal online account, a household one, and a private offline scratch vault. Each vault is a sealed compartment:

flowchart TB
    REG[("Vault registry (unencrypted)<br/>id, label, online/offline, email")]
    subgraph V1["Vault A: online account"]
        A1[("Own database<br/>ciphertext only")]
        A2["Own cached key<br/>(only if opted in)"]
    end
    subgraph V2["Vault B: online account"]
        B1[("Own database")]
        B2["Own cached key"]
    end
    subgraph V3["Vault C: offline only"]
        C1[("Own database")]
        C2[("Own key material<br/>wrapped_dek, salt, params")]
        C3["Own cached key"]
    end
    REG --- V1
    REG --- V2
    REG --- V3

Backup

The problem it solves

If the server is lost entirely, your data is gone: the local copy is ciphertext, and for an online account the key material (salt, wrapped key) lives only on the server. Copying the local ciphertext would therefore be useless. A real backup has to stand on its own.

How it works

While the vault is unlocked, the app takes the decrypted data and re-encrypts it under a scheme that depends on nothing server-issued:

flowchart LR
    V["Unlocked vault<br/>(decrypted data in memory)"] --> P["One JSON document<br/>schema version, export time,<br/>list of entities"]
    P -->|"OpenPGP symmetric encryption<br/>key from the master password"| F["ASCII-armored .asc file"]
    F --> G["Decryptable with plain gpg,<br/>no Moopro required"]
    F -->|"restore"| E["Empty vault"]

Format

It’s using ordinary password-only OpenPGP, so gpg --decrypt opens it even if Moopro no longer exists. I chose that over inventing a custom format so your backup outlives the app.

Contents

Every asset, container, transaction, price snapshot and similar entity, each with its original id and its normal serialized form. The two reserved sentinel containers are left out, since they are recreated on every unlock and are not user data.

Password

The master password as it was when backup was produced. If the master password is changed later, old backups still need the old one. A separate backup-only passphrase is a possible future feature

Restore

Since backups contain the full data, restoring is expected against an empty vault. If the vault already has real data, the restore is refused and nothing changes. This follows the project’s rule: ask the user to reconcile, never silently merge. Merging into a non-empty vault is a possible future feature.

Order and ids are preserved

Entities are written assets and containers first, then the transactions and prices that reference them, each with its original id, so every cross-reference resolves.

The master password

What it is and what it protects

The master password is the only secret that can unlock your data. It is fed to Argon2id to produce the KEK, which unwraps the DEK, which decrypts the records. It is never sent anywhere and never stored.

flowchart LR
    A["Master password"] -->|"Argon2id + salt"| B["KEK"]
    B -->|"AES-GCM unwrap"| C["DEK in memory"]
    C -->|"AES-GCM decrypt"| D["Records, rebuilt into<br/>in-memory plaintext cache"]
    B -.->|"wrong password: auth tag fails,<br/>nothing is decrypted"| X(["Rejected"])

A wrong password is detected cleanly: the unwrap’s authentication tag fails, so there is no “garbage data” state.

If you forget it, the data is gone

There is no reset, no server-side escrow, no backdoor. That follows directly from zero knowledge: the server cannot help because it has nothing that can decrypt. This is the price of the guarantee, and also why some end to end encrypted products like MEGA lets users download a recovery key (a second wrapping of the DEK under a random key shown once at setup).

Strength matters more than usual

Anyone who obtains the stored wrapped_dek and salt, for example from a database leak, can try passwords offline, with no rate limit. Argon2id’s memory-hard cost slows each guess, but a weak password is still the weakest link in the system

Master password vs. account password

For an online vault there are two secrets that are independent at the protocol level: account password is only used to authenticate a user, and master password is only used to decrypt the data, similarly to some end to end encrypted products like Proton for example.

Maximum security holds fully only when the master password is different from the account password. Offline-only vaults have no account password at all, so this concern does not apply to them.

Changing the password

Thanks to the DEK/KEK split, a change derives a new KEK, re-wraps the same DEK and uploads the new wrapped key. No record is touched. Existing backups keep needing the password they were exported with.

Where data lives on a device

The device is trusted more than the server, but an audit showed the on-device database was once readable in plaintext with the sqlite3 CLI. So plaintext is now held only in memory:

flowchart TB
    subgraph Disk["On disk (persistent)"]
        direction TB
        LV[("LocalVaultRecords<br/>ciphertext + nonce")]
        SS[("Sync cursor, version high-water marks")]
        KM[("Key material for offline vaults<br/>(wrapped_dek, salt, params)")]
        REG[("Vault registry<br/>(unencrypted labels only)")]
        SEC[("OS secure storage<br/>DEK only if you opted in")]
    end
    subgraph Mem["In memory only (gone on lock or exit)"]
        direction TB
        DEKm["DEK"]
        DC[("Decrypted domain cache<br/>assets, containers, transactions,<br/>prices, checkpoints")]
    end
    LV -->|"decrypt on unlock"| DC
    DEKm --> DC

Security properties and limits

What you get

Known limits, stated plainly

LimitImpactStatus
Login password is sent to the serverIf reused as master password, the server can decryptIn my todo list: single-password HKDF/OPAQUE design
Weak master passwordOffline brute force of a leaked wrapped_dekOnly non-empty is enforced today
No recovery pathForgotten master password means permanent data lossRecovery key planned in my todo list
Rollback is not cryptographically enforcedThe AAD binds id and type but not the version (the client encrypts before the server assigns it), so a malicious server could replay an older valid ciphertext of a recordPartly mitigated by the client’s per-record high-water mark, which flags a lower version for a record already seen
Dropped records / fresh-device rollbackA server that omits records, or serves stale data to a device with no history, is not detectedAn encrypted manifest of record heads is planned in my todo list
No auto-lockAn unlocked, unattended device exposes everythingPlanned
Metadata leaksRecord counts, sizes and timing are visibleAccepted
Local unlock on Linux/webThe cached key has no biometric or PIN gate thereAccepted; UI says so
Compromised or unlocked deviceOut of scope for E2EEInherent

The server can still refuse service, delete data or withhold records; E2EE protects confidentiality and detects tampering, not availability. That is one of the reasons the offline backup exists.

Comparison with MEGA

MEGA is the best-known consumer product with a similar promise (user-controlled keys, the provider cannot read your files), and it publishes a security whitepaper that openly lists its own weaknesses. I used it as inspiration to build moopro and to learn about end to end encryption. The points below are the ones recorded in my design; for MEGA’s side, the whitepaper is the authority.

TopicMEGAMoopro
Core promiseProvider cannot read user dataSame
Key wrappingOriginally used unauthenticated AES-ECB, which enabled an “RSA oracle” attack (decrypt-on-repeated-login), patched in June 2022AES-256-GCM from the start for both the data key and records, so tampering is detected and that class of attack is not possible
One password or twoDerives separate keys from one password, so the login secret and the encryption key are different valuesTwo independent passwords today (account and master). Safe if they differ, but if reused the server can decrypt
Rollback / freshnessAdmitted as a theoretical limitation: a malicious server can replay old dataSame structural limit. The authenticated data binds id and type but not the version, since the client encrypts before the server assigns one. Partly mitigated by a client-side per-record high-water mark
Stated openlyWhitepaper has a “theoretical vulnerabilities” sectionLimits are written above

What I took from the comparison:

Differences in scope matter as well: MEGA is a file-sharing product with cross-user sharing, while Moopro is a single-person (or household) vault with no sharing between accounts, which removes a whole class of key-exchange problems.

Tradeoffs I made

Each of these was a deliberate choice; none is an oversight.

DecisionWhat I gainWhat I give up
Zero-knowledge E2EEA database leak or hostile operator exposes no financial dataNo password reset, no server-side search or analytics, no server-side features that need plaintext
All computation on the deviceThe server stays a dumb blob store; no key exposureEvery client recomputes balances and charts itself; heavier first load; derived caches are needed to stay fast
Per-record encryption (not one big blob)Small conflicts, cheap incremental sync, one lost edit never loses a batchServer sees record count, size and timing; many small ciphertexts
DEK wrapped by a password-derived KEKPassword change re-wraps one key instead of re-encrypting everythingThe DEK is permanent for the account’s life; rotating it would mean re-encrypting all records
Argon2id with memory-hard paramsStrong resistance to offline guessingSlower unlock, especially on weak devices; params must be tuned and eventually upgraded
Reject stale pushes (409), no auto-mergeServer stays the single source of truth; no silent data loss; far simpler than CRDTsA conflicting edit needs a human decision; fine for one person or household, awkward for heavy concurrent editing
Decrypted data only in memoryDisk theft yields only ciphertextWhole cache rebuilt on every unlock; slower cold start
Opt-in key cachingConvenience without a silent security downgradeMore friction by default; on Linux and web the cached key has no interactive gate
Server may cache, but only as ciphertextAllows precomputed chart data later without breaking zero knowledgeNot built yet; every device currently recomputes locally
Price fetches on-device, manual by defaultBackend never learns your holdingsSubject to public API limits (25/day on the free tier), so no refresh-everything button; manual entry is first class
OCR / parsing on-deviceStatements never leave unencryptedParsers are hand-written per institution and grow one at a time
Holders and budgets are two hierarchies over one pile of valueReal accounts and planning stay separate yet provably consistent (Σ holders = Σ budgets)More rigid: every income, expense and trade needs both a holder and a budget leg; no direct holder-to-budget transfer
A single generic multi-asset containerOne concept for bank, broker and wallet; investments need no schema changeA holder can hold many assets, so “balance” is always per asset and valuation needs prices
trade takes exactly one budgetKeeps the invariant simpleIt does not model which budget truly funded a split purchase
Missing price means “unknown”, not a guessNumbers are never fabricatedTotals can be incomplete until a price is entered
Recurring items require confirmation; trades excludedNever invents transactions or price historySlightly more manual than a fully automatic scheduler
Backup encrypted with the master password, as OpenPGPAnyone with gpg can recover without Moopro; no new crypto formatOld backups need the old password after a change; no separate backup passphrase yet; restore only into an empty vault
Offline-only vault optionUsable with no server, ever; attachable laterAttach works only against a brand-new account; no merging two vaults
One online account = one vaultMatches the server’s single wrapped-key rowNo multiple independent vaults per account
Soft deletes (tombstones)Deletions sync like any other changeDeleted records leave a (tiny) trace server-side
Self-hosted, single-user assumptionsSimpler concurrency and attach logic (a narrow race on key-material upload is accepted)Not designed for large teams or hostile co-tenants
Prefer built-in widgets and well-known packagesDismiss gestures, focus, accessibility for free; consistent lookLess freedom than hand-rolled UI