openDesk upgrades and support

openDesk ships a new minor release every month and supports only the latest one, so upgrades are ongoing work. This page explains what an upgrade and support engagement covers, what drives its effort, and how to split it between your team and a partner.

On this page

Why openDesk upgrades and support are ongoing work, not a one-time project

openDesk upgrades and support are ongoing work because the project ships a new minor release every month and supports only the latest minor. A public-sector or regulated team running openDesk on Kubernetes cannot stay on an older minor and expect vendor support, so each monthly minor must be tested, approved and rolled out before the next one arrives. The work has no end date. It continues for as long as the deployment runs, and the planning should assume a fixed operating rhythm rather than a single go-live project.

Several triggers start this work. A new minor release is the most frequent, since minors arrive monthly under the published cycle. A breaking change in a bundled component, a patch release published on demand, a change to the Kubernetes or Helm requirements, and a security issue in a bundled component each start a separate piece of work. Skipping several minors may require intermediate upgrade steps, so a team that falls behind faces a larger change. The platform floor is also fixed: the cluster must run Kubernetes v1.33 or later, with Helm 3.17.3 or later below v4 and Helmfile 1.0.0 or later. A cluster upgrade can force an openDesk change, so both plans should be reviewed together.

Whether to run this in-house or with a partner depends on how many of these triggers your team can absorb in a normal month. The recurring steps include reading release notes, checking breaking changes against your own values and Helmfile configuration, staging each upgrade on a non-production cluster, running verification and keeping a tested rollback path ready. Ask any delivery partner to state in writing which of these steps it performs, which steps your team keeps, how it handles security patches, and how it documents each change for your change board.

The support model changes how much of this work falls on your team. The Community Edition is supported only by the community on openCode, with no SLA, so upgrade problems and security fixes depend on community responses and your own engineers. ZenDiS recommends the Enterprise Edition for production. It adds SLA-backed 2nd and 3rd level support and patches, including Nextcloud Enterprise security patches. Before you choose, confirm with ZenDiS which patches cover which bundled components, how fast patches are delivered, and what your responsibilities remain under each edition.

What an openDesk upgrade and support engagement includes

openDesk ships a new minor release each month, and only the latest minor is supported, so upgrades are a recurring operating task rather than a one-time project. The work below follows one change from planning through staging, cutover and documentation, and the deliverables stay with your team after the engagement ends.

Upgrade planning per minor and major

Each engagement starts by reading the release notes for the target minor or major and mapping them against your deployed versions. openDesk plans majors annually in Q3 and minors monthly, and in-place upgrades between majors are not guaranteed, so skipped minors may need intermediate steps. The plan records the upgrade path, the breaking changes that apply to your bundled components, and the order of work.

Helmfile and Helm changeset review

Before anything is applied, the Helmfile and Helm changes between your current and target release are reviewed line by line. The review covers chart and image version bumps, changed values, new or removed configuration keys and any change to resources that hold state. Ask for the diff as a written artifact so your team can check each decision.

Staging upgrades and regression checks

The upgrade runs first on a staging environment that mirrors your production configuration, including external PostgreSQL, MariaDB, Redis, object storage and SMTP. Regression checks then cover sign-in through your federated identity setup, file sharing, chat, groupware and the web office. Confirm with the provider which external service versions your target release expects before scheduling the staging run.

Production cutover and rollback preparation

Cutover is scheduled in a window agreed with your operations team, with a rollback path written before the change starts. The rollback plan states which Helm releases can be reverted, how database changes are handled and who signs off the decision to revert. Ask how backups are verified before the window opens, since a rollback is only as good as the last restorable copy.

Prerequisite tracking for the platform stack

Each release depends on the platform beneath it, so prerequisites are tracked separately from openDesk itself. The inventory covers the Kubernetes version, which must be v1.33 or later, the Helm and Helmfile versions, the ingress controller (haproxy-ingress or the deprecated Ingress nginx) and cert-manager. A prerequisite that falls behind is often the reason an upgrade stalls, so it is checked before staging begins.

Patch application on demand

Patch releases are issued on demand rather than on a fixed schedule, so they are applied through the same staging and regression path as minor upgrades. Each patch is matched to the bundled component it affects, such as Nextcloud or OpenProject, and to the license and support tier that governs its delivery. Ask whether your edition includes SLA-backed patches for the components you run, because Community Edition support is community-only.

Documentation of each change

