Jitsi upgrades and support

Self-hosted Jitsi Meet needs its web app, Prosody, Jicofo and videobridges kept on matching stable releases and tested before each change reaches users. This page explains what upgrade and support work includes, what drives its cost, and what you provide.

On this page

Who keeps Jitsi upgrades and support running after go-live

Keeping a self-hosted Jitsi Meet current without disrupting meetings is usually a recurring operations task, not a one-time project. Many teams keep routine patching and restarts in-house and bring in a partner for release testing and larger version jumps, where configuration changes and browser behavior are more likely to break a working setup. The useful question for your organization is which of those tasks your own team can staff on a steady schedule, and which ones need someone who has already tested the upgrade path.

A Jitsi Meet deployment is several components that must run compatible versions together. The web server (nginx or Apache) serves the web application. Prosody is the XMPP server that handles signaling and accounts. Jicofo, the conference focus, allocates conferences and coordinates media. One or more Jitsi Videobridge instances route the audio and video. Optional Jibri (recording and streaming) and Jigasi (SIP dial-in and transcription) add their own moving parts. If the web app, Prosody, Jicofo and the bridges drift apart on releases, users may see failed joins or missing media, and the fault can look like a network problem. Before any upgrade, confirm which stable release each component is on and whether your plan covers every host that runs one.

The upgrade path depends on how you installed Jitsi. The Debian and Ubuntu packages and the official Docker setup each have their own update mechanics, and the Docker setup separates web, prosody, jicofo, jvb, jigasi and jibri into individual containers. Ask your team or your partner to document the exact commands, the order of restarts, the rollback method and the config files that survive an update. Check the supported operating system versions in the quick start (Debian 12 or newer, Ubuntu 24.04 or newer) against your host baseline, because an operating system upgrade can force a Jitsi upgrade at the same time.

Browser compatibility changes are a separate risk from server upgrades. Jitsi Meet relies on current browser media APIs, and end-to-end encryption is available only in Chromium 83 or newer browsers and the Jitsi Electron client, and only for audio, video and screen sharing. A server release that works in your test browsers can still behave differently for users on older or managed desktops. Build a short test matrix covering the browsers and devices your staff actually use, and repeat it for every release you consider.

Ongoing support should be defined in writing before go-live. Ask any provider, including DeployOpen, which of these are included: monitoring of the services, scheduled patching, release testing before rollout, incident response hours, changes to authentication or recording settings, and documentation updates. DeployOpen plans, implements, hardens, backs up, upgrades, documents and supports self-hosted open-source platforms inside the client's own infrastructure, and ongoing support, upgrades and continuous testing are available as retainers. Confirm the response expectations and the upgrade cadence in the written scope rather than assuming them.

What Jitsi upgrades and support cover

Each upgrade follows the same path: record what is running, move every component to matching stable releases, test the change, check the live service and hand over documents your team can reuse. Ongoing support is offered as a retainer, with the scope agreed in writing before work starts.

Inventory of the running deployment

Before anything changes, we record every running component: the web server, Prosody, Jicofo, each videobridge and any optional containers such as Jibri or Jigasi. The inventory covers installed versions or image tags, configuration files, TLS certificates, DNS names and open ports. Compare it with your own change records, because bridges configured by hand at different times often differ in ways the documentation does not show.

Matching stable releases across components

Jitsi Meet publishes stable releases tagged by build number, for example stable/jitsi-meet_11248, so the web app, Prosody, Jicofo and videobridges should move to builds that were tested together. Running mixed versions across these components is a risk to plan for, so confirm the target set in the release notes before scheduling. Ask for the exact target build in the written scope.

Upgrade testing on Docker or Debian packages

Rehearse each upgrade on a staging copy that matches production, installed from Debian packages or from the official Docker images. The Debian and Ubuntu quick start supports Debian 12 (Bookworm) or newer and Ubuntu 24.04 or newer, and it requires OpenJDK 17, so check the host operating system and Java version first. Docker deployments from stable-11146 run rootless with read-only filesystems, which changes how volumes and file writes behave during the test.

Post-upgrade checks on the live service

After cutover, confirm that the ports the service depends on are open: 80/TCP, 443/TCP and 10000/UDP, plus 5349/TCP and 3478/UDP if you use TCP fallback and STUN. Confirm the certificate is valid for your domain, since the handbook warns that self-signed certificates cause audio and video problems, especially on mobile clients. Then join test meetings from several browsers and devices with audio, video and screen sharing, and run each authentication path your users depend on.

