Zitadel upgrades and support

Teams running self-hosted Zitadel need upgrades tested against their own PostgreSQL and Helm setup, plus support after go-live. This page explains what that work covers, what drives its effort, and what you provide.

On this page

Zitadel upgrades and support: when a self-hosted team hands the work to a partner

Teams that run self-hosted Zitadel for workforce, customer or partner identity need to keep it current without interrupting sign-in for every application that depends on it. This service covers testing and rolling out upgrades, running database migrations, and providing support after go-live. Many teams keep routine patching in-house and hand the first major or minor move to a partner, because that move is where configuration drift, schema changes and integration breakage tend to surface.

Several events should start an upgrade review. The first is a new release on the v4 line. The most recent release reference we can point to is v4.19.5, released on 15 October 2026, and each release should be read against its notes before a test environment is touched. The second is a PostgreSQL version change. Self-hosted Zitadel uses PostgreSQL, with versions 14 through 18 supported, so a database upgrade on the platform or a move to a new managed service can change the supported matrix and must be checked on its own. The third is a Helm chart change, since chart values, probes and resource settings can shift between chart versions even when the Zitadel image stays the same. The fourth is a security advisory that affects a component you run. The fifth is a change to an upstream identity provider or a connected application, such as a new Entra ID tenant configuration or a changed OIDC client, which needs re-testing even when Zitadel itself is unchanged.

The work usually falls into a few parts: reviewing release notes and the migration path, building a staging copy with production-like data and PostgreSQL, rehearsing the upgrade and the database migration, testing sign-in flows for each application and identity provider, and writing a rollback plan with a clear point of no return. Confirm with your partner whether the rehearsal runs on a copy restored from a recent backup, and whether the backup restore itself is tested as part of the rehearsal. Ask who owns the change window, how traffic is drained during a Helm rollout, and who decides to roll back.

Support after go-live is a separate decision. A fixed-scope upgrade ends when the agreed deliverables are handed over. Ongoing support, scheduled upgrades and continuous testing are available as retainers, and the agreement should state which release lines are covered, how security advisories are triaged, and what response is expected when sign-in fails. Enterprise support terms, including any custom support agreement or technical account manager arrangement, are set by Zitadel and are not the same as a partner retainer, so ask for each one separately. Confirm the coverage in writing before the first upgrade starts.

What a Zitadel upgrade and support engagement includes

Each engagement breaks into discrete deliverables, and each one produces a record the next one depends on. The scope is agreed in writing before work starts. Ongoing support and upgrades can also be taken as a retainer once the initial work is complete.

Current-state inventory

Before any change, we record the running Zitadel version, the deployment method (Linux binary, Docker Compose or Kubernetes with the official Helm chart), the Helm values in use, and the PostgreSQL version. PostgreSQL must fall within the supported 14 through 18 range, so an older database may need its own step first. The inventory also maps instance and organization layout, projects and identity provider connections. This baseline is what every later step is checked against.

Upgrade plan with rollback steps

The upgrade plan lists each version step, the order of database migrations, the change window and the owner of each decision. It includes rollback steps written for the state at each stage, such as restoring a database snapshot and reverting the chart or image version. Ask who approves a rollback and how long the team has to decide before reverting. Confirm the target v4 release against the Zitadel releases page on the day the plan is written.

Test upgrade in staging

A staging copy of Zitadel is loaded with restored production data, so the migration runs against real schemas, users and client configuration. The test records migration runtime, errors, login behavior and any settings that changed during the upgrade. The results decide whether the production window is viable. Confirm that the staging database version matches production and that restored data is handled under your data protection rules.

Documented rollout runbook

The runbook is a step-by-step document for the Helm or Docker Compose rollout. It covers pre-checks, backup confirmation, the commands or chart values to apply, health checks after each instance restarts, and the stop conditions that trigger rollback. Each step has an owner and an expected output. Kubernetes teams should confirm replica ordering and how migrations execute during a rolling update, since this differs by deployment method.

Post-upgrade verification of clients and providers