Every change is recorded with the versions before and after, the changeset reviewed, the test results and the rollback status. These records, together with the runbooks and the version inventory, are handed over to your team at the end of the engagement. Confirm the format and storage location for these records at the start, so they can be audited without a dependency on the provider.

How the monthly minor cycle and single supported minor set the upgrade rhythm

The published cadence sets the upgrade rhythm for openDesk. ZenDiS plans major releases annually in Q3, minor releases monthly and patch releases on demand, and supports only the latest minor version. For a platform team, the supported target changes every month, so the upgrade window has to be planned around that cadence rather than around a version number that stays fixed. Start by deciding who owns the monthly check of the release list, who approves a move to a new minor, and how much staging time each upgrade needs before it reaches the production namespace.

The pace of the line is easy to underestimate. The latest release at research time was v1.19.1, published on 2026-10-06, and it followed v1.19.0 on 2026-10-01, less than a week earlier. A team that plans a quarterly change window may find that the version it tested is already outside the supported line when the window opens. Before any planning session, check the current release list in the openDesk releases on GitLab, record the newest minor and any patch on it, and confirm the date of that release so the plan starts from the live state, not from this page.

Staying on an unsupported minor is a decision with consequences that the team should confirm in writing before it makes that choice. A deployment on a minor outside the supported line may not receive fixes from the vendor, and support requests may be answered with a request to upgrade first. Ask ZenDiS or your support provider which support, patches and advice still apply to the version you run. Also ask whether your chart values, Helmfile state and bundled component versions can be brought forward without a full reinstall, because the cost of a delayed upgrade often grows with each skipped minor.

Upgrades between major releases carry more risk than monthly minor moves. In-place upgrades between majors are not guaranteed, and skipping several minors may require intermediate steps. Before committing to a jump, read the release notes for every minor in the path, confirm with the vendor whether a direct path exists, and rehearse each step in a staging cluster that matches production's Kubernetes version, external PostgreSQL, Redis and object storage settings. Record the result of each rehearsal so the production change follows a tested sequence instead of an assumed one.

What drives openDesk upgrade effort and how to keep each driver down

This table lists the factors that change how much work an openDesk upgrade takes, why each one matters, and what to do to keep it under control. Read it before you set a release cadence, because most drivers compound: a deployment that is several minors behind, with custom values and many external services, is the hardest to move forward.

DriverWhy it changes effortHow to reduce it
Minor releases behindOnly the latest minor is supported, and skipping several minors may require intermediate upgrade steps, so the gap sets how many releases must be tested in sequence.Adopt a monthly minor upgrade rhythm in a non-production environment first, and confirm with ZenDiS which intermediate steps apply to your gap.
Bundled components enabledEach enabled component (for example Nextcloud, OX App Suite, XWiki, OpenProject, Element, CryptPad, Jitsi, Collabora) adds its own release notes, migrations and regression checks.Enable only the components your rollout needs, and record which ones are in use so each upgrade test covers the right set.
Custom Helm values and overridesLocal overrides can conflict with changed chart defaults or renamed keys, and each override must be reviewed against every new release.Keep overrides minimal, store them in version control, and diff rendered manifests against the previous release before each upgrade.
Enterprise-only features in useFeatures such as GroupSync, Admin Console, the Guard app and advanced search depend on Enterprise modules and license files, so upgrades must confirm entitlement and compatibility.Confirm which Enterprise features are licensed and active, and ask for the compatibility notes that accompany each Enterprise release.
Environment countEach environment (test, staging, production) needs its own upgrade run, validation and rollback check, so effort multiplies with the number of environments.Keep environments built from the same Helmfile state and promote the same tested release through them in order.
Kubernetes and ingress version changesopenDesk requires Kubernetes v1.33 or later and an ingress controller (haproxy-ingress or the deprecated Ingress nginx), so cluster or ingress upgrades can force openDesk changes too.Plan cluster and ingress upgrades as separate, sequenced changes. If you still run Ingress nginx, confirm your migration path to haproxy-ingress with ZenDiS before the cluster moves.
External services (PostgreSQL 15, MariaDB 10, Redis 7, object storage)Production expects external services at specified versions, so a change in database engine, version or storage backend needs its own migration and compatibility test.Track the required versions in a service inventory, schedule database and storage changes separately from openDesk releases, and test backup restore before each change.
Identity federation changesChanges to the external IdP, OIDC client settings, attribute mapping (for example username or mailPrimaryAddress) or the Nubus Directory Importer can break login after an upgrade.Record federation settings, test sign-in and attribute matching in staging after every release, and coordinate changes with the identity team.
Users who must retestAcceptance testing scales with the number of user groups and workflows that must be checked after each change, including mail, files, chat and office editing.Maintain a short, owned test script per bundled service, and use pilot groups to test each release before the full user base.

