Zitadel v3 to v4 upgrade

A self-hosted Zitadel v3 to v4 upgrade touches the database, the runtime, every integration on v1 endpoints and the hosted login. This page explains what to verify, the order of work, and what drives effort.

On this page

Why plan a Zitadel v3 to v4 upgrade now

A team running self-hosted Zitadel v3 that must move to v4 to stay on a supported line should treat the upgrade as a sequenced change across setup, runtime, integrations and login. It is not a binary swap of one image or binary for another. Each layer has its own order of operations, its own rollback point and its own owner. Planning starts by naming those owners: the people who run the PostgreSQL database, the platform team that operates the Kubernetes cluster or Docker Compose host, the application teams that hold OIDC clients and service accounts, and the people who own the hosted login pages your users see. If those groups are not identified before the change window is set, the project stalls at the first decision that needs someone outside the project team.

Plan against a current v4 patch. The latest v4 release supplied for this planning is v4.19.5, released on 15 October 2026. Confirm which patch is current on the day you schedule the work, because later patch releases can carry different upgrade notes. The exact supported path, whether a direct jump from v3 or a sequence of intermediate releases, must be confirmed in Zitadel's upgrade documentation and in the GitHub release notes for each version between your current release and the target. Record the path you confirm in the change plan, together with the release notes you reviewed and the date you reviewed them.

Licensing belongs in the same plan. Zitadel moved its core, Console and hosted login from Apache 2.0 to the GNU Affero General Public License 3.0 with v3.0, which applied from 31 March 2025. APIs, SDKs, proto definitions, examples, documentation, Helm charts and Terraform configurations remain under Apache 2.0. The AGPL includes obligations for modified versions that users interact with over a network, so the question is whether your deployment modifies the core, Console or hosted login. Ask counsel to confirm that the terms for v4 match what your review approved for v3, and schedule that review before the upgrade is approved rather than after the cutover.

Start the inventory now, because it determines the size of every later step. List each Zitadel instance, the organizations and projects inside it, the OIDC and SAML applications and their redirect URIs, any SCIM provisioning connections, the identity providers that federate login, and any customized hosted login pages or branding. Confirm that your PostgreSQL version falls within the range Zitadel documents as supported for self-hosting (versions 14 through 18), and check the target release's documentation for any change to that range. Build a non-production environment from a recent backup so the setup step, the runtime change and the login checks can be rehearsed against your real data.

What changes between v3 and v4 and what to check

This table compares the four areas most likely to affect a v3 to v4 upgrade, plus the PostgreSQL version that must be confirmed first. Read the impact column to understand why each area matters, and use the action column as a checklist for your environment. Confirm every row against the official v4 release notes and migration guide before scheduling work, since this page does not list every breaking change.

ChangeImpactAction needed
PostgreSQL versionSelf-hosted Zitadel supports PostgreSQL 14 through 18. A database outside that range is not supported for the upgrade.Confirm your server version is 14 to 18 before upgrading. If it is not, plan the database upgrade first and test it separately.
Setup step before the new runtimeSetup runs before the v4 services start, so a skipped or failed step can block startup. Confirm which changes it makes to the database.Read the setup section of the v4 migration guide, rehearse it on a copy of the database, and record the required order.
Deprecated v1 endpoints and v2 replacementsIntegrations that call v1 endpoints may fail or need changes once those endpoints are removed. Check the release notes for removal timing.List every client, script and automation that calls v1 paths, then map each call to its v2 replacement in the migration guide.
Login V2 hosted login and custom brandingCustom branding and login pages may render differently under Login V2. Confirm which customizations carry over without changes.Test branding and each sign-in flow in a staging instance, including every identity provider used by your organizations.
Service Ping settingService Ping is a configuration choice that can change between releases. Confirm its default value and where it is set.Check the v4 configuration reference for the Service Ping setting and set it deliberately in your deployment configuration.

Why setup runs before the new runtime starts

The setup step runs before any v4 service starts because the database has to match what the new runtime expects before it reads or writes anything. When v3 and v4 share one PostgreSQL database, there is a window in which the schema or stored state is being prepared for the new release while older processes may still be connected. Running setup first, as a deliberate and separate step, keeps the new services from starting against an unprepared database and makes the cutover order explicit. It also gives the team one checkpoint: if setup fails, no v4 process has taken traffic yet. The exact protection depends on what the target release changes, so the team should read the upgrade notes for that release and confirm what they say about the database.