After cutover, we test each OIDC and SAML client with a live sign-in, token issuance and sign-out. We also confirm that federated identity providers such as Entra ID, Okta, Google or LDAP still complete login. Passkey and MFA paths are included where they are enabled. Results are recorded per application, so any failed check has a named owner and a fix or rollback decision before the change is closed.

Support schedule after go-live

The support schedule defines what happens after go-live: monitoring checks, incident response, reviews of patch and minor releases, backup restore tests and access to upgrade work. Confirm response times, service hours and the escalation path in writing before signing. Retainers can cover this recurring work, while a one-time upgrade stays within its agreed written scope.

What drives the cost and duration of a Zitadel upgrade

This table lists the drivers that change how much effort a Zitadel upgrade takes, why each one matters, and how to reduce it. Compare each row with your own instance count, client inventory and environments before asking for a quote. The main takeaway is that testing scope grows with every instance, client, identity provider and environment, so reducing that surface area is the most direct way to keep effort down.

DriverWhy it mattersHow to keep it down
Instances and organizationsEach instance is a fully isolated tenant with its own data, so post-upgrade checks run per instance. Organizations inside each instance add users, projects and settings to confirm.Consolidate tenants where isolation needs allow, and script post-upgrade checks so they run the same way on every instance.
OIDC and SAML clientsEvery registered application must be retested for login, token refresh and logout after the upgrade. The test list grows with each client added.Keep a current inventory of clients with owners and test cases, and group clients by protocol and flow so they share test suites.
Federated identity providersEntra ID, Okta, LDAP and OpenLDAP, Keycloak and generic OIDC connections each have their own login path to verify, and each organization may use a different one.Document the configuration of each provider, keep a test account for each, and confirm whether provider-side changes affect the connection.
Database size and migration complexitySchema changes run against PostgreSQL data on a supported version (14 through 18). Larger datasets and custom database changes lengthen rehearsal and rollback planning.Confirm your PostgreSQL version is supported, rehearse the migration on a recent copy of production data, and verify backups before each step.
CustomizationsLogin branding, per-organization settings and Actions add code and configuration that must be reviewed against each new release.Keep customizations in version-controlled configuration, limit Actions to what the business needs, and record the owner and purpose of each one.
Number of environmentsDevelopment, staging, production and disaster recovery each need the upgrade applied and verified in the same order, so effort multiplies with each environment.Promote the same artifacts and configuration through each environment, and schedule disaster recovery updates to follow production.
Deployment methodLinux binary, Docker Compose and Kubernetes with the official Helm chart differ in rollout steps, rollback options and how replicas restart.Standardize on one method where possible, and treat the official Helm chart and its values files as the source of truth on Kubernetes.
Compliance evidence requirementsAssessors may ask for change records, test results, approvals and before-and-after configuration. Collecting this adds work to every upgrade.Agree the evidence list before the upgrade, capture it inside the change process, and confirm the format with your assessor.
Gap between current and target versionSkipping releases means reviewing more change notes and retesting more behavior. Supported upgrade paths vary by release.Upgrade in smaller, regularly scheduled steps where the release notes allow, and review the release notes for every version in the path before planning.

How a Zitadel upgrade moves from staging test to production