How an openDesk minor upgrade runs from release review to production

This sequence moves an openDesk minor release from review to production in a fixed order, so every change is checked in staging before the production window opens. Each step closes with a written output the client keeps. Timing depends on the client's own change windows and approvals.

  1. Review release notes against the deployment

    DeployOpen reads the release notes and changelog for the target minor version and compares them with the versions of each bundled component in use, such as Element, Nextcloud, OX App Suite and Nubus. The team lists every minor version between the current and target release, because openDesk's release management notes that skipping several minor versions may need intermediate steps. Output: a written version gap list agreed with the client's platform owner before any change is planned.

  2. Confirm prerequisites before any change

    DeployOpen checks the cluster against openDesk's requirements: Kubernetes at v1.33 or later, Helm 3.17.3 or later below v4, Helmfile 1.0.0 or later, an ingress controller, cert-manager and an RWO volume provisioner. If the target release raises a requirement, the gap is recorded and resolved before staging begins. Output: a signed prerequisite checklist that shows each item as met, with the version reported by the cluster or tool.

  3. Analyze changesets and breaking changes

    The team reviews the changeset between the current and target versions, including chart value changes, image updates, removed or renamed settings and any manual migration steps the release notes describe. Each item is classed as no action, configuration change or blocking issue, and blocking issues go to the client's platform owner for a decision. Output: a change register listing each affected component, the configuration updates required and the owner of each decision.

  4. Upgrade and verify in staging

    The upgrade is applied first to a staging environment that mirrors production as closely as the client allows, including its external PostgreSQL, MariaDB, Redis, object storage and SMTP relay where those are in use. During the run, DeployOpen verifies that container images are pinned by tag and digest and that Helm charts validate against the expected GPG keys, as openDesk's security documentation describes. Output: a staging upgrade log with image and chart verification results attached.

  5. Run functional and integration regression tests

    The team runs functional tests on each bundled application and integration tests across them. These cover chat, files, groupware, office documents, the portal, login through the openDesk IdP and any federation with the client's existing identity provider. Failures are triaged against the change register, and fixes are retested in staging before production is considered. Output: a regression report listing passed, failed and accepted-risk cases, each with a named approver.

  6. Agree the production change window and rollback path

    The change window and approvals come from the client, and their timing depends on the client's change calendar, governance board and any public-sector sign-off steps. DeployOpen prepares the production change record, including the exact upgrade steps, a backup taken and verified before the window, and a rollback path that has been tested in staging. Output: an approved change record with the rollback procedure and named decision makers.

  7. Execute the production upgrade and verify

    During the approved window, the upgrade runs in the order proven in staging. The team checks the health of each application and repeats the critical integration tests from the regression suite against production. If a critical check fails, the rollback path is used and the decision is recorded in the change record. Output: a post-upgrade verification checklist, signed by the client, that confirms the version running for each component.

  8. Hand over the upgrade and confirm support scope

    DeployOpen hands over the release notes, the change register, staging and production logs and updated runbooks. The handover also records the support boundary for the edition in use. openDesk supports only the latest minor version, and Community Edition is supported by the community on openCode without an SLA, while Enterprise Edition includes SLA-backed support. The client should confirm which applies before the handover closes. Output: a handover pack accepted by the client's operations team.

Community versus Enterprise: who answers when an upgrade breaks

The support model decides who answers when an openDesk upgrade breaks, so settle it before the first production upgrade and before an incident forces the question. Community Edition is supported only by the community on openCode, and that support carries no SLA. No one is contractually obliged to respond, to help diagnose a failed Helmfile run or to deliver a fix by a set date. Because openDesk supports only the latest minor version, a community answer may also arrive after you have already needed to move to a newer release. Community Edition can suit evaluation and non-production work, but you should document in writing which team in your organization owns any failure.

Enterprise Edition uses the same open-source core licenses as Community Edition, but it adds closed-source modules, an Enterprise-only registry and a license file that your deployment must present. It also includes SLA-backed 2nd and 3rd level support and patches, and it is sold as SaaS or for on-premises installation. For upgrade work, the registry and license file become dependencies of your deployment pipeline. Confirm with the vendor who issues the license, how credentials are rotated, what response times apply to each severity level, and whether the SLA covers every bundled component or only some of them.