Browser and encryption compatibility changes

Browser releases can change how Jitsi Meet media and features behave, so each upgrade includes a compatibility pass on the browsers your users run. End-to-end encryption is available in Chromium 83 and later browsers and the Jitsi Electron client, and it covers audio, video and screen sharing only, so chat and polls fall outside it. Record which clients were tested and where gaps remain, so the support team knows which combinations are covered.

Runbook, configuration record and test log

Each engagement ends with three deliverables: an upgrade runbook with steps, owners and rollback points, a configuration record of the deployed components and settings, and a test log listing each check, its result and who ran it. Your team keeps these documents after the engagement ends, so the next upgrade does not depend on the people who performed this one. Confirm the document formats and storage location in the quote.

What drives the cost of Jitsi upgrades and support

This table lists the factors that change how much work each Jitsi upgrade and support cycle takes, why each one matters, and what the client can do to keep it manageable. Use it to see which parts of your environment will raise the scope of a quote, and to decide which choices to standardize before asking for one. Costs are not estimated here; the quote follows from the written scope.

DriverWhy it changes effortHow to keep it down
Install methodDocker deployments run separate web, prosody, jicofo, jvb, jigasi and jibri containers, while Debian or Ubuntu installs use system packages. Each method has its own upgrade path and failure modes.Standardize on one documented install method and record every deviation from the vendor defaults.
Number of videobridges and host spreadEach videobridge is a separate media router that must run a matching release. More bridges, especially across several hosts, multiply the checks after each upgrade.Keep bridge builds identical through configuration management and confirm all bridges reconnect after each change.
Optional components enabledJibri, Jigasi, Etherpad and the Excalidraw whiteboard each add services, configuration and dependencies that must be tested alongside the core release. Jibri also needs its own host or VM.Enable only the components the business needs and track each one as a named item in the upgrade test plan.
Authentication setupInternal XMPP accounts, JWT tokens, LDAP and Matrix-based verification each depend on different settings in the .env file and external systems. A release can change how these interact with the identity provider.Document the chosen mode and test login, token issuance and guest access for each mode before every upgrade.
Number of environments to testEach environment (development, test, production, and any pilot) needs its own upgrade rehearsal, configuration check and browser test pass. Work scales with the number of environments, not only with the production size.Maintain one standing test environment that mirrors production topology and run every release through it first.
How far the current release is behindJitsi Meet stable releases are tagged by build number, so a long gap can cross several configuration and dependency changes at once. Larger gaps usually mean more regression testing and more reading of release notes.Schedule regular, small upgrades on a set cadence instead of waiting for a security or feature need.
Browser compatibility changesBrowser updates can change how Jitsi Meet behaves for audio, video, screen sharing and end-to-end encryption, which is supported in Chromium 83+ browsers and the Electron client. Each browser change may need a retest.Keep a short browser matrix of the versions your users run and repeat it after each release and each major browser update.
Compliance evidence requirementsAssessors may ask for change records, test results, configuration baselines, patch history and proof of access controls. Producing this evidence for each upgrade adds documentation work on top of the technical change.Agree the evidence list before the first upgrade and generate it as part of each change. DeployOpen prepares evidence; auditors and certification bodies assess it.

How a Jitsi upgrade project runs, phase by phase