This sequence moves a self-hosted Zitadel release from a documented version gap to a production cutover that has been rehearsed against a copy of the real database. Each phase closes with a written output, so the change window is approved on evidence rather than on hope.

  1. Assess the version gap and release notes

    Identify the current Zitadel version in production and the target release on the v4 line, then read every release note between them for breaking changes, required configuration edits and database migration notes. The team lead and the DeployOpen engineer review this together. The output is a written version gap review that lists each change that touches your deployment, your Helm values or your integrations. The step is done when every change is either scheduled or marked not applicable with a reason.

  2. Rehearse PostgreSQL backup and restore

    Take a fresh backup of the production PostgreSQL database and restore it into an isolated environment that matches production's supported PostgreSQL major version, which must fall within the 14 to 18 range Zitadel supports. The database owner confirms the restore completes and that the restored instance starts and serves data. Record the backup method, the restore time observed and any gaps found. The output is a signed restore rehearsal record. Do not proceed to staging until this record exists.

  3. Upgrade staging with the target release

    Deploy the target Zitadel release to a staging environment built from the restored database copy, so the schema migrations run against production-shaped data. Watch the migration job logs from start to finish and capture any errors or warnings. The team confirms that all pods or processes reach a healthy state and that the instance serves its API and console. The output is a staging deployment log and a migration record showing the final schema state.

  4. Test login flows, passkeys and federation

    Run scripted and manual tests across the flows your users depend on: password login, passkey registration and sign-in with password fallback, and SCIM provisioning and deprovisioning. Test each federated identity provider you use, including Entra ID, Okta, Google, LDAP or any per-organization provider, and confirm that OIDC and SAML clients still receive correct tokens and assertions. Record pass or fail for every case. The output is a functional test report with each failure either fixed and retested or accepted in writing by the owner.

  5. Review Helm values and chart differences

    If you run the official Helm chart, which Zitadel recommends for high availability, compare the rendered manifests of the current and target chart versions and review each difference against your own values file. Confirm that secrets, the master key reference, database connection settings and TLS configuration carry over unchanged. Teams running Linux binaries or Docker Compose follow a different rollout path that replaces this review with their own configuration diff. The output is an approved values and manifest diff stored with the change ticket.

  6. Execute the production change window

    Agree a change window with the business owners, announce it, and take a final production backup immediately before the change. Apply the approved chart or deployment change, let the migrations run, and verify health checks, login success and token issuance before opening traffic fully. Keep the rollback plan ready and the restored backup reference recorded. The output is a completed cutover record with timestamps, the backup identifier and the verification results.

  7. Monitor after cutover and hand over

    After go-live, watch error rates, login failures, provisioning jobs and database health against the baseline captured before the change. Confirm that scheduled SCIM syncs and federated sign-ins behave as they did in staging. When the operating team accepts the environment, the DeployOpen engineer hands over the final runbook, the version record and the open items list. The output is a signed handover pack that names who owns each open item next.

Which Zitadel upgrade tasks stay in-house and which go to a partner

This table compares each recurring Zitadel upgrade and support task with the team usually best placed to own it, and the skills each one needs. Read the outsourced column as the work a partner typically takes on for the first move to a new major line or a complex multi-instance estate, not as a rule for every release. The main takeaway is that day-to-day operations often stay with your team, while the riskiest structural changes benefit from an outside partner.

TaskUsually kept in-houseUsually outsourcedSkills needed
Routine minor patchingApplying patch releases within the v4 line in staging and productionInitial setup of the patching runbook and pipelineKubernetes or Docker operations, Helm basics
Reading release notesTriage of each release for changes that affect your configuration or clientsDetailed impact analysis for a jump across major linesWorking knowledge of OIDC, SAML and Zitadel configuration
PostgreSQL backup policyRunning scheduled backups and periodic restore testsDesigning backup retention and point-in-time recovery for the estatePostgreSQL administration, backup tooling, recovery testing
Helm value managementEditing values files and reviewing chart changes in version controlMapping legacy values to a new chart version and validating defaultsHelm, GitOps practice, Kubernetes manifests
Identity provider changesUpdating upstream provider settings for existing customersRedesigning federation for a new identity provider or organization modelOIDC and SAML federation, identity provider administration
Staging test designMaintaining regression tests for your own login flows and applicationsDesigning the full upgrade test matrix, including database migration rehearsalsTest automation, identity flow testing, migration validation
Cutover coordinationScheduling the change window with application ownersRunning the cutover plan, rollback decision points and go or no-go checksChange management, incident command, Zitadel architecture
Incident responseFirst-line response and escalation during business hoursSpecialist troubleshooting for failed migrations or cross-instance faultsLog analysis, database diagnostics, Zitadel internals
Compliance evidence captureKeeping change records, approvals and test results currentPreparing control evidence packs for assessors and auditorsControl mapping, change and access record keeping