Several Enterprise-only features touch upgrade work directly. Collabora automatic load scaling, Element AdminBot, GroupSync and Admin Console, Nextcloud Enterprise security patches and the Guard app, OX S3 storage and advanced full-text search, OpenProject Enterprise add-ons and XWiki Pro apps each bring their own configuration, images or dependencies. A Helmfile values set that is correct for one edition may therefore need changes for the other. Before you choose an edition, list which of these features your rollout needs, and ask the vendor which of them change between the minor releases you plan to take.

ZenDiS recommends Enterprise Edition for production use. Your organization must confirm licensing and support terms directly with the vendor, including who is entitled to open tickets and which versions are covered. A partner retainer can cover upgrade execution, testing and operations, but it does not replace vendor support unless the contract says so. Ask for a written responsibility split that names who triages a failed upgrade, who escalates to 2nd and 3rd level support, and who approves a rollback decision before the maintenance window opens.

What goes wrong in openDesk upgrades and how to prevent it

Most openDesk upgrade failures trace back to a short list of causes: versions that drift apart, changes never tested against the client's own configuration, and production changes that bypassed a rehearsal. Each card below names one cause and the check that prevents it.

Falling more than one minor behind

openDesk releases a minor version monthly and supports only the latest minor. A deployment that skips several minors may need intermediate steps described in the release documentation, so an upgrade planned from an old baseline can stall partway through. Before each cycle, record the deployed minor, list every minor released since, and read the upgrade notes for each one. Confirm the path with ZenDiS release documentation or your support provider before scheduling the change window.

Untested changes in custom Helm values

Client overrides in Helm values files are the part of the deployment that no release tests for you. A new chart version can rename a key, change a default or remove an option, and the failure appears only after the new values are applied. Render the manifests for the current and target versions using your own values and compare the differences before the upgrade. Keep overrides in version control so every change is reviewed and attributable to a person and a reason.

Platform prerequisites below supported versions

openDesk requires a CNCF-certified Kubernetes cluster at v1.33 or later, Helm 3.17.3 or later below v4, and Helmfile 1.0.0 or later. Clusters often drift below these minimums during routine node or operating system maintenance. The deprecated Ingress nginx controller also needs a planned move to haproxy-ingress or another supported controller. Check external services such as PostgreSQL 15, MariaDB 10 and Redis 7 against the requirements before each upgrade, because a version mismatch there can break a release that works on paper.

Unverified image digests and chart signatures

openDesk signs and validates most Helm charts against GPG keys, pins every container image by tag and digest, and signs the images it builds with cosign. An upgrade step that skips these checks, or a mirror that rewrites digests, can pull an artifact that differs from the released version. Make verification a gated step in your pipeline: confirm chart signatures and image digests match the release notes, and treat any failed check as a stop condition. A warning should not allow the deployment to proceed.

Identity changes breaking logins

Sign-in depends on the Keycloak-based openDesk IdP, OIDC federation with your existing identity provider, and the Nubus Directory Importer for LDAP or Active Directory. A release that changes the IdP configuration or directory handling can break sign-in even when every pod reports healthy. Before upgrading, test a federated login and a directory sync in staging. Confirm that the matching attribute, such as username or mailPrimaryAddress, still resolves to the same account for every user group.

Production patches without staging or rollback

A patch applied straight to production has no tested fallback if it fails. Rehearse each upgrade in a staging environment built from the same chart versions, values and external service versions as production. Before the change window, write down the rollback procedure, confirm backups of persistent volumes and external databases exist, and test that a restore works. Agree in advance who makes the rollback decision and the time by which it must be made.

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

This table shows who usually owns each recurring upgrade and support task for openDesk, and which skills that task needs. Read it as a starting split to confirm with your own platform and security teams, since the right owner depends on your Enterprise or Community choice, your change control process and how many bundled components you run. The main takeaway is that release triage and Kubernetes work tend to stay with your team, while staging regression tests and vendor escalation are where a partner or the vendor adds the most.