The command, its place in the sequence and whether it can be run again safely are defined by the official self-hosting documentation for your deployment method. Zitadel documents binaries, Docker Compose and Kubernetes with the official Helm chart, and each one wires the setup step differently. Confirm the exact invocation for the release you are moving to, the required configuration and database credentials, and whether it must complete before the new service definition is applied. Ask specifically whether the step is idempotent, meaning a second run on an already prepared database is harmless, because that decides how a failed run is retried. Confirm also that your PostgreSQL major version falls within the 14 to 18 range the database documentation supports. Record the answers in the runbook along with the documentation version you read, so a reviewer can check them later.

Setup changes shared state, so it is an operational event in its own right. Take a full database backup before it runs and verify that it can be restored, because an untested backup is only an assumption. Back up the configuration and secrets the v3 deployment uses, since both the new runtime and any rollback depend on them. Keep the v3 container images, binaries or Helm release revision available so the old runtime can be started again. Confirm in the documentation whether a v3 runtime can run against a database after setup has changed it. If it cannot, a database restore is the only rollback path, and the team must plan for that outcome before the window opens.

Agree the rollback point before the first v4 process starts, in writing, with named decision makers. The record should state which backup identifier is the restore point, who has authority to declare a rollback, which signals trigger that decision, and how writes from users and integrations are paused or replayed if a restore is needed. Decide whether the gap between backup and cutover is short enough that data written in it can be reconciled, and document how that reconciliation would work. Make sure the on-call engineers and the application owners who depend on the identity service have reviewed the plan. A rollback point that exists only in one engineer's memory will not hold up during an incident.

Rehearse the sequence on a copy of production data before the real window. Illustrative example: a team restores the latest backup into a staging environment running the same PostgreSQL major version, runs setup, runs it a second time to test idempotency, and then starts the v4 services against that copy. Each step produces a log entry and a check that the team can compare with the production run. The rehearsal also shows how long the backup and restore take in your environment, which is the figure to use when scheduling the window. Record the result in the cutover runbook, and ask your DeployOpen team or internal engineers to sign off on each step before the production change is approved.

What to back up and inventory before the upgrade

Four preparation areas each need an output the team can check before the change window opens. Each one guards against a different failure during the v3 to v4 upgrade: data loss, broken API callers, altered login pages or an untested runtime. Keep the Helm chart, Terraform configuration and configuration files in version control so the v3 state can be reproduced.

Database backup and tested restore

Take a backup of the PostgreSQL database Zitadel uses, and prove it can be restored. Zitadel supports PostgreSQL 14 through 18, so confirm the current supported version in the Zitadel database documentation and against your own PostgreSQL build before planning the change. The output is a backup set with a recorded checksum and a timed restore into a scratch environment, with the restore log filed with the change record. A backup that has never been restored is not yet evidence.

Inventory of Zitadel API callers

List every application, service account and script that calls Zitadel APIs, including scheduled jobs and CI pipelines that create users or manage projects. For each entry, record the API version it calls, especially any v1 endpoints that must move to v2, the authentication method, the owner and the environment it runs in. The output is a register with one row per caller and a named owner who will test that caller in staging. Callers missing from this list are usually the ones that fail after cutover.

Custom branding and Login V2 assets

Catalog every custom branding element and Login V2 asset in use, including logos, colors, fonts, custom text, stylesheets and any overrides applied at instance or organization level. Record where each asset is stored, which file version is live and who approved it. The output is an asset catalog plus login screenshots for each organization and login flow, captured before the change so the team can compare them in staging. Confirm in the current Zitadel documentation which settings carry over to the new runtime.

Staging built from production

Build a staging environment from a recent copy of production, deployed with the same method you use in production, whether Kubernetes with the official Helm chart, Docker Compose or binaries. Match the Zitadel version, PostgreSQL version, configuration and connected identity providers, and anonymize personal data where it appears. Keep the Helm chart, Terraform configuration and configuration files in version control so the v3 state can be rebuilt if the rehearsal must start again. The output is a staging instance and a rehearsal record listing every difference from production.

How to move integrations from v1 endpoints to the v2 APIs

