Platform
What we buildHelp centreSecurityComplianceReliabilityScalabilityEfficiency Platform overviewSolutions
Startup foundersEstablished businessesOperations teamsIntegrations
Payments, billing & taxAccounting & ERPIdentity, access & auditEmail deliverySMS & voiceElectronic signature All integrationsCompare
All comparisonsSecure
Security is not a phase near the end of the project. It is the shape of the thing from the first line, because retrofitting it costs more than building it right.
The defaults are the secure ones. There is no hardening step you have to remember to ask for.
Almost every breach you read about is the same story: something sensible was skipped because it was not urgent yet. A default password left in place, a storage bucket left public, a dependency left unpatched for two years, a log file quietly recording credit card numbers. None of these are hard problems. They are problems of attention, and attention is exactly what a founder building their first product does not have to spare.
TLS on every connection with modern ciphers and HSTS, and encryption at rest for databases, backups and uploaded files. There is no internal network where traffic travels in the clear because it is "behind the firewall".
Passwords are hashed with a modern algorithm and a per-user salt — never encrypted, never recoverable, never logged. Where you use Google or Microsoft sign-on, we never hold a password at all.
Time-based codes and, where the browser supports it, passkeys. Enforceable per role, so administrators can be held to a higher bar than ordinary users.
Sessions time out, rotate on privilege change, and can be terminated centrally. When someone leaves your company, their access ends when you say it ends, not when their cookie happens to expire.
Parameterised queries, output encoding, strict content-security policy, and file uploads checked by content rather than by filename. The standard injection and cross-site scripting classes are closed structurally rather than caught by review.
Login attempts, password resets, API calls and anything expensive are rate limited per account and per address, so a script cannot brute-force an account or run up your bill overnight.
Most incidents are not clever attacks. They are credentials that were left somewhere convenient.
API keys, database passwords and tokens are stored in a managed secret store, injected at runtime, and rotated. Nothing sensitive is committed to a repository, pasted into a configuration file, or emailed to anyone.
Every component gets the narrowest permissions that let it do its job, and that includes our own engineers. Access to your production data is scoped, justified and logged rather than ambient.
Sign-ins, permission changes, exports and administrative actions are recorded with who, what and when — in a form a non-technical person can review, not just a log file.
Your application, your data store and your credentials are separated from every other customer we run. A problem in someone else's application is not a problem in yours.
Software does not decay, but the world around it does. Yesterday's safe dependency is tomorrow's advisory.
Every library your application depends on is monitored against published vulnerabilities. Security patches are applied on a schedule, and critical ones out of band, without waiting for you to ask.
Nothing reaches production without review and an automated check suite. The path from a change to your live application is the same every time, which is what makes it safe.
If something does go wrong, there is a defined path: contain, assess, notify you, fix, and tell you afterwards what happened and what changed. You are told, in plain language, rather than managed.
Third-party penetration testing, with the report available to you and to your customers' security teams.
Roadmap · next
The specifics
What you can tell a security reviewer without having to ask us first.
| Item | What you get |
|---|---|
| Transport | TLS 1.2+ enforced, HSTS, modern cipher suites only |
| At rest | AES-256 for databases, object storage and backups |
| Passwords | Hashed with a memory-hard algorithm, per-user salt, never reversible |
| MFA | TOTP and passkeys, enforceable per role |
| Secrets | Managed secret store, injected at runtime, rotated; never in source control |
| Access control | Role-based, least privilege, applied to our engineers as well as your users |
| Audit logging | Authentication, permission changes, exports and admin actions |
| Dependencies | Continuously scanned; security patches applied on schedule |
| Isolation | Per-customer separation of application, data and credentials |
| Incident response | Documented process with defined notification to you |
| Penetration testing | Third-party, report shareable — on the roadmap |
Yes. That is a normal part of the work rather than an escalation, and it is the reason the answers above are written down rather than assembled on request. See Compliance for what the evidence trail looks like.
Access is scoped to the engineers working on your application, is granted for a reason, and is logged. It is not ambient access that everyone happens to have because it was easier to set up that way.
We contain it, assess what was affected, and tell you — with facts, in plain language, and within a defined window rather than when the story is comfortable. Afterwards you get an account of what happened and what changed so it does not happen again.
Yes, with scheduling so we do not mistake your test for an actual attack and start responding to it.
Start here
A 30-minute call is enough for us to tell you whether we can build it, what it will cost to run, and when it goes live.
We use analytics cookies to understand which pages are worth keeping. They are off until you say otherwise, and you can change your mind at any time from the footer. Read the privacy policy.