The sequence moves from an inventory of what is running today to a tested, documented upgrade in production. Each phase produces a written record that the next phase depends on, so the change can be reviewed, repeated and reversed if something goes wrong. Most of the risk sits in the first two phases, where the team finds out which versions and settings are actually in use.

  1. Inventory current versions and configuration

    The team records how Jitsi runs today: the install method (Docker or Debian packages), the release of each component, and every local setting. For Docker, the list shows the web, prosody, jicofo, jvb, jigasi and jibri containers separately, plus the certificate chain and its expiry date, the authentication method and the open ports. The output is an inventory list naming each component, its version, each local change and an owner. The step closes when your platform owner confirms the list matches what is running.

  2. Select the target release

    Your team and DeployOpen choose the target from the stable releases in the jitsi-meet repository, reading the release notes for changes to configuration, browser support and the Docker layout. Components move together, so Jitsi Meet, Prosody, Jicofo and the videobridges should be on matching stable releases. Reviewers also check whether the container security behavior introduced at stable-11146 is affected. The output is a release decision record with the chosen tag, the reasons and the configuration changes it requires. The step closes when the service owner approves it.

  3. Build a test environment with the same install method

    Build a test environment with the same install method as production, including the operating system, Docker images or Debian packages, Java runtime, reverse proxy and certificate approach, so the test reproduces production. For Debian and Ubuntu installs, the Jitsi quick start lists Debian 12 or newer, Ubuntu 24.04 or newer, and OpenJDK 17. The team restores the current configuration from the inventory and confirms the test host is reachable on the same ports. The output is a build record comparing test and production component versions and settings. The step closes when the two match apart from hostnames and credentials.

  4. Rehearse the upgrade and verify containers

    Run the upgrade in the test environment from the documented steps, recording each command and its output. For Docker, the rehearsal confirms that the web, prosody, jicofo, jvb, jigasi and jibri containers start, communicate and restart cleanly. Containers have run rootless with read-only filesystems since stable-11146, so the test must confirm that this behavior still holds after the change, including any write paths the new release needs. The output is a rehearsal log with errors and every deviation from the runbook. The step closes when a second engineer can repeat the upgrade from the log without help.

  5. Run a user-facing test window

    Invite a small group of pilot users to join test meetings on the upgraded environment, using the browsers and devices your staff use. Testing covers audio and video, screen sharing, lobby and authentication flows, and the certificate chain as each browser sees it, because the Jitsi handbook says working audio and video needs HTTPS with a proper domain certificate. Self-signed certificates cause problems, especially on mobile clients. The output is a test matrix showing browser, device, result and defect reference for each case. The step closes when the owner accepts open defects as known issues or fixes them before cutover.

  6. Upgrade production with a rollback plan

    Schedule the change with the affected users and freeze other changes to the same hosts. Before starting, back up the configuration, the .env file and any certificates, and write down the exact rollback steps for each component, including how to restore the previous images or packages. Apply the upgrade in the order given in the runbook, then repeat the test window smoke tests against production. The output is a change record with the smoke test results and notes on whether any rollback step was used. The step closes when the smoke tests pass and the owner signs the change record.

  7. Hand over runbook, support and ownership

    Deliver the updated inventory, runbook, release decision record, test matrix and change record to your team, then walk through monitoring, backup checks and the process for the next upgrade. Confirm who owns each component after the change and how issues reach support, including whether ongoing support is retained under a DeployOpen retainer. Credentials and access move only through your secret management process. The output is a handover pack and a signed ownership list. The step closes when your team runs the rollback steps in the test environment without assistance.

Browser compatibility changes that Jitsi support has to watch

An upgrade of a self-hosted Jitsi Meet deployment is not only a server change. The web app that users load runs inside their browser or the Jitsi Electron desktop client, so a release can change how meetings behave on machines you never touch. Support staff need to treat the browser and client matrix as part of every upgrade, not as something that only the people building the server have to think about. Before each release, confirm the current browser matrix with the Jitsi project, since compatibility statements can move between versions.

End-to-end encryption is one area where client differences matter. Per jitsi.org, Jitsi Meet offers end-to-end encryption in Chromium 83 or later and in the Jitsi Electron client. It covers audio, video and screen sharing, and it does not cover chat or polls. Support should therefore not assume that a user on Firefox, Safari or an older Chromium build gets the same protection, and should not describe encryption to users in general terms. Testing should include the browsers and client versions your users actually run, collected from your device inventory or from the browser reports your identity or endpoint tools already provide, plus at least one check that confirms encryption status is shown when a meeting is joined in a supported client.

Certificates are the most common source of browser-side failure after an upgrade. The Jitsi handbook states that HTTPS with a proper domain certificate is necessary for working audio and video. Self-signed certificates cause problems, and the handbook specifically warns that mobile clients are the most affected. A user may see the page load and still get no camera or microphone, so a certificate problem can look like a media fault. Put certificate expiry dates, the renewal method and the certificate chain on the support checklist, and test joins from a phone on the corporate network as well as from a desktop. Confirm with your certificate authority or internal PKI team how renewals are automated, because a lapsed certificate will break every client at once.

Browser policy changes are the second recurring risk. Browser vendors change permission prompts, autoplay rules, cookie handling and the way they treat insecure content, and any of these can affect camera, microphone or screen sharing access inside a meeting. Support should keep a short register of the browser versions in use, the policy changes announced for them, and the managed settings your organization pushes, such as permission allowlists for the Jitsi domain. When a browser release is announced, run the join test scripts against it in a staging environment before users are moved to it. Where the Jitsi release notes and the browser vendor notes disagree, treat the failing test as the authority and raise it with the Jitsi project.