Most applications that sign users in through Zitadel use standard OpenID Connect and OAuth 2.0 flows, which depend on discovery metadata and token endpoints. The v1 calls usually appear where an application or its backend calls management or user endpoints directly, for example to read user details or manage grants. Separate those two groups before you plan any change.

  • Find calls: Search application repositories for hard-coded API paths and base URLs in configuration. Check gateway logs for requests to v1 paths and use API audit data to identify which client identifiers made them.
  • Map calls: For each call, find the v2 equivalent in the API documentation for your target version. Record request fields, response fields and required scopes, because the response shape may differ.
  • Test in staging: Run sign-in, token refresh, logout and each backend lookup. Confirm that tokens still carry the claims the application reads.
  • Phase cutover: Move one application per window and keep a configuration switch so it can return to the previous path. Keep the v1 path active until its last caller is gone.

Confirm that each application owner has signed off on staging results before any production change.

The Zitadel v3 to v4 upgrade sequence with rollback points

This sequence moves a self-hosted Zitadel deployment from v3 to v4 in an order that keeps a clear rollback path until the schema changes begin. Each step closes with a check your team can record, so the production window opens only after staging, backups and integrations have been verified.

  1. Confirm the supported upgrade path and target patch

    Start from the official Zitadel upgrade guide for v3 to v4 and confirm your starting v3 release, any required intermediate steps, and the v4 patch you will deploy. The v4 line includes v4.19.5, released on 15 October 2026, but confirm whether that patch or a later one fits your plan. Check your PostgreSQL version against the supported range of 14 through 18. Done when a written upgrade record names the source version, target patch, database version and the guide revision you followed.

  2. Freeze configuration and take verified backups

    Freeze changes to Zitadel configuration, Helm values or Compose files, identity provider settings and instance settings for the duration of the upgrade. Export or checksum each file, then take a PostgreSQL backup with your database tooling and store a separate copy of configuration and every encryption key or secret the deployment depends on. Verify the backup by restoring it to a scratch PostgreSQL instance and confirming that Zitadel can read the expected instances and organizations. Rollback point: nothing has changed yet, so restarting the v3 deployment is the rollback.

  3. Upgrade staging end to end

    Run the full upgrade in a staging environment that matches production in topology, database version, identity providers, Login V2 branding and reverse proxy settings. Restore the data from the backup taken in the previous step, and handle any personal data under your own data protection rules. Work through the official guide in order, logging each command, error and manual correction. Done when staging runs v4, every deviation from the runbook has been reviewed, and the team agrees the log is complete. Rollback point: staging can be restored from the same backup and the run repeated.

  4. Migrate integrations to v2 APIs and verify in staging

    Inventory every client that calls deprecated v1 endpoints, including applications, scripts, provisioning jobs and monitoring checks, and plan the move of each to its v2 equivalent. Confirm with the upgrade guide which v2 endpoints exist on your starting release, since a client moved early may need the v1 path kept until cutover. Test token issuance, user and organization calls, and SCIM or admin automation against staging v4. Done when every inventoried client passes its test and the inventory shows no remaining v1 calls. Rollback point: keep each client's previous configuration on file so it can be reverted on its own.

  5. Schedule the production window and set rollback criteria

    Agree the production window with the owners of applications that depend on login, token issuance and provisioning, and confirm who can authorize a rollback. Write go and no-go criteria in advance, covering staging sign-off, a successful backup restore test, integration sign-off and a named approver for each step that changes data. Share the expected user impact during restarts with support teams. Done when the change record lists the window, approvers, criteria and the communications sent. Rollback point: no production change has been made, so cancelling the window leaves v3 running unchanged.

  6. Run setup before starting the v4 runtime

    Stop the v3 runtime, take a fresh database backup immediately before setup, and then run the setup step from the v4 release as the official guide describes. Setup prepares the database for the new runtime, so treat it as the point after which returning to v3 binaries alone is no longer a safe rollback. Check the setup output for errors, confirm the expected schema changes are present, and store the logs with the change record. Done when setup completes cleanly and the team has recorded the guide's statement on v3 compatibility with the migrated schema. Rollback point: from here, rollback means restoring the database from the backup taken just before setup, then redeploying v3.

  7. Start one v4 node and run smoke tests

    Where your deployment method and the guide allow it, start one v4 replica or node while the others stay stopped or on v3. Run smoke tests for login through Login V2, token issuance for a test OIDC client, SCIM provisioning for a test user, and the admin console functions your operators use. Watch logs and database connections throughout the tests. Done when every smoke test passes and the logs show no new errors over an observation period your team sets. Rollback point: if a test fails and the guide does not document a supported mixed-version rollback, stop the v4 node and restore the database from the pre-setup backup.

  8. Complete the rollout and close the rollback window

    Move the remaining replicas or nodes to v4, then confirm health checks and integration traffic on all of them. Update monitoring, runbooks and deployment manifests to the v4 release, and retire v1 endpoint paths only after the integration inventory confirms that no client still uses them. Keep the pre-setup backup for the retention period set in your policy and record the final state. Done when every node reports v4, smoke tests pass against the full deployment, and the change record is closed with the backup location. Rollback point: after the final node moves, rollback is a planned restore from the pre-setup backup, and data written since then needs a decision first.