TaskUsual ownerSkills required
Subscribing to release notes and triaging impactIn-houseApplication administration for each bundled component, reading Helm changelogs, knowledge of which components your users rely on
Helmfile and Helm changeset reviewSharedHelm and Helmfile, Kubernetes operations, reviewing chart value changes and image tag and digest pins
Staging upgrade and regression testingPartner or sharedHelm and Helmfile, application administration for each bundled component, test scripts for login, mail, chat and file flows
Production cutover in change windowsIn-house with partner supportKubernetes operations, Helm and Helmfile, identity and directory administration, rollback planning
2nd and 3rd level vendor escalationVendor under Enterprise, community under CommunityLog analysis, sufficient detail to reproduce faults, clear description of impact and affected components
Kubernetes platform upgradesIn-house platform teamKubernetes operations, cluster lifecycle tooling, checking compatibility with the required Kubernetes version and bundled ingress and cert-manager
Ongoing patch and version inventorySharedHelm and Helmfile, application administration for each bundled component, tracking of image tags and digests across environments

What your team must provide before an upgrade or support engagement starts

Before any upgrade or support engagement can be scoped, your team needs to make a set of inputs available. The most important of these is read access to the Helmfile environment and values repository, because the deployed state of openDesk is defined there: the environment files, the values overrides for each bundled application, and the pinned chart and image versions. Without it, a partner can only guess at what is running today. Confirm where that repository lives, who owns it, and whether the environment files reflect what is actually deployed or have drifted through manual changes. Second, the operator role needs cluster access. openDesk requires a CNCF-certified Kubernetes cluster at v1.33 or later, and the work touches the ingress controller, cert-manager, the RWO volume provisioner and the namespaces that hold each component. Confirm which of these your platform team can grant to a named operator role, under what approval, and whether production access is separated from staging. Also confirm that the Helm version in use is 3.17.3 or later but below v4, and that Helmfile is at 1.0.0 or later, since both affect how the upgrade is executed. Third, a staging environment that mirrors production is needed to rehearse each upgrade. A staging system that differs in external services, such as PostgreSQL 15, MariaDB 10, Redis 7, the SMTP relay, ClamAV over ICAP, object storage or the TURN server, can hide the very breaking changes the rehearsal is meant to catch. Ask whether the staging cluster runs the same external service versions as production and whether its data can be refreshed from production on a schedule your change process allows. Fourth, supply test accounts and a written test plan that covers the bundled applications your users depend on, such as Element, Nextcloud, OX App Suite, XWiki, OpenProject, Jitsi and Collabora. Pair these with the change calendar, the approval owners who can sign off a release window, and a current version inventory listing the deployed openDesk release and each component's version. Document the versions of the external services as well. Confirm the identity provider and directory configuration, including any OIDC federation and the Nubus Directory Importer settings, so the test accounts reflect real sign-in paths. Finally, name one owner for each bundled application who can answer functional questions and accept the result of testing. Before requesting a quote, walk through this list and mark each item as existing, partly existing or missing. Items that are missing usually add effort to the engagement and should be named in the written scope.

Questions buyers ask before hiring help for openDesk upgrades

How much does ongoing openDesk support cost?

Ongoing support is priced from a written scope, so the cost depends on what you ask a partner to cover. Four components usually make up the bill: partner time for tracking releases and planning upgrades, time to execute and test each upgrade in staging and production, the infrastructure for a staging environment that matches production, and any openDesk subscription you choose. The subscription is billed by ZenDiS and sits separately from partner fees. Recurring costs follow the monthly minor release cycle, while onboarding, runbook creation and an initial review of the environment are usually one-time. Costs rise with the number of bundled components in use, the amount of customization, the number of external services such as PostgreSQL, Redis and object storage, and the number of environments you run. Ask for a quote that separates one-time and recurring items and lists what is excluded.

How long does a minor openDesk upgrade take?

Duration depends on the target release and your environment, so no fixed figure applies to every deployment. Start with the release notes for the target minor version, since they list the changes that affect configuration. The main drivers are the number of bundled components that change, whether the release contains breaking changes that need configuration edits, how much customization sits in your Helmfile values, the size of the cluster and its external services, and how much testing your users and security team require before cutover. Teams with version-controlled configuration and a staging cluster that matches production usually move faster than teams that edit live values by hand. Ask any partner to estimate time against a named target version and a written component list, and to state which tests are included.

Can our own team upgrade openDesk without outside help?

Yes, a capable platform team can run openDesk upgrades alone if it has the right inputs and skills. You need the release notes for every minor version you pass through, a staging environment that mirrors production, and a tested rollback path. The skills include Kubernetes operations, Helm 3.17.3 or later below v4, Helmfile 1.0.0 or later, and familiarity with how openDesk is configured and which external services it depends on. Your team also needs capacity for the monthly cycle, because only the latest minor version is supported and each upgrade requires testing. A common split is to keep routine minor upgrades in-house and bring in a partner for annual major releases, incidents or a first upgrade on an unfamiliar environment. Decide which parts you own before the first upgrade is scheduled.