Finally, write the support runbook so that a browser-related ticket is triaged in a consistent order: confirm the browser and client version, confirm the certificate is valid for the domain the user opened, check the permission state in the browser, and only then escalate to the server team. This order matters because most reports that look like a server fault after an upgrade turn out to be client or certificate issues. Record each result in the ticket so that the next upgrade test can reuse the same checks, and agree with the internal IT owner who approves browser policy changes before the next release goes live.

What goes wrong in Jitsi upgrades and how to prevent it

Most Jitsi upgrade incidents trace back to a small set of repeatable causes: components on different builds, changed defaults, host baselines that drift, and certificates or firewall rules nobody re-checked. Each card pairs one failure with the control that prevents it, so the upgrade runbook can name a specific check for each risk.

Videobridge and Jicofo version drift

A partial upgrade can leave Jitsi Videobridge on one stable build and Jicofo or Prosody on another, and conferences may then fail in ways that are hard to trace to the version mismatch. Pin Jitsi Meet, Prosody, Jicofo and every videobridge to the same stable build tag, upgrade all components in one change window, and record the build number of each host in your change log. Confirm the release pairing in the release notes for the build you select before you begin.

Silent configuration changes in new releases

A new release can change a default configuration file, and the change may not be called out in a way your team notices before restart. Keep your overrides in version control, and diff the new release's default files against your current configuration before each upgrade. Review every changed key, decide whether your override still applies, and test the result in a staging environment that mirrors production.

Base operating system below the supported floor

The Debian and Ubuntu quick start supports Debian 12 (Bookworm) or newer and Ubuntu 24.04 or newer, and it requires OpenJDK 17. A host that was built on an older release, or that was upgraded only partly, may fall below this floor and fail during the next Jitsi update. Check the OS release and the installed Java version on every host as part of the pre-upgrade baseline, and confirm the current requirements in the quick start before planning the change.

Media path blocked after a host rebuild

The quick start requires 10000/UDP for media, along with 80/TCP and 443/TCP, and rebuilt hosts often come back without the firewall rules that were applied by hand. Users then join a meeting, see the interface load, and hear or see nothing. After every rebuild or upgrade, run port tests from outside your network to each videobridge on 10000/UDP and to the web endpoints on 80/TCP and 443/TCP, and store the results with the change record.

Expired certificate found during a meeting

The Jitsi handbook states that HTTPS with a proper domain certificate is necessary for working audio and video, and it warns that self-signed certificates cause problems, especially with mobile clients. An expired certificate therefore stops meetings for everyone at once, often at a time nobody planned for. Monitor the expiry date of every certificate that the web server uses, automate renewal where your certificate authority allows it, and set alerts well before the expiry date so the renewal is a scheduled task.

Jibri sharing a host with other workloads

Jibri records or streams a conference by running Chrome in a virtual framebuffer and encoding with ffmpeg, which is CPU and memory intensive. The Jibri README states that one recording at a time is supported on a single Jibri and that it should run on its own machine or VM. A Jibri host shared with other services can drop recordings or degrade the meeting being recorded, so give Jibri a dedicated machine or VM and confirm its capacity before you enable recording for users.

What recurs after go-live when you run Jitsi support in-house or with a partner