Testing Login V2 with custom branding before cutover

Before cutover, the team must test the hosted login experience on the Zitadel v4 runtime, because end users reach Login V2 directly and a fault there blocks sign-in for every organization that depends on it. The hosted login covers four areas that users encounter in sequence: sign-in, passkeys with password fallback, federated identity provider buttons, and branding. Each area has its own code path and its own failure modes, so each needs explicit test cases. Treat a passing v3 setup as a starting point only. Confirm in the Zitadel v4 documentation which login and branding behaviors are documented for v4 before you write the test plan.

The core of the test plan is a matrix. The rows are the instances and organizations you run, because Zitadel separates tenants into instances and places organizations inside them, and each customer organization may have its own branding and its own identity provider. The rows also include each federated identity provider configured for those organizations, such as Entra ID, Okta or Google. The columns are the flows a user can take: first passkey enrollment, sign-in with a passkey, fallback to password when a passkey is unavailable, password reset, and the error pages for wrong credentials, disabled accounts and a failed upstream provider. Ask the platform owner to list which cells are actually in production use, and test those first.

Branding needs its own verification step because settings may not move between versions in the same form. Build an inventory of every branding setting in the v3 configuration for each instance and organization, including logos, colors, text and any per-organization overrides. For each item, use the v4 documentation to decide whether it carries over automatically, needs manual re-entry, or changed meaning. Record that decision in the plan with the source page you used. Then apply the v4 configuration to a staging copy of the production data and compare the rendered login pages against approved screenshots for each organization. Do not assume a visually similar page means the setting was applied correctly.

Browser and device coverage determines whether passkey tests mean anything. Passkey prompts, platform authenticators and password manager behavior differ between desktop browsers and between iOS and Android devices, so enrollment and sign-in should be tested on each browser and device class your users run, not only on the engineering laptop. Confirm the browsers and platforms the v4 documentation lists as supported for Login V2, and record any combination you test outside that list as a known risk. Include at least one session where a user switches between a passkey and a password on the same account, because that switch is where fallback defects tend to appear.

Set the exit criteria before testing starts. Name who signs off each organization's login and branding results, what counts as a blocking defect, and what happens if a check fails close to the cutover date. Write down the rollback path for the login layer, including who can make the call and how users are told. Your quote from DeployOpen should list the number of organizations, identity providers, browsers and devices in scope, since those counts drive most of the testing effort. Ask for the matrix to be reviewed by your identity team and by any customer owner who manages branding for their own organization.

What makes a Zitadel v4 upgrade take longer

This table lists the factors that most often lengthen a self-hosted Zitadel v3 to v4 upgrade, why each one adds work, and how to keep it contained. Read each row against your own estate to see which drivers apply to you. The main takeaway is that most of the effort happens before the upgrade window, in inventory, testing and change preparation.

DriverWhy it adds effortHow to reduce it
Integrations still calling v1 endpointsEach application, script or SDK call on a deprecated v1 endpoint must be found, moved to v2 and retested before cutover.Inventory every client with API logs and code search, then migrate and test them in a staging instance first.
Customer organizations and instances with custom brandingLogin V2 with custom branding must be tested per organization and instance, since each one has its own styling and text.Keep branding settings documented as code, and use a representative sample for visual and functional tests.
Federated identity providers and login flowsEach upstream provider, such as Entra ID, Okta or LDAP, needs its login path verified, including just-in-time user creation and attribute mapping.Build a test matrix per provider and flow, and confirm with each identity provider owner before the window opens.
Data and user volume in PostgreSQLLarger databases lengthen backup, restore rehearsal and setup time, and make rollback slower if a problem appears.Measure database size and user counts early, rehearse a full restore, and confirm supported PostgreSQL versions from 14 to 18.
Deployment methodA single binary, Docker Compose and a Kubernetes cluster with high availability each have different rollout, health check and rollback steps.Write a runbook for your exact method, and for high availability plan a rolling sequence that keeps instances serving.
Environments upgraded in sequenceDevelopment, test, staging and production usually follow a fixed order, so delays in one environment hold up the next.Agree the promotion order and entry criteria for each environment, and record the results of each stage.
Automation and infrastructure as codeHelm values, Terraform configurations and deployment pipelines may pin versions or settings that need review and changes.Pin the target version in code, review configuration diffs against the release notes, and test pipelines in a non-production environment.
Change control and audit evidenceApprovals, risk assessments, rollback plans and test records must be produced and retained for the change board or assessors.Agree the evidence list with your change board and auditors before work starts, and collect it during testing, not afterward.