Zitadel upgrade risks: what breaks on the v4 line and how to prevent it

Most Zitadel upgrade failures trace back to a short list of causes: unsupported database versions, untested rollbacks, environment drift, overwritten chart values and trust settings that no longer match. Each card names one failure mode and the checks that prevent it. Work through them before every upgrade on the v4 line, then repeat the trust and provisioning checks after cutover.

PostgreSQL outside the supported range

Zitadel documents PostgreSQL 14 through 18 as supported database versions. A database major version outside that range may start without complaint, then fail during schema migration or under production load, which is the worst time to find out. Before any upgrade, record the current PostgreSQL major version, confirm the target Zitadel release supports it, and plan any database upgrade as a separate, tested change. Check the version in staging as well, since a mismatch there hides the problem until production.

Migrations without a tested restore point

Zitadel applies database migrations when a new version starts, and a failed migration can leave the schema partly changed. Take a full database backup immediately before the upgrade, then restore it into a separate environment and confirm the instance starts and users can sign in. Record the exact restore commands and how long each step takes, so the rollback plan rests on measured steps and documented timings. Repeat the restore test for each target release, because migration content changes between versions.

Master key and configuration drift

The master key Zitadel uses for encryption must be identical wherever a backup of the database will be restored, and configuration sets database, TLS and login behavior. When staging and production use different keys or settings, a restored backup may fail to decrypt, or a fix tested in one environment never reaches the other. Keep the master key in a managed secret store with access logging, keep configuration in version control, and compare the rendered configuration of each environment before each upgrade. Store the key backup separately from the database backup.

Helm values overwritten during chart upgrades

Teams running the official Helm chart keep local values files for hostnames, replicas, database connections and custom templates. A chart upgrade run with default values, or with a values file copied from an older template, can silently reset these settings. Customizations such as login branding, Actions and template overrides can also break when chart defaults change. Diff the new chart's default values against your own values file, render the manifests with helm template, and review the output before running helm upgrade.

Endpoints that stop matching after cutover

Cutover often moves Zitadel to a new hostname, certificate or issuer URL. OIDC clients reject logins when the redirect URI, post-logout URI or issuer no longer matches exactly. SAML service providers reject assertions when they hold outdated Zitadel metadata or signing certificates. SCIM clients configured against the old base URL or token stop provisioning users, groups and deactivations, and their failures may appear only in the client's own logs. Inventory every application, redirect URI, SAML metadata file and SCIM client before cutover, then test each one after cutover.

Expiring federated identity provider certificates

Upstream identity providers such as Entra ID, Okta or a SAML partner sign assertions with certificates that expire on a fixed date. When that certificate rolls over and Zitadel still trusts the old one, users in the affected customer organization cannot sign in, and the failure looks like a Zitadel fault. Record each federated provider's certificate expiry date, subscribe to its rollover notices, and test the replacement certificate in staging before the old one lapses. Confirm which organizations use each provider, since a single expiry can affect several of them.

What you need to provide before a Zitadel upgrade starts

The upgrade cannot be planned safely until the client supplies the items below, and each one needs a named owner on the client side. Start with the running deployment. DeployOpen needs read access to the live Zitadel deployment and its configuration, plus the Helm values file or Docker Compose files that produced it. The platform or infrastructure team that operates the cluster or hosts usually owns these. Without them, the upgrade plan rests on documentation that may not match production. Check for drift now: settings changed directly in the cluster, but not in the Helm values, will be overwritten or missed during a chart upgrade, so the team should reconcile them before the change window.

Next, the database. Provide the PostgreSQL version and the date and result of the most recent full backup. The database platform or DBA team owns this. Confirm that the running version falls within the range Zitadel documents for self-hosting (versions 14 through 18 at the time of writing), because a version change during the upgrade adds work and risk. Ask whether a restore has been tested, not just whether backups run. A backup that has never been restored gives the rollback plan no solid basis. Also confirm who can take a snapshot at the moment of cutover and how long that takes to complete.