Once Jitsi Meet is live, the recurring work decides whether it stays reliable. Someone must watch the central server, which runs the nginx or Apache web tier, Prosody, and Jicofo, and watch each Jitsi Videobridge separately, because a healthy signaling server can still sit in front of a bridge that is overloaded or down. The same owner patches the operating system and keeps the OpenJDK 17 runtime current, follows new Jitsi Meet releases such as the stable tag stable/jitsi-meet_11248, renews TLS certificates before they expire, backs up configuration and any recordings, and answers incidents when a meeting fails. Each of these tasks is small on its own. Together they are the standing cost of operating the system. The first upgrade and the standing arrangement are different pieces of work, and they should be priced and staffed separately. The first upgrade includes building a test environment, comparing your local configuration against the defaults in the new release, confirming that Prosody, Jicofo and the videobridges are on matching versions, and checking browser behavior with your users' devices. That is one-time effort. A standing support arrangement covers the repeating tasks: monitoring, patch windows, release testing, certificate renewal, backup checks and incident response. Ask any partner to split its proposal into these two groups so you can see what you pay once and what you pay each period. The Jitsi scalable setup guide warns that building scalable infrastructure is not a task for beginning Jitsi administrators and recommends configuration management tools such as Ansible or Puppet. This affects who can maintain the system. If your team has no experience with these tools, every bridge you add becomes a manual change that someone must remember to repeat, and every upgrade becomes harder to reproduce. Decide early whether your staff will build and own the configuration code, whether a partner will build it and hand it over, or whether you need both. Confirm who holds the repository, the inventory of hosts and the secrets before go-live. A retainer covers the agreed tasks and the response expectations, and both should be set in writing before work starts. Specify which systems are monitored, how often patches are applied, what release testing includes, and how quickly incidents are acknowledged and worked. DeployOpen does not publish a price list, so a quote follows from the written scope. The main cost drivers are the number of videobridges, the number of environments that must be kept in step, whether recording with Jibri is in use, and how often your team expects new releases to be tested. Ask each provider to state which of these drivers its quote includes.

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

This table compares each recurring Jitsi upgrade and support task by the skill it needs and whether teams usually keep it, outsource it or share it. Read each row against your own staffing: the right split depends mostly on how many people can carry on-call duty for a live meeting platform. Most teams keep routine patching and release reading in-house and hand off rehearsal, multi-component upgrades and verification when they lack depth in one of the required skills.

TaskSkill requiredUsual splitWhy it moves
Routine security patching of the hostLinux administrationKeep in-houseNeeds system access and a maintenance window owned by your change process
Reading release notes for each stable buildXMPP and WebRTC networkingShareSomeone must judge which changes affect your deployment, such as config or port changes
Configuration changes that follow a releaseXMPP and WebRTC networking, Ansible or PuppetShareConfig drift across Prosody, Jicofo and bridges is easy to miss without a tracked template
Upgrade rehearsal in a test environmentContainer operations or Debian packaging, Linux administrationOutsource or shareRequires a production-like copy of all components, which many teams do not keep
Docker or Debian package upgrades across all componentsContainer operations, Java services, Linux administrationShareWeb, Prosody, Jicofo and videobridges must move to matching releases together
Post-upgrade verification with real browsersWebRTC networking, security testingOutsource or shareNeeds multi-browser, multi-network test calls that check audio, video and screen sharing
Incident response during a live meetingXMPP and WebRTC networking, Linux administrationKeep in-house, with partner escalationRequires on-call coverage, which depends on how many staff can take the pager
Documentation for auditorsSecurity testing, compliance readinessShareChange records and test evidence come from your team, while the write-up benefits from an outside reviewer

How Jitsi upgrade work differs by install method and starting point

A Docker installation runs each Jitsi role in its own container: web, prosody, jicofo and jvb, plus jigasi and jibri if they are enabled. An upgrade is mostly a change of image tags and configuration files, so the test plan focuses on whether your local additions still work with the new release. Test in a staging copy before touching production.

  • Image tags: Confirm that every container moves to the same release tag, so the web app, Prosody, Jicofo and the bridges stay matched.
  • Rootless and read-only containers: Since stable-11146, the containers run rootless with read-only filesystems. Custom volume mounts or scripts that write into container paths may fail.
  • Environment file: Compare the current .env file with the new release's template and confirm that authentication settings carry over unchanged.
  • Optional containers: Confirm the configuration for any enabled jigasi or jibri containers, since these are upgraded and tested separately.
  • Client provides: A Docker host with Compose access, the current .env file and any override files, and access to the image registry or an approved mirror.

Before any plan is written for Kubernetes or another orchestration platform, confirm the approach against the current Jitsi documentation, because the supported layout and upgrade steps may differ from a Compose host. For Docker, check that the staging stack completes a test call from more than one network location before the change is scheduled.

What you provide before a Jitsi upgrade or support engagement starts

Confirm the Jitsi Meet release running in each environment before any scope is written. The release determines which upgrade path applies. The jitsi-meet repository tags stable builds by number, for example stable/jitsi-meet_11248, so ask for the exact build tag or Docker image tag from production, staging and any test environment, not a general description such as "the current version." For Docker, also confirm whether the deployment predates stable-11146, because the move to rootless containers with read-only filesystems changes how containers are rebuilt and what needs to be checked afterward. Mixed versions across Prosody, Jicofo, the videobridges and the web app are a common cause of failed upgrades, so ask for the version of each component.