Deciding whether to enable Service Ping after the upgrade

Decide whether Service Ping stays enabled before production cutover, and write the decision down. Before making that call, the team has to establish from the Zitadel v4 documentation what the setting is, whether any data is sent to Zitadel, how the setting is switched on or off in the configuration, and whether it can be disabled entirely. This page does not describe what Service Ping collects. The team should take that from the official documentation for the exact release it deploys. Record the answer to each of those questions in the upgrade ticket so the decision rests on the vendor's own text, not on memory or a secondhand summary.

The security and data protection owners should test the decision against two commitments: the outbound traffic policy and data residency. Ask the platform team to show the destination the instance would contact, the protocol, the direction of traffic, and the network path that would carry it. If the instance runs in a restricted or air-gapped network, an outbound call may be impossible to allow, and the team needs to know that before the cutover window. Confirm also whether any data sent could identify tenants, organizations or users, because that answer determines whether the data protection lead needs a formal assessment before approval.

Name one accountable approver, usually the security or platform owner with input from data protection, and state who may change the setting later. Keep the record where auditors can reach it. It should include the setting value in each environment, the documentation version consulted, the date, the approver and the reason for the choice. A short, dated decision record that quotes the exact configuration key or environment variable is more useful to an assessor than a general statement that telemetry was reviewed. Pair the record with an export of the effective configuration from the running instance, not only the intended configuration in source control.

Make the decision in staging first, using the same configuration template that production will use. Confirm the effective value after setup and after the first restart in each environment, since the value the instance reads is what matters, not the value the team meant to write. Schedule a review of the decision whenever the deployment changes in a way that affects outbound access or data handling, such as a new network path, a change in hosting region, a move to a different deployment method, or a change to the outbound policy. Note in the record that this review is a standing trigger, not a one-time sign-off.

How long does a Zitadel v3 to v4 upgrade take and what does it cost

How much does a Zitadel v3 to v4 upgrade cost?

The cost follows from the written scope. DeployOpen does not publish a price list, so the quote reflects the environments, integrations and branding work you agree to before the project starts.

The main cost drivers are:

  • the number of Zitadel instances and environments to upgrade
  • how many integrations still call deprecated v1 endpoints and need moving to the v2 APIs
  • how many applications use custom Login V2 branding that must be tested
  • whether Service Ping is in scope

Who is paid for what: DeployOpen charges for scoping, the staging build, integration migration and the branding test matrix. Your internal staff time for owners, approvals and testing is an internal cost. A support retainer, if you buy one, is a separate recurring fee. Ask for a quote that prices each part separately so you can see what is one-time and what recurs.

How long does a Zitadel v3 to v4 upgrade take to complete?

Duration depends on the same drivers as cost. The timeline is set in the written scope, and no fixed duration applies to every deployment. The largest variables are the number of integrations that need migration, how many environments must be built and tested before production, and how quickly your owners review test results.

The work usually runs in this order: scoping, a staging build with the new runtime, setup run before the new runtime starts, integration migration, branding and login testing, then a production change in an agreed window. Each stage depends on access and decisions from your team, so delays on the client side extend the schedule. Ask the partner for a plan with a stage-by-stage schedule and a named dependency on each stage, and confirm the release you are targeting with Zitadel's GitHub releases page before you set dates.

Can our own team upgrade Zitadel v3 to v4 without a partner?

Yes, if your team has the skills and the time to test. The upgrade is within reach of an internal platform team that already runs PostgreSQL, Kubernetes or Docker, because the work involves database and runtime changes, configuration updates and application-level testing.