The client also needs a staging environment that can hold a copy of production data, including the user and event tables that database migrations touch. The platform team owns the environment, and the data protection owner must approve any copy of personal data, along with masking rules and retention limits. If staging holds only synthetic data, the migration is rehearsed against different data volumes and shapes than production. If no staging environment exists, the migration risk moves into the production change window, which is the wrong place to discover a problem. Agree the staging refresh date before the rehearsal is scheduled.

Provide a list of every OIDC and SAML client and every identity provider connected to the instance, with an owner for each. Application owners own their clients, and identity administrators own each federated provider, including Entra ID, Okta, Google or LDAP where they are in use. For each client, record redirect URIs, grant types and the organizations that depend on it. Also grant access to the identity provider admin consoles so testers can run test logins, with test accounts that carry the same MFA and policy settings as production. Without this list, nobody can confirm which logins to test, and a broken client is often first reported by a user.

Name one decision maker for change windows. This person approves the window, accepts the risk of cutover and calls a rollback during the event, so the role should sit with someone who can act without waiting for a committee. Then agree a rollback window in writing. The document should state how long after cutover a rollback remains possible, who authorizes it, and how data written to the upgraded instance during that period will be preserved or reconciled if the team returns to the earlier version. Settle these points before the change window is booked. Deciding them during an incident leaves the team without authority or a shared understanding of what a rollback costs.

How Zitadel upgrades differ on Kubernetes, Docker Compose and air-gapped networks

Zitadel recommends a Kubernetes cluster with the official Helm chart for high availability, so this is the path most production teams will test first. An upgrade is a chart version change plus, when the release requires it, a database migration that runs during the rollout. Testing should reproduce the production topology: the same replica count, ingress and TLS termination, and a PostgreSQL instance within the supported major versions.

  • Staging parity: Run the candidate chart against a restored copy of production data, with the same replicas and health probes.
  • Migration ordering: Confirm whether the chart runs database migrations as a job before pods roll, and what happens if that job fails midway.
  • Rollout behavior: Check the update strategy so old and new pods do not serve incompatible requests during the window.
  • Rollback limits: Confirm which database changes are reversible. Restoring a pre-upgrade backup may be the only option.
  • Verification: Test login, token issuance, the Console and one application integration after each stage.

Before scheduling, get the chart version to pin, the Zitadel release it deploys and the rollback steps in writing from the vendor or your platform team.

What support after Zitadel go-live covers and what it costs to keep running

Go-live is the start of recurring work, not the end of the project. A self-hosted Zitadel instance needs someone to watch it, respond when it misbehaves, restore it when it has to be restored, and move it forward on the v4 line. Whether your team or a partner carries that load, the work itself is the same. Before you compare options, list the recurring tasks and assign each one an owner in writing. The core tasks are monitoring and incident response, backup and restore tests, applying upgrades and patches, certificate and secret rotation, identity provider and client changes, access reviews, and evidence collection for assessments. Monitoring should cover login errors, token issuance, the PostgreSQL database and the Kubernetes or Docker runtime. Backup tests matter more than backup jobs: a restore into a separate environment is the only proof that a backup works. Secret rotation covers TLS certificates, database credentials and the credentials used by applications and identity provider connections.

The volume of this work depends on your design choices. Each customer organization, each federated identity provider and each registered application adds changes to track, and each one needs a review when its owner leaves or its configuration shifts. Upgrades carry two parts: the Zitadel release itself and any database migrations it runs. Zitadel documents PostgreSQL versions 14 through 18, so your database upgrade plan has to be checked against the Zitadel release you are moving to. Check the current v4 release notes and the GitHub releases page before each planned change, and rehearse every upgrade on a copy of production data first. Keep an upgrade calendar that names the test environment, the rollback point and the person who signs off. Record the result of each restore test and each access review in the same place, so that the evidence is produced as a side effect of operations rather than rebuilt during an audit.

