Product
Home How it works What it handles The console PricingResources
Security, in plain English Docs QuestionsSecurity
Everything on this page is live in production right now. No roadmap items, no aspirational claims. One honest note on scope: we publish our security guarantees — what you're protected from — but not the mechanics of how each protection works. Publishing the internals would hand attackers a map. Where a detail is missing, that's why — and security researchers can always reach us at abuse@gemmein.com.
Other platforms sell the safe version back to you as an enterprise tier. Gemmein can't do that, because safety is the product. Every one of these guarantees holds for every app, including free ones — already handled for you, nothing to configure.
Every request to your app passes through multiple independent layers of defence before it ever reaches your data. Abuse, floods, and known attack traffic are absorbed and filtered before they can touch anything of yours.
One app can never see another app's users or data, and a production environment can never leak into a development one. This is enforced by the platform itself — not by app code that could have a bug in it.
The systems that hold your data are not reachable from the internet at all. The only way in is through the protected front door. There is nothing exposed for an attacker to find.
Your users sign in with a one-time email code. There is no password database to breach, no password reset flow to abuse, and no stolen-password list that can be replayed against your app.
Data is encrypted on its way to us and encrypted where it's stored. There is no unencrypted path and no unencrypted copy.
Sign-in abuse, scraping, and traffic spikes are throttled automatically. The limits are deliberately tight and deliberately unpublished — attackers tune their behaviour to stay under numbers they know.
Hosting, scaling, patching, and backups are handled by the platform. You never provision, update, or babysit a server, and routine protection never depends on you remembering to do something.
Users sign in with a short-lived email code. That's the whole model — and it removes an entire category of breach before it can happen.
Sign-in codes are unguessable and expire quickly. Even we never keep a usable copy, so there is nothing on our side worth stealing.
Sessions expire on their own, end immediately on logout, and can't be carried from one app to another. A session for one app is worthless everywhere else.
Tenant isolation is the single most important property of a multi-tenant backend, so Gemmein enforces it more than once, in more than one place.
Every piece of data belongs to exactly one app and one environment, and the platform refuses to cross that line — independently, at more than one layer. Even a hypothetical bug in one layer can't expose another tenant's data.
In private collections, each user sees only what belongs to them. Identity is decided by the server — a browser cannot claim to be someone else.
Uploaded files are checked, size-limited, and served in a way that means uploaded content can never run as code — anywhere.
All payment processing is handled end to end by a dedicated payment provider. Card numbers are never transmitted, processed, or stored on our infrastructure.
Deleting a record, a collection, or an app comes with a grace period, so no structural mistake is one keystroke from permanent. Nothing important can be dropped by accident — even by us.
When a user asks to be deleted, they are deleted. Account deletion is a hard delete, as it should be — the details are in our privacy policy.
Every meaningful action — sign-ins, data changes, management changes, including the ones that were refused — is recorded.
The trail can't be quietly erased
Logs never contain secrets, credentials, or your users' message contents, and the trail is kept in more than one place, independently — so no single compromise can erase the evidence. The platform is watched around the clock by automated monitoring that pages real humans, not a dashboard nobody reads.
Gemmein's controls are aligned with OWASP, NIST, and ISO 27001 guidance. That is alignment, not certification — we have not been audited for certification, and we say so plainly.
The platform went through a full security review before launch. Every finding was fixed and re-verified, and the review never stopped: security claims are continuously re-checked against the actual code, and automated security tests guard against regressions on every change.
We say “aligned”, never “certified”. We say “security-reviewed”, never “independently audited”. If a claim on this page ever stops being true, it comes off the page.
If you've found a security vulnerability or have a concern about how Gemmein handles data, we want to hear about it. We take every report seriously and will respond promptly.
abuse@gemmein.comFor privacy-related questions: privacy@gemmein.com