Security
Security by design, at every layer.
The controls in the product your team uses, in the way we build and change it, and in the cloud it runs on.
Overview
How we secure Productmind
Productmind holds your product knowledge, your customers' feedback and access to your code. We protect it in three layers, and this page lists the controls in each, then where our part ends and yours begins.
- Hosting
- Amazon Web Services, in Frankfurt (eu-central-1)
- Data separation
- A database schema per workspace from the Start plan; a dedicated database on Enterprise
- Encryption
- HTTPS with HSTS in transit; AES-256 at rest
- Sign-in
- Single sign-on with SAML 2.0, Google Workspace or Entra ID; multi-factor on every plan
- Audit log
- Changes recorded field by field on every plan, kept 2 years by default
- Coding agents
- One runner per cloud session; plans and merges stay with people
- Breach notification
- Within 48 hours of our becoming aware of it
- Certification
- Working towards ISO/IEC 27001
- Agreements
- Data Processing Agreement with SCCs, subprocessor list, DORA addendum
Fail closed
When a control can't reach a decision, it refuses. Each role's permissions are an explicit list, so a new capability is granted to nobody until someone decides who gets it, and our infrastructure deploys stop when they can't tell exactly what they would change.
Least privilege
People get the access their role and teams grant. A tool you connect acts as you and no more. A coding runner gets credentials scoped to its one session, and fetches your secrets only when it needs them.
People decide
Agents read, plan and propose. A person approves the plan before code is written, reviews the pull request, and merges it.
Evidence over assertion
Each security statement we publish maps to the code, configuration or agreement that proves it, and the gaps we find are recorded and tracked until they're closed. A statement we can't prove isn't published.
01Productmind software
Security and governance in the product
The controls your team works with: who can sign in, what each person and tool may do, how your workspaces are kept apart, what the agents may touch, and the record of who did what.
1.1Identity and authentication
Members sign in with a password, with Google, or through your company's single sign-on, and you can require a second factor of everyone.
- Single sign-onStart and up
- Members sign in through Google Workspace, Microsoft Entra ID or any SAML 2.0 provider, such as Okta or OneLogin. Require it, and password and Google sign-in stop; the owner always keeps a way in, so the organization can't lock itself out.
- Accounts from your identity providerStart and up
- New people from your identity provider can join with the role and workspaces you choose. Each email domain belongs to one organization, and public email providers can't be claimed.
- Multi-factor authenticationEvery plan
- A 6-digit code from an authenticator app, with 10 single-use recovery codes. Require it of every member, the owner included; members without one are signed out until they set it up.
- Lockout on wrong codes
- Five wrong codes end a sign-in attempt. Ten wrong codes in 15 minutes, or 30 in a day, pause signing in to that account.
- Passwords
- Stored only as a salted bcrypt hash. Changing your password signs you out everywhere else, and a reset signs you out everywhere.
- Sessions you can see and end
- Connected clients lists every browser and app signed in as you, how it signed in and when it expires. Revoking one takes effect within 30 seconds.
Identity & Access
Multi-factor authentication
Require everyone to confirm a code from an authenticator app after their password, and see who has already set one up.
2 members have not set one up yet.
Enforcement
Require multi-factor authentication
Every member has to confirm a code from an authenticator app after their password. Members without one are walked through setup on their next sign-in and cannot use the app until they finish.
Require multi-factor authentication?
2 of 12 members have not set up an authenticator yet. They will be signed out immediately and asked to enrol before they can use the app again. Members who already have one stay signed in.
1.2Access control
Each member has one role in your organization and access to the workspaces you choose. The API enforces what each role may do, and the app hides what it may not.
- Built-in roles
- Seven roles, from Owner and Admin to the read-only Viewer, each with Create, Read, Update and Delete permissions on every kind of record.
- Enforced by the API
- Permissions are checked by the API, not only hidden in the app. The app's own permission table is generated from the API's routes and tested against them in both directions.
- Teams
- A team's role only adds permissions to what its members already have, and Owner is never a team role.
- Private features
- Limit a feature to the teams on its access list, who can view or edit it. Who sees a feature changes in the Productmind app only: the AI and the tools that call the API can't change it.
- Workspace admins
- A workspace admin manages that one workspace and gets no other permission from it.
- Leavers
- Disabling a member stops their sign-in, removes them from every workspace and team, and stops the tools they connected.
1.3Tenant isolation
Every workspace belongs to one organization, and its requests name it in their path. How its data is kept apart from other customers' data depends on your plan.
- A schema per workspaceStart and Scale
- Each workspace has a database schema of its own, and its queries run inside it.
- A dedicated databaseEnterprise
- Your organization's workspaces run on a database of their own.
- A shared schemaEarly
- Workspaces share one schema and are separated in every query.
- Single sign-on stays in its organization
- A session signed in through your single sign-on opens only your organization, never another one its member belongs to.
- One runner per session
- Each cloud coding session runs on a runner that serves only that session, never another session or another organization.
1.4API and tool access
AI assistants, the Productmind CLI and your own tools reach Productmind through OAuth, as the person who connected them.
- OAuth 2.1 with PKCE
- Every tool signs in with OAuth 2.1 and PKCE. There are no API keys and no personal access tokens.
- Only back to you
- A sign-in may return only to your own computer or to a browser extension.
- Short-lived access
- Access lasts an hour. A renewal used again more than a minute after it was exchanged is treated as stolen, and ends that sign-in.
- As you, within your role
- A connected tool acts as you, within your role and teams, and what it does is recorded in the audit log under your name. Its MCP tools need the same permission as the same action in the app.
- Secrets out of reach
- An assistant never sees a secret's value, and changing application and sandbox settings through one is for Owners and Admins.
- Unused connections expire
- A connection nobody uses for 90 days expires.
1.5AI agent governance
Coding agents read, plan and propose. Your team approves the plan, reviews the pull request and merges it.
- A plan before any code
- When the plan is ready, the agent waits for a person to approve it or ask for changes. The agent can't approve its own plan.
- No access to your Git provider
- The agent never pushes or opens a pull request itself, even when asked to: it has no access to your Git provider of its own.
- People merge
- Productmind never merges a pull request on its own. Merging is a person's action.
- Risky files flagged
- Data migrations, API contracts, authentication and security code, and CI and infrastructure files are flagged high risk by default, so a reviewer sees them first. Each application's risk rules are yours to change.
- CI workflow changes wait for a personGitHub
- Your CI workflows run with your repository's secrets, so the agent's change to one waits until someone signed in approves it.
- Read-only repositories
- Mark a repository read-only for an application or for one session, and nothing is committed or pushed to it.
- Who pushes, and who mergesGitLab and Bitbucket
- Choose whether a session's code is pushed by your workspace's Git connection or by the account of the person who started it. When it's theirs, Productmind's Merge is refused to that same person.
- Secrets fetched when needed
- A secret's value is hidden once saved. A runner fetches the secrets it needs when it needs them, and they're never placed on a queue.
- Scans only read
- Repository scans never change your code, commit or open pull requests.
- Your choice of where agents run
- An Owner or Admin can turn off Productmind cloud sessions, so every session runs on your members' own machines. There it uses their own Claude Code or Codex account and none of your AI credits, for a fixed fee per session.
- Which agents run in our cloud
- Cloud sessions run Claude Code, or Codex with your organization's own OpenAI key.
- Your own model keyScale and up
- Connect your organization's own Anthropic, OpenAI or LiteLLM key. Productmind never replaces it silently or falls back to its own AI credits.
Email the reminder as well
3 pull requests3/3
billing-api: Read-only repository.
This repository is read-only in this session, so the agent's changes to it were not committed or pushed, and no pull request was opened on it. They stay in the run's checkout. To publish changes here, allow pushes to the repository (on its chip above, or in its application's settings) and ask the agent again.
- src/reminders/schedule.ts
- src/reminders/channels.ts
invoicing-web: 1 CI workflow file awaiting approval
1.6Audit logging
Productmind records who created, changed and deleted what in your workspace and organization, on every plan.
- Field by field
- Each event records who made the change, when, and each field's value before and after. Secret values show as dots.
- Every caller named
- Each event names its caller: a person, a coding session, a service, a service acting for a person, or a Productmind architect.
- Recorded on every planEvery plan
- Changes are recorded on every plan, whether or not yours includes reading them.
- Search and exportScale and up
- Owners and Admins filter the log by action, caller, record and person, open any event, and export it as CSV or JSON.
- Retention you setScale and up
- Keep events for 90 days, 1 year, 2 years (the default) or indefinitely, per workspace.
- Review stays in Productmind
- A session's review comments stay in Productmind. They aren't posted to your Git provider.
Identity & Access
1.7Support access
Productmind's architects see your work only when your team asks for a review, and only for as long as it takes.
- Only when asked
- An architect opens a session only when your team asks for a review, and sees that one session.
- Time-limited and recorded
- Access lasts 24 to 72 hours. Every grant is listed for your Owners and Admins, who can revoke it.
- What architects never see
- People's email addresses are always hidden, and architects can't see the session's transcript or logs, your lists or your other sessions.
- Merge only if you allow it
- An architect can merge only when the person who asked for the review allowed it.
- Your off switch
- An Owner or Admin can turn support access off. It starts off when your organization requires single sign-on.
- The Help assistant can't look in
- The Help assistant answers from our documentation. It can't look inside your workspace or change anything in it.
1.8Data retention and deletion
Your data is yours to take out, and what's deleted is deleted on a schedule we publish in our Data Processing Agreement.
- Export at any time
- Take your data out through the app, the API or the MCP server.
- Deleting a workspace
- A deleted workspace is no longer accessible. If you deleted one by mistake, Productmind support can restore it within 30 days.
- Deleting your organization
- Its data is erased from production after a 30-day grace period, and from backups within 35 days of that. We confirm the deletion in writing on request.
- Transcripts expire
- Coding session transcripts expire 60 days after they're written.
- Kept only where the law requires
- We keep data after deletion only where the law requires it, such as invoices, and the audit records of destructive changes.
02Productmind operations
How we build, change and run Productmind
We plan and track our own work in Productmind. Our code changes through pull requests on protected branches, automated checks run before every deploy, and our repositories are scanned continuously for vulnerabilities.
2.1Work tracking and traceability
Our work can be traced from the request behind it to the release that shipped it.
- Built with Productmind
- Our work starts as a task, a bug report or a feature in our own Productmind workspace, and the coding session, branch and pull request that deliver it carry its ID.
- Releases as records
- Each release to production is a pull request of its own, with a release record of the work it ships.
- Our agents follow the same rules
- Much of our code is written by coding agents in Productmind sessions, and reaches our repositories the way our customers' work does: as pull requests a person merges.
- Staff actions recorded
- Our own platform administration is in the audit log too: each of its requests is recorded and marked as an administrator's.
2.2Source control and change management
All of our code, including the code that defines our infrastructure, lives in version control and changes through pull requests.
- Private repositories, two-factor sign-in
- Our code lives in private GitHub repositories, and our GitHub organization requires two-factor authentication of every member.
- Protected branches
- Rules on our development and main branches require a pull request with every review conversation resolved, and block force-pushes and deletion.
- Stricter rules for the AWS organization
- A change to our AWS organization's configuration needs a code owner's approving review and passing checks before it can merge.
- Infrastructure as code
- Our cloud infrastructure is defined in code, with Pulumi and CloudFormation, and changes through the same pull requests as the product.
- Two stages
- A merge to development deploys to our pre-production stage, and a release from development to main deploys to production.
2.3Testing and quality assurance
Automated checks run on our pull requests and again before every deploy.
- Checks on every pull request
- Pull requests run type checks, linting, unit tests and, for the API, database tests. Our infrastructure code is linted, type-checked and tested the same way.
- Deploys re-run them
- Each deploy runs the quality checks again, and a failing check stops it.
- Tests that guard the security model
- The app's permission table must match the API's routes, a new kind of record can't ship until it's decided whether it's audited, and a build fails if its scripts drift from its content security policy.
- Workflow security linting
- The repository that configures our AWS organization also lints its CloudFormation templates and checks its CI workflows for security issues.
2.4Vulnerability management
Our code is scanned continuously with Aikido, and each finding is triaged and tracked to a decision.
- Continuous scanning with Aikido
- Since July 2026, Aikido has scanned all of our repositories: our code for vulnerabilities (SAST), our dependencies for known vulnerabilities (SCA) and our infrastructure code, while it also monitors our public endpoints.
- Every finding decided
- Each finding becomes tracked work with a recorded verdict: fixed, or a false positive with its reason written down.
- A register of known gaps
- Weaknesses we find ourselves are recorded in a security gap register by severity, and tracked until they're closed.
- External penetration test
- In October 2026 an external party ran a penetration test of the platform. We fixed its findings, and the fixes are in production.
2.5Software supply chain
What goes into our builds is pinned, and what comes out of the Productmind CLI's build is checked and signed.
- Pinned dependencies
- Each repository pins its dependencies in a committed lockfile, and most of our pipelines fail when a lockfile is out of date.
- Signed CLI releases
- The Productmind CLI's release checksums and its Linux packages are signed.
- No keys in a binary
- A CLI build fails if any binary it produces contains private-key material.
2.6Deployment and release
Deploys are automated, staged and guarded against destructive mistakes.
- No long-lived cloud keys
- Our pipelines reach AWS through GitHub's OpenID Connect, with short-lived credentials, and each is trusted only for its own repository and stage.
- Pre-production first
- Changes run on our pre-production stage before a release takes them to production.
- Guarded infrastructure deploys
- An infrastructure deploy stops when it can't resolve exactly what it's deploying, and deploys to production only from main. Production data stores are kept even if their code is removed.
- Migrations in the deploy
- Database migrations run as part of each deploy, and a failed migration fails the deploy.
- Pinned rollbacks
- A rollback redeploys an earlier, pinned version, and is refused when that version predates a one-way change to our data.
2.7Monitoring and incident response
We log what happens on the platform, and we tell you when something goes wrong with your data.
- Request logging
- The API writes one access log line for every request it serves.
- Database audit logging
- Our production database logs every write, schema change and connection.
- Operational alerts
- Our team gets an alert when a coding runner stops responding, is relaunched or is lost.
- Breach notification in 48 hours
- If a personal data breach affects your data, we notify you within 48 hours of becoming aware of it, with what we know, its likely consequences and what we're doing about it.
03Productmind infrastructure
The cloud Productmind runs on
Productmind runs on Amazon Web Services in the EU, on servers AWS runs and patches, in accounts and networks defined in code, with your data encrypted in transit and at rest.
3.1Hosting and data residency
Your workspace data is stored in the European Union.
- AWS Frankfurt
- Productmind runs on Amazon Web Services in the Frankfurt region (eu-central-1), where your workspace data is stored.
- A separate account per stage
- Production, our pre-production stage and our test stages each run in their own AWS account, within one AWS Organization.
- Processing outside the EU, disclosed
- Some subprocessors, including AI model providers, process data outside the European Economic Area when the service uses them, under Standard Contractual Clauses. The Subprocessors page lists where each one does.
3.2Serverless platform
Our API and our database run on serverless AWS services: AWS runs the servers beneath them and keeps them patched, and we look after what runs on top.
- No servers we manage
- Nothing in our production account runs on a server we manage: there's no machine to sign in to and no SSH key to guard. The coding runners run on Amazon ECS Managed Instances, machines AWS provisions, patches and retires.
- The API on AWS Lambda
- The API and its WebSocket run on AWS Lambda. AWS runs the servers beneath them and keeps their operating system patched.
- Nothing waiting between requests
- The API runs only while it's handling a request. Between requests AWS Lambda freezes it, so there's no idle server of ours for anyone to probe.
- The database on Aurora Serverless
- The database runs on Amazon Aurora Serverless, with PostgreSQL. AWS runs and patches its servers, and applies new PostgreSQL minor versions automatically in a weekly maintenance window.
- What stays ours
- Our code, the runtime it ships with and its dependencies are ours to keep up to date. They're pinned to exact versions, and our code and its dependencies are scanned continuously.
3.3Network security
The database is reachable only from the API, and nothing reaches the coding runners from outside.
- A private database
- The database runs in private subnets, isn't publicly accessible, accepts connections only from the API, and has no outbound access.
- The API in our VPC
- The API runs inside our virtual private cloud.
- Runners closed to inbound traffic
- A coding runner accepts no inbound connections and can't reach the database. It can reach the internet, so the agent can install your dependencies.
3.4Encryption and key management
Data is encrypted in transit and at rest, and the credentials you give us are encrypted again by the application.
- HTTPS only, with HSTS
- Every connection to Productmind uses HTTPS, and browsers are told to use nothing else for a year, on every subdomain.
- TLS to the database
- The API connects to the database over TLS and verifies the database's certificate.
- AES-256 at rest
- Databases, object storage, queues and the parameter store are encrypted at rest with AES-256.
- Integration credentials encrypted twice
- Credentials for your integrations are encrypted by the application with AES-256-GCM before they're stored, and the API never returns them.
- Managed secrets
- Platform secrets are kept encrypted in AWS Systems Manager Parameter Store and AWS Secrets Manager.
- Signed sign-in tokens
- Sign-in tokens are signed with an RSA key held in AWS Systems Manager, and their algorithm, issuer and audience are checked on every use.
3.5Cloud identity and access
Each part of the platform has its own role, and people and pipelines reach AWS with short-lived credentials.
- A role per component
- Each part of the platform runs with its own IAM role, scoped to what it does. A coding runner's role lets it call AI models and nothing else in AWS.
- A credential per session
- A runner writes its session's transcript with a 15-minute credential that reaches that one session's storage.
- Single sign-on for our team
- Our team signs in to AWS through AWS IAM Identity Center, with sessions that expire.
3.6Isolated coding runners
A cloud coding session, its live preview and its repository scans run on a container task started for that session.
- One task, one session
- Each runner is a container task started for one session. It refuses work for any other session, and serves no other organization.
- A machine per session
- Each cloud coding session's runner gets a machine of its own, which never serves another session and is discarded when the runner stops.
- Nothing secret in the task
- Your secrets are never written into a runner's definition or placed on a queue: the runner fetches them when it needs them.
- Stopped when idle or overrunning
- A runner exits after a few idle minutes with no live preview, and one that runs past its maximum runtime is stopped.
3.7Logging and audit trails
Changes to our AWS estate are recorded, with integrity checks, and kept.
- AWS CloudTrail
- CloudTrail records management activity in our production account, with log file validation, and keeps it for two years.
- An organization trail
- Our AWS organization keeps its own trail across every region, encrypted, with log file validation and locked storage, and it alerts us to sensitive changes.
- Edge and database logs
- The API's edge keeps access logs, and the database's audit log is exported to Amazon CloudWatch.
3.8Backup and resilience
Customer data can be recovered to a point in time, and production data stores are protected from deletion.
- 30 days of point-in-time recovery
- The primary database can be restored to any point in the last 30 days, a floor our production configuration can't lower.
- 35 days for our other databases
- The tables that hold customer data in our other databases have 35 days of point-in-time recovery.
- Deletion protection
- The primary database has deletion protection, and production data stores are retained even if their infrastructure code is removed.
- Replicated storage
- Amazon Aurora keeps the database's storage in six copies across three Availability Zones.
3.9Web security
Our web applications tell the browser exactly what it may load and run.
- Security headers
- Our web surfaces deny framing, turn off content sniffing, limit the referrer they send and require HTTPS.
- Enforced content security policies
- The app runs scripts only from itself and named origins, never inline code. This website pins every inline script by its hash, and the API's policy allows nothing at all.
3.10Cloud accounts for your applications
When Productmind deploys an application into an AWS account for you, the account is built to the same standard.
- Guardrails on Managed accountsEarly access
- A Managed account is created in its own part of our AWS organization, with policies that block IAM users and long-lived keys, changes to the organization and sharing outside the account, and with its own audit trail and network flow logs.
- Your own account, one roleEarly access
- A connection to your own AWS account is a single role that admits only Productmind, with that connection's ExternalId and one-hour sessions.
Compliance and assurance
Certification, privacy and the agreements behind them
What we're working towards, how our controls are tested, and the documents that commit us to them.
- Working towards ISO/IEC 27001
- We're working towards ISO/IEC 27001 certification. Our controls are designed to meet ISO/IEC 27001:2022 and the SOC 2 Trust Services Criteria.
- Independent testing
- An external party penetration-tested the platform in October 2026, and its findings are fixed in production.
- GDPR
- We process your data as your processor under our Data Processing Agreement, with Standard Contractual Clauses for transfers outside the European Economic Area.
- Subprocessors
- Every subprocessor is listed with its purpose and location. We announce a new one 30 days before it receives your data, and you can object.
- DORA
- Financial entities can rely on our DORA Addendum, which covers the contractual provisions of Article 30.
- Security reviews
- We share our security documentation and answer security questionnaires under confidentiality, and support audits as our Data Processing Agreement describes.
Data Processing Agreement
How we process your data: our security measures in Annex 2, and the AI models we use in section 12.
Subprocessors
Who processes your data for us, for what, and where.
DORA Addendum
The Article 30 provisions for financial entities.
Privacy notice
What we process as a controller, on this website and in the product.
Report a vulnerability
Found a security issue?
Tell us, and we'll work with you to fix it. Write to our security team with:
- what you found, and where: the page, the endpoint or the component;
- the steps that reproduce it;
- what someone could do with it.
Please don't access data that isn't yours, degrade the service, or disclose the issue publicly before we've fixed it.
For a security questionnaire or our security documentation, write to the same address.