There are two main sources of support. The first is a DeployOpen retainer, which covers ongoing support, upgrades and continuous testing inside your own infrastructure. Retainers are scoped in writing, so the decision is which of the recurring tasks above the retainer covers, which stay with your team, and how requests and incidents are routed between the two. The second source is Zitadel's own Enterprise plan, which the Zitadel pricing page describes as offering custom support agreements and technical account management. Enterprise pricing is custom and is listed for both self-hosted and cloud deployments, so ask Zitadel for a written statement of what it covers, how it treats your self-hosted version, and who is accountable for upgrade questions. The two options can overlap or complement each other. Clarify which party handles vendor escalations and which handles configuration work in your environment before signing either agreement.

The Zitadel pricing page lists ISO 27001, SOC 2 Type II and OpenID certification. Treat these as claims to verify, not facts to rely on. Confirm the current status directly with Zitadel, ask for the scope of each certification or report, and check whether it covers the software you will run or only Zitadel's own cloud operations. A vendor certification does not transfer to your self-hosted deployment, which your organization still has to assess against its own controls. DeployOpen prepares systems, controls and evidence for compliance assessments, but it does not issue audit reports, attestations or certifications. Independent auditors and certification bodies do that work. Ask your assessor early which evidence they expect from the identity platform, such as access review records, change records and restore test results.

Recurring cost has several components, and they are paid to different parties. Your internal staff time covers monitoring, approvals, access reviews and coordination. Infrastructure costs cover the Kubernetes or Docker hosts, PostgreSQL, backup storage, monitoring and log retention, and they recur every month. Retainer fees, if you buy them, are set from the written scope and recur on the agreed cycle. Enterprise subscription fees from Zitadel are custom and also recur. Upgrade and restore testing has a one-time setup cost for the test environment and a smaller recurring cost each time you run the tests. When you ask for a quote, request a list of included tasks, the response process for incidents, how upgrades and database migrations are tested, what is excluded, and how changes to scope are priced. Ask which costs are fixed and which change with the number of organizations, identity providers and applications you run.

Questions buyers ask about Zitadel upgrades and support

How much does a Zitadel upgrade and support engagement cost?

The cost follows the written scope, and DeployOpen does not publish a price list. A quote is built from the work agreed in writing before it starts. The main drivers are the number of environments to upgrade, the number of Zitadel instances and organizations, the number of client applications and identity providers that need regression testing, custom Actions and branding that must be checked, and the size and backup setup of the PostgreSQL database. One-time costs usually cover planning, a tested staging copy, upgrade rehearsal, cutover and documentation. Recurring costs apply only if you choose a retainer for monitoring, upgrades and support. When you ask for a quote, request an itemized list of deliverables, the environments included, the assumptions behind the estimate, the retainer term and what is excluded.

How long does a Zitadel upgrade take to complete?

The duration depends mainly on how many environments must be upgraded and how many instances, organizations and client applications need testing afterward. A single production cluster with a small set of applications takes far less effort than several environments with many identity provider federations and custom Actions. Other factors include whether the Helm-based rollout is already in place, how current the database backups are, and how much approval a maintenance window requires in your organization. Release notes for each version between your current and target release should be reviewed, because migration steps can differ. Ask for the timeline in the written scope, along with the milestones that gate the production cutover.

Can our own team upgrade self-hosted Zitadel without a partner?

Yes, an internal team can upgrade self-hosted Zitadel if it has the skills and time to do so safely. The essential prerequisites are a tested staging copy of the production database and configuration, a rehearsed rollback procedure, and a check that the PostgreSQL version falls within the supported range, which is versions 14 through 18. The team should also read the release notes for every version it crosses, verify the Helm chart values or deployment files, and test every client application and identity provider afterward. If your team lacks capacity, has not performed a Zitadel upgrade before, or wants an independent rehearsal before production, DeployOpen can plan and run the upgrade or support your staff during it.

What does our organization need to provide for an upgrade?

