Skip to main content

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.

Where the controls sit: a request from a person or a tool passes the edge's gates and the API's into your workspace's own store, and a coding session runs on a runner of its own and hands its work back as a pull request. All of it runs on servers AWS runs and keeps patched. Each gate carries the number of the section that describes it.
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, on its Multi-factor tab: an owner turns the requirement on, and Productmind says how many members will be signed out before it does. Sample data.

Single sign-on in the user guide

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.

Roles and permissions in the user guide

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.

API access in the user guide

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.
A session in review: one of its repositories is read-only, so nothing was pushed there, and its change to a CI workflow waits for a person to approve it. Sample data.

Pull requests in the user guide

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.
The audit log: changes by a person, a coding session, a service and a Productmind architect, and a role's permissions opened field by field. Sample data.

The audit log in the user guide

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.

Support access in the user guide

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.

How a change to Productmind reaches production: a tracked task, a pull request on a protected branch, the automated checks, our pre-production stage, then a release; apart from the line, Aikido scans continuously.

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.

Productmind's AWS Organization: in the production account, the edge, the API on AWS Lambda and the database on Aurora Serverless in our virtual private cloud, the coding runners, one machine per session in a network of their own, with no way into ours, and the encrypted stores, all on servers AWS runs and patches; beside it, the organization's own trail and the other accounts.

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.

Cloud accounts in the user guide

Shared responsibility

What we secure, and what's yours

Productmind secures the platform, with the controls on this page. Your organization decides who gets in, what it brings, and what it approves, merges and deploys. Here is where that line sits, area by area.

  • Amazon Web Services

    Runs the data centers, the hardware and the servers beneath our API, our database and our coding runners.

  • Productmind

    Secures everything we run on top: our code and its dependencies, the configuration of our cloud, and the controls in parts 01 to 03.

  • Your organization

    Decides who gets in and with which role, what data and code it brings, and what it approves, merges and deploys.

Area by area

AreaProductmindYou
Members and roles

The API enforces each role, a team's role only adds permissions, and disabling a member ends their sign-in and stops their tools.

See 1.2

Who joins your organization, with which role, teams and workspaces, and disabling the people who leave.

Product Terms 3.1, DPA 3.3

Sign-in

Single sign-on, multi-factor authentication, a lockout after wrong codes, and sessions you can see and end.

See 1.1

Requiring single sign-on and multi-factor authentication where your plan includes them, and the security of your own identity provider.

Product Terms 3.3

Credentials and connected tools

Every tool signs in with OAuth, with no API keys, access that lasts an hour, and connections that expire when unused.

See 1.4

Keeping your members' sign-in credentials and tokens confidential.

General Terms 4.1

Your data

We process it as your processor, keep it apart from other customers' data, encrypt it, and delete it on the schedule we publish.

See 1.3, 3.4, 1.8

What you bring into Productmind: a lawful basis for it, telling the people concerned, the consent that recordings, interviews and the feedback widget need, and no special categories of personal data unless we've agreed safeguards for them in writing.

DPA 3.1 and 3.2, Product Terms 8.3

Integrations and model keys

Integration credentials are encrypted by the application and never returned by the API, and a model key of your own is never replaced silently.

See 3.4, 1.5

Which integrations and model keys you connect, the access you grant at each provider, and what that provider does with your data.

Product Terms 7.1 and 7.2, DPA 3.3

Repositories and code

The agent has no access to your Git provider of its own, nothing is pushed to a read-only repository, and scans only read.

See 1.5

Which repositories you connect, knowing an AI model reads them; your code's security, its dependencies and the secrets in it; and your repositories' settings at your Git provider, such as branch protection.

Product Terms 5.1 and 5.6, DPA 12

AI output and merges

A person approves the plan before any code is written and merges the pull request, risky files are flagged, and on GitHub a change to a CI workflow waits for a person.

See 1.5

Reviewing what the agents produce, code included, before you rely on it, merge it or publish it. Merging, deploying and releasing are your decisions.

Product Terms 5.4, Product Terms 6.1

Sandboxes and container images

Each cloud session runs on a runner and a machine of its own, closed to inbound connections, that fetches your secrets only when it needs them.

See 3.6, 3.3

A container image you supply: its base, its patches, and keeping secrets out of it. And the variables and secrets you configure for a sandbox, which should be only what a session needs.

Product Terms 5.3 and 5.6

Where sessions run

The Productmind CLI's releases are signed, and each cloud runner serves one session and no other organization.

See 2.5, 3.6

Whether sessions run in our cloud or on your members' machines, and on theirs, those machines and their own Claude Code or Codex accounts, under those providers' terms.

Product Terms 5.2

Cloud accountsEarly access

A Managed account is built with guardrails, and an account of your own admits Productmind through a single role.

See 3.10

An AWS account of your own that you connect, and everything in it apart from the role it gives Productmind.

Product Terms 7.3

Incidents

We notify you within 48 hours of becoming aware of a personal data breach affecting your data, and help you with the notifications the law asks of you.

See 2.7

Telling us at security@productmind.ai without delay if you suspect unauthorized access, and, as the controller, notifying the supervisory authority and the people affected where the law requires it.

General Terms 4.1, DPA 6

Settings to review

Most of your part is a setting, in Productmind or at your Git provider. These are the ones to check first.

Require single sign-onStart and up
Members then sign in only through your identity provider, and the owner keeps a way in.
Require multi-factor authenticationEvery plan
Of every member, the owner included.
Review roles and teams
Give each member the role their work needs, and disable the people who leave.
Decide on support access
It's on unless your organization requires single sign-on, and an Owner or Admin can turn it off.
Mark repositories read-only
For code the agents should read but never push to.
Review each application's risk rules
Choose which files a reviewer sees flagged first.
Protect your branches
At your Git provider, require reviews and passing checks before anything merges to the branches you release from.
Choose where sessions run
Turn off Productmind cloud sessions, and every session runs on your members' own machines.
Set how long the audit log keeps eventsScale and up
From 90 days to indefinitely, per workspace.

This is a summary, and the Agreement prevails over it. It sets these responsibilities out in full in the General Terms, Product Terms and Data Processing Agreement.

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.

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.
security@productmind.ai

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.