Provide administrative access to the hosts or the container platform, plus DNS management for the meeting domain. Upgrades touch the web server, Prosody, Jicofo and each videobridge, so the team needs shell or container administration rights to inspect and change them. DNS access is needed for records that point to the public address and for certificate renewal. Without DNS access, a certificate or domain change waits on another team, and a short maintenance window can close before it is done. Also supply the current configuration files, including the .env file for Docker deployments, or the Debian configuration files for each component. Without them, the team has to reconstruct settings from a running system, which raises the risk of configuration drift after the upgrade.

List every enabled extension and authentication method. In Docker, these are usually visible in the .env file, but ask for a written list anyway, because optional components such as Etherpad, Excalidraw, Jibri or Jigasi each add containers, ports and storage that must be checked after an upgrade. Authentication also needs to be documented exactly: internal XMPP accounts, JWT tokens, LDAP, Matrix verification, or the older secure domain method. The Jitsi handbook marks the secure domain method as deprecated for new installations, so if you still use it, the upgrade scope should say whether migration is included. Supply certificate details too: the domain names covered, the issuer, how renewal runs and when the current certificate expires. HTTPS with a valid domain certificate is necessary for working audio and video.

Name one owner for decisions and one owner for each environment, with authority to approve changes and accept risk. Agree a maintenance window in writing, since restarting services ends active meetings and the window should avoid recording sessions and scheduled events. Provide a test set of user accounts covering guests, authenticated users and moderators, plus the browsers and mobile clients your staff actually use, so verification reflects real sessions. Identify where backups are stored and when a restore was last tested. If auditors require specific evidence, such as change records, access reviews or configuration baselines, share those requirements now. DeployOpen prepares systems and evidence for assessments, but independent auditors issue any audit report or attestation.

How much does Jitsi upgrades and support cost, and what do you need to provide?

How is the cost of a Jitsi upgrade or support engagement set?

Upgrade work is sold as a fixed-scope project, and the scope, deliverables and timeline are agreed in writing before work starts. Ongoing support, upgrades and continuous testing are available as retainers. DeployOpen does not publish a price list, so a quote follows from the written scope.

One-time and recurring: The upgrade project is one-time. A retainer recurs on an agreed term and covers the ongoing work you choose to buy.

What drives the cost: the number of environments (production, staging, test), the number of components (web, Prosody, Jicofo, each videobridge, and any optional Jibri, Jigasi or Etherpad services), the install method, how much test coverage you want, and any custom changes that must carry through the upgrade.

What to ask for in a quote: an itemized list of components and environments, what is excluded, who performs the rehearsal and cutover, and what the retainer includes.

How long does a Jitsi upgrade take and what sets the timeline?

The timeline is set in the written scope for each engagement, and the main inputs are the factors below. Ask for the planned duration to be stated as a schedule with milestones before you approve the work.

Install method: Docker deployments run web, Prosody, Jicofo, JVB and optional services as separate containers, while Debian and Ubuntu installs use packages on hosts. Each method has its own upgrade steps and checks.

Number of components: every videobridge, optional add-on and additional region adds configuration to change and verify.

Test coverage: a pilot with real users, browser checks across the browsers your staff use, and join tests with audio, video and screen sharing take longer than a smoke test.

Number of environments: each environment needs its own upgrade and validation. A rehearsal on a copy of production is the step most often shortened under pressure, so confirm it is included.

Can our internal team upgrade Jitsi on its own?

Yes, an internal team can upgrade Jitsi alone if it has the right skills and enough time to rehearse. The work requires Linux administration, networking (ports, NAT, DNS and certificates), and container skills if you run the Docker setup. Rehearsal on a copy of your environment is where most internal upgrades succeed or fail.

The Jitsi scalable setup guide states that building a scalable infrastructure is not a task for beginning Jitsi administrators, and it recommends configuration management tools such as Ansible or Puppet. If your team is new to Jitsi, plan for outside help on the first upgrade or at least for a review of your runbook.

The trade-off is staff time against a fixed-scope project. Compare the hours your engineers would spend, including rehearsal and rollback planning, with the written quote before deciding.

What do we need to provide before a Jitsi upgrade starts?

Before work starts, you provide access, decisions and records. Missing items are the most common reason a schedule moves.