An upgrade needs access and decisions from your side, not only technical work. Typical requirements include access to the cloud accounts, Kubernetes cluster or servers where Zitadel runs, read access to the PostgreSQL database and recent backups, and handling of the master key and secrets under your own controls. You will also need a current inventory of client applications, identity provider federations and Actions, named business and technical owners who can confirm test results, approved maintenance windows, and test accounts for each application and tenant. DNS and TLS certificate details should be available before cutover. Confirm these items during scoping so they do not delay the work.

Should we upgrade self-hosted Zitadel or move to Zitadel Cloud?

The upgrade alone should not decide this. The choice depends on the long-term cost of running Zitadel, including infrastructure, database operations, staff time for upgrades and on-call duties, and the level of control your organization requires. Zitadel Cloud plans and Zitadel's Enterprise support terms are separate from the self-hosted cost model, so compare them on the same basis. Licensing also matters: Zitadel's core moved to the GNU Affero General Public License 3.0 with v3.0, and whether those terms affect your use should be confirmed with your legal counsel. Our cost-of-ownership topic compares self-hosted and Zitadel Cloud options in more detail before you commit to an upgrade plan.

What happens if a Zitadel upgrade fails partway through?

If an upgrade fails, the work stops and the team decides between fixing forward and restoring the pre-upgrade state. The rollback path depends on whether the database migration completed, so the team must first confirm the state of the schema and the running services. A tested backup taken before the upgrade and a rehearsed restore procedure make recovery predictable, which is why rehearsal in staging is part of the plan. Whether a specific release can be rolled back after its schema migration runs should be confirmed in that release's notes and in your own rehearsal. No upgrade plan removes the need for a backup, and the written scope should state who leads recovery and how the incident is communicated to the business.

Does support after go-live cover Zitadel patches and incidents?

Support after go-live covers only what the agreed scope and retainer include, so confirm the exact terms before you sign. DeployOpen provides ongoing support, upgrades and continuous testing as retainers, and the retainer defines which systems, release windows and response arrangements apply. Zitadel's Enterprise plan offers custom support agreements and technical account management, so ask Zitadel directly what its vendor support covers and how it works alongside a partner's retainer. Ask your partner to state in writing how patches are tested, who approves production changes, how incidents are escalated and what documentation is maintained.

How DeployOpen scopes, delivers and supports Zitadel upgrades

DeployOpen plans and carries out Zitadel upgrades inside your own infrastructure, from a written scope that names the target v4 release, the PostgreSQL and Helm changes, and the tests that must pass. Ongoing support after go-live is available as a retainer, so upgrades stay routine rather than becoming one-off projects.

How we scope

  • Inventory your current Zitadel version, deployment method (binary, Docker Compose or Kubernetes) and PostgreSQL version before estimating work.
  • Agree the target release on the v4 line and confirm it against the release notes and database support list.
  • Engagements are fixed-scope, so the written scope lists upgrade paths, environments, test cases and handover items before work starts.

How we build

  • Rehearse the upgrade and database migration in a non-production copy restored from a recent backup.
  • Test OIDC and SAML client logins, SCIM provisioning and federated identity providers against the upgraded instance.
  • Update Helm chart values and configuration in version control so each rollout can be reviewed and reproduced.

How we hand over

  • Document the runbook with pre-checks, rollout steps, rollback points and the validation checklist used for each environment.
  • Record the versions, configuration changes and migration results so your team can repeat the process without us.
  • Walk your operations and identity teams through the runbook and confirm who approves production upgrades on your side.

How we support

  • Offer post-go-live support as a retainer covering scheduled upgrades on the v4 line and review of new release notes.
  • Agree in the contract what response and review terms apply, and confirm them in writing with your team.
  • Re-run the upgrade test set whenever Zitadel, PostgreSQL or the Helm chart changes, so regressions surface before production.

Sources and further reading

Talk to our team.

Tell us what you're working on, whether it's a deployment, an audit, a security test or a cyber range. You'll speak with an engineer who can help you scope it.

  • 30-minute call: free, with no obligation.
  • NDA on request: we can sign before you share details.
  • Clear next steps: a scope and plan after the call.