The skills to confirm are PostgreSQL administration (Zitadel supports versions 14 through 18), container or Kubernetes operations, and familiarity with OpenID Connect integrations. The effort most teams underestimate is the integration inventory: finding every client that calls a v1 endpoint, moving it to the v2 APIs and testing sign-in in each application. Also plan for a rollback path and a change window. If any of these are missing, an outside partner can cover that part under a fixed scope.

What should a written quote for this upgrade include?

A useful quote lists the scope, the deliverables and the exclusions. Ask for each item below to appear as its own line so you can compare proposals on the same basis.

  • Scope: which instances, environments and Zitadel features are covered
  • Integration inventory: each application or API consumer, its current endpoints and its planned v2 migration
  • Test matrix: login flows, Login V2 branding variants, devices and identity providers tested
  • Rollback plan: the steps, the data checks and the decision point for returning to v3
  • Handover: runbooks, documentation and the knowledge transfer your team receives
  • Exclusions and retainers: what is out of scope and what recurring support costs separately

DeployOpen fixes scope and deliverables in writing before work starts, so the quote should match that document line for line.

Which parts of a Zitadel upgrade are one-time and which recur?

Most of the upgrade is one-time work, and later maintenance recurs. The one-time portion covers scoping, the staging build, migration of integrations to the v2 APIs and the branding test matrix. Once those are complete and production is stable, the project closes.

Recurring costs come from later patch upgrades, which you will need to apply as Zitadel publishes new releases, and from any support retainer you choose for ongoing operations, monitoring and testing. DeployOpen offers ongoing support, upgrades and continuous testing as retainers, and those are priced separately from the upgrade scope. Ask whether a future patch upgrade is included in the retainer or billed as a separate piece of work, and confirm how far back patch support extends.

What does our organization need to provide for the upgrade?

The upgrade depends on decisions and access from your side. Before the work starts, confirm who will provide each of the following:

  • Access: working access to staging and production, including the database and the Kubernetes or Docker hosts where Zitadel runs
  • API consumer owners: a named person for each application or service that calls Zitadel, who can confirm behavior and approve the change
  • Branding owners: the people who approve Login V2 themes, logos and text
  • Change window: an agreed production window with a rollback decision maker present

Missing owners are the most common reason integration testing stalls. Ask the partner to list these roles in the written scope so each one has an accountable person before the staging build begins.

Does the Zitadel Enterprise plan cover an upgrade project?

No. Zitadel's Enterprise support and the upgrade scope are separate purchases. Zitadel's pricing page states that the Enterprise plan offers custom support agreements and technical account management, and Zitadel sets those terms directly. That support relates to Zitadel's own assistance and account management. It does not replace a planned upgrade of your instances, integrations and branding.

For the upgrade, you still need someone to scope the work, build staging, migrate integrations and run the test matrix. Ask Zitadel what its Enterprise agreement includes, and separately ask DeployOpen for a quote based on your environments. Keep the two contracts distinct so each one has its own deliverables and owner.

How DeployOpen scopes, delivers and supports the upgrade

DeployOpen plans and runs the Zitadel v3 to v4 upgrade inside your own infrastructure, from the first environment inventory to post-cutover support. Engagements are fixed-scope, so the upgrade path, deliverables and timeline are agreed in writing before work begins. Every stage ties back to the four workstreams in this upgrade: setup before the new runtime, v1 to v2 API moves, Login V2 branding tests and the Service Ping decision.

How we scope

  • Inventory every Zitadel instance, database version, deployment method and Helm or Compose configuration in scope.
  • List every integration calling v1 endpoints, with its owner, traffic path and planned v2 replacement.
  • Agree in writing whether Login V2 branding and the Service Ping decision sit inside the fixed scope.

How we build

  • Run Zitadel setup against a staging copy of your PostgreSQL database before the new runtime goes live.
  • Move each v1 integration to the v2 APIs in version control, with contract tests against the new endpoints.
  • Test Login V2 with your custom branding across browsers, locales and each customer organization's sign-in path.

How we hand over

  • Deliver a runbook with setup steps, database backup checkpoints, rollback points and the agreed cutover order.
  • Document the v1 to v2 mapping for every integration, with owners and the verification evidence for each one.
  • Record the Service Ping decision, the reasoning behind it and the configuration you keep or change.

How we support

  • Provide ongoing support and upgrades as a retainer if you want the team available after cutover.
  • Review each new Zitadel release against your deployment and recommend whether and when to take it.
  • Confirm support terms, response expectations and included releases in the written agreement before work starts.

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.