Access: administrative access to each server or container host in scope, plus a staging environment that mirrors production.

Domain and certificates: control of the DNS records and a proper HTTPS certificate for the domain. The Jitsi handbook says HTTPS with a proper domain certificate is necessary for working audio and video, and self-signed certificates cause problems, especially with mobile clients.

Network: firewall change rights for 80/TCP, 443/TCP and 10000/UDP, plus 5349/TCP and 3478/UDP if you use TCP fallback or STUN.

Configuration and decisions: current configuration files and the .env file, the authentication method in use, a named approver, a maintenance window, and test users for the pilot.

Why must Jitsi Meet, Prosody, Jicofo and videobridges stay on matching releases?

Jitsi Meet, Prosody, Jicofo and the videobridges work together as one deployment, so they are kept on matching stable releases. A mismatch between them can break how components talk to each other, and the symptoms can look like network or browser faults.

Stable Jitsi Meet releases are tagged by build number, for example stable/jitsi-meet_11248, so an upgrade should move every component to a release set that has been tested together. Confirm with DeployOpen or your own engineers which release set is targeted and in what order the components will change.

In practice, the upgrade plan should list the versions before and after for each component, and the rehearsal should check that the set works end to end.

What do you receive at the end of a Jitsi upgrade?

The deliverables are agreed in the written scope, but a typical handover includes a runbook, a rollback plan and a record of what changed. Ask for the list to be written into the statement of work so it is clear what you own at the end.

Runbook: the steps used for the upgrade, the checks after each step, and the commands or container actions for each environment.

Rollback plan: the steps to return each component to its previous release, tested on staging before the window.

Configuration record: the versions in use, changed settings, and where secrets and the .env file are stored.

Handover: a session with your operators so they can run the next upgrade or respond to an incident.

Does ongoing Jitsi support cover browser compatibility changes?

Whether browser compatibility testing is included depends on the retainer scope, so confirm it in writing before you sign. Browser updates can change how Jitsi Meet behaves, and checking this is ongoing work rather than a one-time task.

For example, Jitsi Meet end-to-end encryption is offered in Chromium 83 and later browsers and in the Jitsi Electron client, and it is limited to audio, video and screen sharing, not chat or polls. A support plan should name the browsers and clients your staff use and how often they are checked.

Ask how regressions are reported, who fixes configuration problems, and whether testing covers audio, video and screen sharing on each browser you support.

What happens if a Jitsi upgrade goes wrong during the maintenance window?

If an upgrade fails in the window, the rollback plan returns the affected components to the previous release. The plan should be rehearsed on staging before the window, so the steps and timing are known.

Before the window: agree the go or no-go criteria, the point at which rollback starts, and who makes that call.

During the window: check each component after each step, and keep the meeting links and communication plan ready in case users need to rejoin.

After a rollback: record what failed, confirm the previous release is stable, and schedule a fix and a new window.

Ask for these steps to be written into the runbook and the scope.

How DeployOpen scopes, upgrades and supports Jitsi

DeployOpen plans and performs Jitsi upgrades and ongoing support inside your own infrastructure, so you keep control of the web server, Prosody, Jicofo and videobridges. Every step starts from a written scope that names the components, release targets and test environments involved.

How we scope

  • We inventory the running components: web server, Prosody, Jicofo, videobridges and any optional containers or packages.
  • We record the current release, the target stable release and the deployment method, Docker or Debian packages.
  • We confirm the written scope covers which environments, which upgrade windows and which browsers and clients must be checked.

How we build

  • We rehearse each upgrade in a staging copy that matches production configuration, including authentication and certificates.
  • We keep Prosody, Jicofo and videobridges on matching stable releases so the deployment stays internally consistent after each change.
  • We review browser compatibility changes in each release and test meeting join, audio, video and screen sharing before cutover.

How we hand over

  • We document the upgrade procedure, rollback steps, configuration changes and the versions in use for your operations team.
  • We deliver a test record showing which scenarios were checked, which browsers and devices were covered and any open issues.
  • We walk your administrators through the runbook so they can perform routine upgrades without outside help.

How we support

  • Ongoing support is available as a retainer, covering scheduled upgrades, patch follow-up and incident response agreed in advance.
  • We track upstream stable releases and tell you when a new build affects your deployment, with the scope of work it would require.
  • Retainer terms, response expectations and included hours are set in the written agreement, so confirm them against your operating needs.

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.