Skip to main content

Overview

Twenty is an open-source CRM — a self-hosted alternative to Salesforce, HubSpot and Pipedrive — with customizable objects, pipelines, views and workflows behind a REST and GraphQL API. This template deploys the Twenty server (React front end plus NestJS API on port 3000), a background worker that drains its job queues and runs its cron jobs, a bundled single-node Redis, and a PostgreSQL database that is a single instance by default or a highly available Patroni cluster with one flag. Attachments go to a shared persistent volume or to an S3 bucket you own. Twenty is AGPL-3.0 licensed; the template runs the unmodified upstream image.
This template does not create a GVC. It deploys into an existing GVC that you already have; pass it with --gvc GVC_NAME.

What Gets Created

Your app key, database credentials and Redis password secrets (see Prerequisites) are not created by the template.

Prerequisites

Three secrets must exist before installing. They hold credentials, so they are prerequisite secrets rather than values — a value would sit in plaintext in the Helm release for the life of the install. Twenty encrypts stored OAuth tokens, TOTP secrets and app variables, and signs its auth tokens, with one app key that you supply through an opaque secret. The value never passes through Helm values; the template hands it to Twenty as both APP_SECRET and ENCRYPTION_KEY. The bundled PostgreSQL and Redis take their credentials from two dictionary secrets.
1

Create the app key secret

The payload is a single random string. Secrets are org-level, so no --gvc flag is involved:
Set secrets.name to this name.
2

Back the value up

Store a copy outside Control Plane. The key is effectively write-once: changing secrets.name without pointing secrets.fallbackName at the previous key makes stored OAuth tokens, TOTP secrets and app variables undecryptable and logs everyone out. See Rotating the App Key.
3

Create the database credentials secret

A dictionary secret; the bundled PostgreSQL initializes with these values and Twenty connects with them, in either database mode:
Set its name in the key of the database mode you use: postgres.config.credentialsSecretName (single-instance, the default) or postgresHA.config.credentialsSecretName (HA). Use only letters, digits, - and _ in all three values — Twenty puts them in its database connection URL, and other characters break it (the openssl rand -hex password above is safe). Secret names are org-wide, so give each Twenty release its own secret. PostgreSQL reads the secret only when its data is first initialized — see Rotating the Database Password.
4

Create the Redis password secret

A dictionary secret with one key, password; the bundled Redis requires it and the server and worker connect with it:
Set its name in redis.credentialsSecretName. Use only letters, digits, - and _: Twenty receives the password inside its REDIS_URL, unencoded. Give each Twenty release its own secret. To change it later, see Rotating the Redis Password.
If any of these secrets does not exist at install time, the deployment wedges silently. cpln logs returns zero lines — the containers never start, so they have nothing to log. The one place the reason appears is status.versions[].message (for the Redis secret, also check RELEASE_NAME-twenty-redis):
Note this is get-deployments — plain cpln workload get has no versions field. Creating the secret repairs the deployment on its own after several minutes, or force a redeployment to skip the wait.
Everything else works with the defaults. Three optional features need their own setup first:
  • S3 attachment storage — an existing bucket plus either a Control Plane cloud account (AWS S3) or a static-key dictionary secret (S3-compatible servers). See Attachment Storage. Required for more than one server replica.
  • Database backups — a bucket and access setup for AWS S3, Google Cloud Storage or an S3-compatible server. See Backing Up.
  • App key rotation — a second opaque secret holding the previous key, referenced by secrets.fallbackName for the duration of the rotation. See Rotating the App Key.

Installation

Once the three prerequisite secrets exist, install into your existing GVC with their names set:
To install using another method, follow the instructions for it:

UI

Browse, install, and manage templates visually

CLI

Manage templates from your terminal

Terraform

Declare templates in your Terraform configurations

Pulumi

Declare templates in your Pulumi programs

Configuration

Each subsection shows the shipped defaults for one top-level values area.

Twenty Server

