Self-hosted instead of bought in
Error tracking runs on a self-hosted GlitchTip instance on our own Scaleway infrastructure, so crash reports never leave our servers. And they don't contain you: before a report goes out, user identity, IP, cookies, headers, authorization tokens, request body and query string are stripped. The body is the part that matters, because note content and search queries would otherwise sit in it. Performance tracing is off by default. This website's visitor stats are cookieless (Plausible, EU), and the app itself has none at all.
Keys that can do one thing only
Access keys follow the principle of least privilege: every system gets only the permissions it actually needs. Example: this website's automated deploy holds no account-wide CDN key, just a token that can do exactly one thing: purge this site's cache. The central keys themselves live in Scaleway's Secret Manager, not in external build systems.
The separation lives in the database, not in the code
In most services, application code is what keeps you from seeing someone else's data. One forgotten "where user = …" in a single query is then enough for a leak. In Memexa the separation sits a layer lower: PostgreSQL enforces it through row-level security. With no user context set, the database returns no rows: not the wrong ones, none at all. The context is set per transaction and falls away when it ends, so it can't carry over to the next connection out of the pool. To keep it that way, a check runs with the test suite that fires as soon as a new table arrives without row-level security or an explicit classification: the build fails instead of quietly passing.
What your AI may do is your call, and you can take it back
Claude, ChatGPT and Cursor don't get a master key. Access runs through OAuth: before you approve, you see which AI app is asking and where the access goes, and you confirm it yourself. The browser clipper and full AI access hold separate permissions: the clipper may file things, not search your store. You can disconnect AI apps any time in Memexa; an AI app can also hand its access back on its own. And access control doesn't hang on one central gate: every endpoint checks the session itself, so a mistake in one place doesn't open everything.
Deletion means deletion: in this order
You can delete your account yourself, confirmed by email. What happens then is deliberately the other way round: first every file in object storage is removed, across the complete user prefix, so orphaned files that no longer belong to any entry go too. Only then do the database rows fall. If the file deletion fails, the whole run aborts and your account stays, rather than leaving you with the records gone and the documents still sitting there. The run is safe to repeat. Individual items you can delete any time without touching the account.
The wires in between
Every leg is encrypted: TLS 1.2 and up at the edge, older versions switched off; database connections check certificate and hostname too, so they are not just “encrypted somehow”. The database sits on a private network with no public address. In front of it are a WAF and DDoS protection, and the origin server only accepts requests from the CDN's network, so you can't reach it directly. The application container runs without root, dependencies build from a pinned lockfile, and the one external binary we need is pinned to a version and a checksum.