What happens if we skip several openDesk releases?

You may not be able to jump straight to the newest version, so plan the upgrade path before you start. openDesk supports only the latest minor version, and skipping several minor versions may require intermediate steps. The release management documentation defines those steps, so read the notes for each version between your current release and the target. In-place upgrades between major versions are not guaranteed, so a move across a major release should be treated as a separate project with its own review and a test run in staging. Begin by recording the deployed version of every bundled component, then compare that list with the current release. For a production estate, confirm the exact path with ZenDiS or your support provider before you schedule the change.

Do we need openDesk Enterprise Edition for production?

ZenDiS recommends openDesk Enterprise Edition for production, but the decision should follow your risk and support requirements. The Community Edition is supported only by the community on openCode, with no SLA. Enterprise uses the same open-source core licenses, adds closed-source modules, and requires its own registry and license file. It includes SLA-backed second and third level support and patches, and it is sold as SaaS or for on-premises installation. Some Enterprise-only features, such as Nextcloud Enterprise security patches with the Guard app and GroupSync with the Admin Console, change how you operate the suite. Before you decide, confirm in writing with ZenDiS the support terms, response commitments, patch timing, license scope and pricing, since these terms can change and are not set by DeployOpen.

What does an upgrade partner need from us to start?

A partner needs an accurate picture of your current environment and an agreed way to make changes. The usual readiness list includes:

  • A Kubernetes cluster at v1.33 or later with the required ingress controller, cert-manager and RWO volume provisioner
  • Helm and Helmfile versions that meet the requirements
  • The deployed openDesk version of every bundled component
  • Your Helmfile values and any customizations in version control
  • A staging environment that matches production
  • Versions and backup status for PostgreSQL, MariaDB, Redis, object storage and the other external services
  • Named owners and approvers for each change
  • Access through approved channels and agreed maintenance windows
  • Written rollback criteria for each upgrade
What documentation do we keep after an upgrade engagement?

You keep the documentation produced during the engagement, and the exact list should be written into the scope before work starts. Typical deliverables include upgrade and rollback runbooks, an inventory of every bundled component with its version, configuration held as code, change records for each upgrade, test evidence, notes on breaking changes and the decisions behind them, and a list of open issues with owners. A record of the upgrade path taken is useful when the next release is planned. Ask for these items to be stored in your own repositories and document systems rather than in a partner's tools, so your team can run the platform without the partner. Confirm the format, storage location and handover steps in the written scope.

How DeployOpen scopes, delivers and supports openDesk upgrades

DeployOpen plans, implements, upgrades, documents and supports self-hosted open-source platforms inside the client's own infrastructure, and openDesk upgrades follow the same written-scope approach. Each upgrade starts from the release your installation runs today, the release you target and the path between them, so the work is defined before anything changes in your cluster.

How we scope

  • Inventory the current openDesk release, Helmfile state and bundled component versions before agreeing a target.
  • Map the upgrade path, including any intermediate minor releases needed when several minors are skipped.
  • Review breaking changes in the release notes for each component and list the configuration changes they require.
  • Confirm the Kubernetes version, ingress controller, cert-manager and Helm versions against openDesk's stated requirements.

How we build

  • Run the upgrade first in a non-production environment that matches your cluster, external services and identity setup.
  • Apply Helmfile changes in a reviewed, version-controlled sequence and record each deviation from the defaults.
  • Test login, federation, mail, file sync, chat, document editing and video calls against a written acceptance list.
  • Verify image and chart signatures and pinned digests for every release applied, and capture the results as evidence.

How we hand over

  • Deliver a runbook covering the upgrade steps, rollback points, and the commands your operations team will repeat.
  • Document the environment as built, including the release, component versions, configuration overrides and external service endpoints.
  • Walk your operations team through the upgrade in a working session and agree who signs off each production change.
  • Hand over the test scripts and checklists so your team can repeat verification on the next monthly minor release.

How we support

  • Offer ongoing support, upgrade and continuous testing as a retainer, agreed in writing alongside the upgrade scope.
  • Track each new monthly minor release against your environment and plan the next upgrade window with you.
  • Confirm with ZenDiS which support tier applies to your edition, since Community support has no SLA and Enterprise support is SLA-backed.

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.