Both the server and the worker run twenty.image. Leave twenty.serverUrl empty on a public install: the server then advertises its own canonical endpoint, and the worker advertises the server’s — never its own. Set it, with the scheme, whenever browsers open Twenty at any other address: a custom domain (https://crm.example.com), or the address you reach through a port-forward on a private install (http://localhost:3000). Twenty compares the browser origin against SERVER_URL, so a mismatch breaks sign-in and CORS with opaque errors.

Background Worker

The worker drains the job queues (entity events, webhooks, workflow triggers, file maintenance) and runs the registered cron jobs. It is a fixed single replica with no worker.replicas knob, exposes no port and accepts no inbound traffic. It has no probes, so it reports ready as soon as it is scheduled — read its logs rather than its readiness:

App Key Secret

secrets.name is the prerequisite opaque secret from Prerequisites. secrets.fallbackName is set only while rotating the key — see Rotating the App Key.

Attachment Storage

Attachments are written to a shared (read-write-many) volume set mounted at /app/packages/twenty-server/.local-storage by both the server and the worker, so the worker’s file-maintenance jobs see what the server uploaded. Files survive restarts, redeploys and upgrades under the same release name.
Shared volume sets support expansion only — they cannot be snapshotted — and exist in a single location. For production, storage.type: s3 is the durable choice, and it is required for twenty.replicas above 1; the chart refuses to render that combination with local storage.

Access

Public access is on by default. Set publicAccess.enabled: false for an internal-only instance — external requests are then refused, and in-GVC callers still reach it according to internalAccess.type: The worker and the bundled Redis are never publicly reachable: the worker accepts no inbound traffic, and Redis accepts only same-GVC traffic. A change to either access knob takes a few minutes to take effect.

Redis

Redis is required — Twenty does not boot without REDIS_URL — and it runs as a single node with persistence on and eviction disabled, so a queued job is never dropped. Twenty accepts only a plain redis:// URL, which is why the Sentinel-based redis template is not used here. Its password comes from the prerequisite secret named by redis.credentialsSecretName; use only letters, digits, - and _, because the value is embedded in a connection URL.

Database

Enable exactly one of postgres (single instance, default) and postgresHA (highly available) — the chart refuses to render with both or neither. Twenty is wired to the active database automatically: the single instance directly, or the HAProxy leader endpoint in HA mode. In both modes the database credentials come from the prerequisite dictionary secret you created (see Prerequisites), named by postgres.config.credentialsSecretName or postgresHA.config.credentialsSecretName; the bundled database initializes from it and Twenty connects with it.
The other keys of the bundled postgres and postgres-highly-available templates are available under postgres.* and postgresHA.*, with one exception: postgresHA.proxy.enabled must stay true, because the HAProxy endpoint is the address Twenty connects to.
Choose the database mode before you have data. The two paths run different PostgreSQL majors (18 and 17) on separate volume sets, so flipping postgres.enabled / postgresHA.enabled on a live release points Twenty at a different, empty database — your existing records are orphaned, not migrated. Moving between the modes is a dump and restore.
Secret names are org-wide. If you run more than one release of this template in the same org, create a separate database credentials secret and Redis secret for each, and point each release’s postgres.config.credentialsSecretName (or postgresHA.config.credentialsSecretName) and redis.credentialsSecretName at its own.

Connecting

Read the public hostname and the stored credentials:
To verify the server from your machine without going through the public endpoint, forward port 3000 and query the health route:
On an install with publicAccess.enabled: false, the same port-forward is how you reach the UI in a browser at http://localhost:3000 — and twenty.serverUrl must then be set to that address, because Twenty checks the browser origin against it.

First Run

Twenty ships no default account. The first person to sign up creates the workspace and becomes its full administrator.
1

Wait for the server workload to report ready

A first install takes several minutes: the database and Redis come up first, then the server waits for a live PostgreSQL, runs its boot migrations and only then starts listening on port 3000. Every fresh install logs relation "core.appToken" does not exist and similar lines early in the boot — the migration framework probing for tables it has not created yet — and the readiness probe may report a transient failure during the migration window. Both stop on their own once migrations finish; do not abort the install.
2

Sign up immediately

Browse to the canonical endpoint of RELEASE_NAME-twenty and create the first account. On a public endpoint, whoever reaches the URL first owns the CRM — sign up as soon as the workload is ready, or install with publicAccess.enabled: false and reach the sign-up page through a port-forward (set twenty.serverUrl to http://localhost:3000 for that session).
3

Finish configuration inside the app

SMTP, AI provider keys, rate limits and OAuth/SSO are not template values. Set them in Settings → Admin Panel → Configuration Variables; they are stored in the database and apply without a redeploy.

Operations

Backing Up

Database backups are optional and off by default. They cover the PostgreSQL database — every record, workspace and user. Attachments are not included: in S3 mode they live in your bucket, in local mode on the RELEASE_NAME-twenty-storage volume set, which cannot be snapshotted. Enable backups with postgres.backup.enabled: true or postgresHA.backup.enabled: true (matching your database mode) and complete the storage setup for your provider before installing. The keys below are shown as backup.*; set them inside the enabled database block.
1

Create a bucket

Create an S3 bucket. Set backup.aws.bucket and backup.aws.region to match.
2

Set up a cloud account

If you do not have one, create a cloud account for your AWS account. Set backup.aws.cloudAccountName to its name.
3

Create a bucket-scoped IAM policy

Create an AWS IAM policy with the same bucket-scoped JSON shown under Attachment Storage (replace YOUR_BUCKET_NAME with the backup bucket), then set backup.aws.policyName to the policy’s name.
Single-instance mode takes scheduled logical dumps through the RELEASE_NAME-postgres-backup cron workload on backup.schedule. In HA mode, backup.mode selects logical (a scheduled dump run by RELEASE_NAME-postgres-ha-backup) or wal-g (continuous WAL archiving every backup.walg.intervalSeconds). backup.*.prefix is the key prefix within the bucket; schedules are cron expressions in UTC.

Restoring a Backup

The database restore is the one documented for the bundled database: Restoring a Backup on the postgres page, or Restoring a Backup on the postgres-highly-available page (logical and WAL-G). In HA mode, connect through RELEASE_NAME-postgres-ha-proxy.GVC_NAME.cpln.local so the restore targets the current leader; use the username and password from the secret named by *.config.credentialsSecretName. Three Twenty-specific points:
  • The server and worker must not be writing to the database while a dump is replayed. After the restore, force a redeployment of both so they reconnect:
  • Attachments are restored separately: copy them back into the bucket (S3 mode) or onto the RELEASE_NAME-twenty-storage volume set (local mode).
  • Keep the app key from your prerequisite secret with the backup. A dump restored under a different ENCRYPTION_KEY cannot decrypt the OAuth tokens, TOTP secrets and app variables it contains.
This restore path has not been exercised against a Twenty install. The database procedure is the bundled template’s own; rehearse it on a test release before you depend on it.

Rotating the App Key

secrets.name points at the opaque secret holding the current app key. secrets.fallbackName points at a second opaque secret holding the previous key and exists only for a rotation: Twenty uses it as FALLBACK_ENCRYPTION_KEY, a verification-only key that keeps rows encrypted under the old key readable while new writes use the new key.
1

Create the new key secret

2

Upgrade with both names set

Run helm upgrade with secrets.name pointing at the new secret and secrets.fallbackName at the old one. The identity is granted reveal on exactly those two secrets plus the ones the template creates.
3

Let the rollout finish

The server re-runs its boot migrations during this rollout, so it takes about as long as a first install. Sessions issued under the old key keep working and existing records stay readable. Twenty’s documentation does not say that rows are re-encrypted under the new key, so do not clear secrets.fallbackName on an assumption — keep both secrets until you have confirmed the old key is no longer needed.
Never change secrets.name without setting secrets.fallbackName to the previous key. Stored OAuth tokens, TOTP secrets and app variables are encrypted with the old value and become undecryptable, and every user is logged out.

Rotating the Database Password

PostgreSQL keeps the password it was initialized with, and a running workload keeps the values it started with, so a rotation takes three steps in order (single-instance; in HA mode follow Rotating the Database Password in HA Mode instead):
  1. Change it in the database: ALTER ROLE DB_USERNAME PASSWORD 'NEW_PASSWORD'; (connected as that user, from inside the GVC; letters, digits, - and _ only).
  2. Update the secret: cpln secret edit SECRET_NAME.
  3. Right away, redeploy Twenty — the worker first, then the server — and wait until get-deployments shows a higher version number, alone and ready (right after the command the status may not show the restart yet, and ready: true alone can still describe the old replica). Do not redeploy the database: PostgreSQL reads the secret only when it is first initialized, so restarting it only adds downtime.
Connections the app already has open keep working after ALTER ROLE; new ones fail until its redeploy finishes, so redeploy right away and rotate in a quiet window.

Rotating the Database Password in HA Mode

The HA database (postgresHA) needs its own order. The replication role repl shares the password, and a member that restarts with the old password can be promoted to leader, which splits the cluster. Move the leader to member -0 first, so it restarts last, after every other member already has the new password. pgx runs a command in one member (LOCATION is your GVC’s location, DB_USERNAME the secret’s username):
Then force-redeploy RELEASE_NAME-twenty-worker, then RELEASE_NAME-twenty, which keep the old password until they restart. The database drops connections briefly at each switchover, and the app cannot open new connections from the ALTER ROLE until its own redeploy finishes, so rotate in a quiet window. If a member stays starting, or running without streaming for several minutes, re-copy it from the leader. This copies the whole database, so it costs network traffic in proportion to its size:

Rotating the Redis Password

Redis keeps no password on disk: it takes the password from the secret each time it starts, and the server and worker do the same. So rotation is the secret and then the restarts:
  1. Update the secret: cpln secret edit SECRET_NAME (letters, digits, - and _ only), and check the new value with cpln secret reveal SECRET_NAME -o yaml.
  2. Redeploy Redis, the worker and the server together. None of them picks up the change without its redeploy.
Expect a short interruption: until all three have restarted, Redis and the app hold different passwords, so queued jobs wait and the server cannot reach its cache.

Upgrading From 1.0.0

Version 1.0.1 only updates the bundled highly available database to a release that compacts its etcd cluster. Without compaction, etcd’s backend grows with time alone and eventually goes read-only, taking PostgreSQL failover with it. Only installs running the HA database (postgresHA.enabled: true, off by default here) are affected — see etcd History Compaction for the mechanism and the symptoms. Compaction stops further growth but cannot shrink a backend that has already grown.

Upgrading From 1.0.1 or Earlier

Version 1.1.0 changed the single-instance database path:
  • postgres.config.username, postgres.config.password and postgres.config.database were removed. Carrying them fails the render with config.username was REMOVED in postgres 3.4.0. Put the values your single-instance database was initialized with into the database credentials secret under Prerequisites (keys username, password, database), set postgres.config.credentialsSecretName to its name, and remove the three keys.
  • postgres.backup.minio.accessKey and postgres.backup.minio.secretKey were replaced by postgres.backup.minio.credentialsSecretName, a prerequisite dictionary secret holding accessKey and secretKey — see Backing Up.
Keep the secret’s values equal to the ones your database was initialized with; the running database still enforces them. When upgrading straight to 1.4.0 or later, also follow Upgrading From 1.3.0 or Earlier for the Redis password.

Upgrading From 1.1.0 or Earlier

Version 1.2.0 moved the highly available database to postgres-highly-available 2.5.0, which no longer creates its own credentials secret:
  • postgresHA.postgres.username, postgresHA.postgres.password and postgresHA.postgres.database were removed. Carrying them fails the render with the postgres block was REMOVED in 2.5.0. Delete the block.
  • In HA mode the credentials now come from the database credentials secret under Prerequisites, named by postgresHA.config.credentialsSecretName.
Use the credentials your cluster already has. Put exactly the values your postgresHA.postgres.* block held into the secret’s username, password and database keys. The database was initialized with them and still enforces them; putting new values in the secret does not change the running database — it gives Twenty a password that no longer works.

Upgrading From 1.2.0 or Earlier

Version 1.2.1 replaced postgresHA.backup.minio.accessKey and postgresHA.backup.minio.secretKey with postgresHA.backup.minio.credentialsSecretName, a prerequisite dictionary secret holding accessKey and secretKey. Only installs backing up the HA database to an S3-compatible server are affected — see Backing Up for the secret. Version 1.3.0 changes no values. It makes the server and worker wait for a live PostgreSQL before running boot migrations, which fixes a first-install failure where the containers could start against a database that was not yet accepting connections.

Upgrading From 1.3.0 or Earlier

Version 1.4.0 removed postgres.credentials: the database credentials are now a prerequisite secret, the same one the database templates require on their own. redis.auth.password was removed the same way: the Redis password is now a prerequisite secret named by redis.credentialsSecretName. Carrying either old key forward fails the render. 1.3.x created the database secret itself, so this upgrade deletes it. Before upgrading, create a secret under a new name holding the values your database was initialized with — not new ones, or Twenty loses its database connection. OLD_SECRET_NAME is the credentialsSecretName of the mode you use (default my-twenty-db-credentials):
1.3.x also kept the Redis password in a secret it created, RELEASE_NAME-twenty-creds (key redisPassword), which this upgrade deletes too. Create the Redis secret under a different name, holding the current Redis password:
Then upgrade with postgres.config.credentialsSecretName (single-instance mode) or postgresHA.config.credentialsSecretName (HA mode) set to the database secret’s name, redis.credentialsSecretName set to the Redis secret’s name, and postgres.credentials and redis.auth removed. Your current values are also in postgres.credentials and redis.auth.password of the 1.3.x release. The upgrade restarts the bundled PostgreSQL and Redis too (they now read the new secrets), so Twenty briefly loses its database and Redis and reconnects by itself. The new version of a workload can also wait for several minutes, with get-deployments reporting that it is not allowed to reveal the secret, while access to the new secret propagates; the previous version keeps serving meanwhile, and it clears by itself.

Upgrading From 1.4.0 or Earlier

1.4.1 moves the HA database (postgresHA) to controlplanecorporation/patroni-postgres:0.8, which carries pgvector 0.8.7 (CVE-2026-103484). The fix takes effect when the upgrade restarts the Patroni members; existing data needs nothing. Nothing limits that rollout, so expect a brief interruption of writes while the leader changes. Twenty itself restarts as on any upgrade, and its worker and bundled Redis restart with it; with a single Twenty server replica (the default) that is the longer interruption, because the old replica stops before the new one serves, and writes fail while Redis restarts. Upgrade in a quiet window. If you pinned postgresHA.image in your values, set it to the 0.8 tag: tags 0.1 to 0.7 are refused at render. Twenty does not use the vector extension; if you created it yourself in a database, \dx keeps reporting the old version until you run ALTER EXTENSION vector UPDATE; there, which only updates that record. Single-instance mode (postgres) is unchanged.

Scaling and Availability

  • Server tier — twenty.replicas sets how many server replicas run behind the endpoint. Anything above 1 requires storage.type: s3; the chart refuses to render the combination with local storage.
  • Boot migrations run in exactly one container, and the template places them automatically: Because the worker owns migrations above one replica, a fresh multi-replica install serves errors until the worker has created the schema. Upgrades of an existing release already have a populated schema.
  • Worker and Redis — both are fixed at one replica by design: the worker owns cron registration, and Twenty accepts only a plain redis:// URL. A Redis restart stalls background jobs briefly; the UI stays up.
  • Database — the opt-in postgresHA path keeps serving through a replica failure and a rolling restart; the default postgres path has no failover. The mode is an install-time choice.
  • Helm upgrades — the first helm upgrade after an install can restart the bundled database and Redis even when their values did not change; upgrade in a quiet window.

Troubleshooting

Symptom: RELEASE_NAME-twenty and RELEASE_NAME-twenty-worker never reach ready, and cpln logs returns zero lines.Cause: a secret referenced by name does not exist — usually the app key secret (secrets.name), the database credentials secret (postgres.config.credentialsSecretName or postgresHA.config.credentialsSecretName) or the Redis secret (redis.credentialsSecretName), or the fallback or S3 key secret when those are set. The container never starts, so there is nothing to log.Fix: read status.versions[].message, which names the missing secret, then create it. The deployment recovers on its own after several minutes, or force a redeployment to skip the wait.
Symptom: a fresh install logs error: relation "core.appToken" does not exist and similar lines, and the readiness probe reports a transient failure.Cause: the migration framework probes for its state tables before creating them. This is expected on every fresh install and stops once the boot migrations finish.Fix: none — wait for the server to report ready. If the server never does, read its log for a migration error:
Symptom: the server or worker log repeats twenty: waiting for Postgres... (attempt N) and ends with twenty: Postgres not ready after 250s; exiting for restart.Cause: the start script waits for the database to answer a real PostgreSQL handshake before running migrations, and the database was not accepting connections within its window. On a first HA install this can happen once while the cluster elects a leader; a database that never comes up is a different problem.Fix: the container restarts and retries on its own. If it keeps happening, check the database workload — RELEASE_NAME-postgres or RELEASE_NAME-postgres-ha — with cpln workload get-deployments and its logs.
Symptom: the UI loads but sign-in loops or fails, and the browser console shows CORS or origin errors.Cause: the address in the browser does not match SERVER_URL. This happens with a custom domain, or when reaching a private install through a port-forward, while twenty.serverUrl is empty.Fix: set twenty.serverUrl to exactly the URL browsers use, including the scheme (https://crm.example.com, or http://localhost:3000 for a port-forward), and run helm upgrade.
Symptom: helm install or helm upgrade fails before anything is applied, citing twenty.replicas > 1 requires storage.type: s3.Cause: local attachments live on a volume set, which does not serve more than one server replica.Fix: complete the S3 setup under Attachment Storage and set storage.type: s3, or keep twenty.replicas: 1.
Symptom: the render fails citing static keys (storage.s3.auth.secretName) are only for S3-compatible servers.Cause: storage.s3.auth.secretName is set but storage.s3.endpoint is empty. AWS S3 is keyless only.Fix: for AWS S3, clear storage.s3.auth.secretName and use storage.s3.cloudAccountName plus storage.s3.policyName; for an S3-compatible server, set storage.s3.endpoint.
Symptom: helm upgrade fails before anything is applied, citing config.username was REMOVED in postgres 3.4.0.Cause: your values still carry the 1.0.x single-instance keys postgres.config.username, postgres.config.password or postgres.config.database.Fix: put the three values into the database credentials secret and remove the keys, as described in Upgrading From 1.0.1 or Earlier.
Symptom: helm upgrade fails before anything is applied, citing the postgres block was REMOVED in 2.5.0.Cause: your values still carry postgresHA.postgres.username, postgresHA.postgres.password or postgresHA.postgres.database from version 1.1.0 or earlier.Fix: delete the postgresHA.postgres block and put the same three values into the database credentials secret — see Upgrading From 1.1.0 or Earlier.
Symptom: helm upgrade fails before anything is applied, citing postgres.credentials was REMOVED in 1.4.0 or redis.auth was REMOVED in 1.4.0.Cause: your values still carry the 1.3.x plaintext database credentials or Redis password.Fix: create the two prerequisite secrets holding your current values and remove the old keys — see Upgrading From 1.3.0 or Earlier.

Important Notes

  • Create all three prerequisite secrets before installing — the app key (secrets.name, opaque, plain encoding), the database credentials and the Redis password. A missing one wedges the deployment silently; see Prerequisites.
  • The app key is effectively write-once — rotate it only with secrets.fallbackName set to the previous key, or stored OAuth tokens, TOTP secrets and app variables become undecryptable and everyone is logged out.
  • Sign up immediately after install — there is no seeded account, and on a public endpoint the first visitor to sign up becomes the workspace administrator. Install with publicAccess.enabled: false until you are ready if that is a concern.
  • Set twenty.serverUrl whenever browsers open Twenty at anything other than its canonical endpoint — a custom domain or a port-forward — with the scheme. A mismatch breaks sign-in and CORS with opaque errors.
  • Use only letters, digits, - and _ in the database and Redis secrets — both are embedded in connection URLs.
  • Changing the database credentials secret does not change the database password — PostgreSQL keeps the password it was initialized with. Rotate as described in Rotating the Database Password; in HA mode a leader switchover comes first.
  • Rotating the Redis password needs a forced redeployment of Redis, the worker and the server — see Rotating the Redis Password.
  • Choose the database mode before you have data — the single-instance and HA paths run PostgreSQL 18 and 17 respectively on separate volume sets; switching is a dump and restore, not a values change.
  • twenty.replicas above 1 requires storage.type: s3 — the shared local volume set cannot be snapshotted and lives in one location, so S3 is the production recommendation regardless of replica count.
  • AWS S3 is keyless only — use a cloud account plus a bucket-scoped IAM policy. Static keys are accepted only when storage.s3.endpoint points at an S3-compatible server.
  • Give each release its own database and Redis secrets — secret names are org-wide.
  • SMTP, AI provider keys, rate limits and OAuth/SSO are not values knobs — configure them in Settings → Admin Panel → Configuration Variables inside the app.
  • Foreign data wrappers (“remote objects”) are unavailable — that feature needs upstream’s custom PostgreSQL image, which this template does not deploy.
  • Data survives restarts and upgrades; uninstalling deletes it — records live in the database volume set and local attachments in the storage volume set, and both go with the release. Your prerequisite secrets are yours and survive an uninstall.

External References

Twenty Documentation

Official Twenty documentation

Self-Hosting Setup

Configuration variables and the in-app admin panel

REST and GraphQL API

Query and mutate CRM records over HTTP

Twenty on GitHub

Source code and release notes

Twenty Template

View the source files, default values, and chart definition