Migrate Mattermost from GitLab Omnibus to a standalone installation

GitLab is removing Mattermost from its Omnibus package, so teams must move chat data to their own server and PostgreSQL on a supported Mattermost release. This page explains the documented path, prerequisites, downtime window and backups.

On this page

How to migrate Mattermost from GitLab Omnibus before GitLab 19.0 removes it

If your Mattermost runs inside the GitLab Omnibus package, you need to move it to its own server before GitLab removes it. The move follows Mattermost's documented GitLab Omnibus procedure, and it consists mainly of planning, moving data and cutting over traffic to a new environment. Your first job is to decide the target and the cutover date, then work backward through the prerequisites, the downtime window and the backups that the procedure requires.

The deprecation timing GitLab has announced the deprecation of Mattermost from the Omnibus package with GitLab 19.0. Until final removal, GitLab supports Mattermost up to version 10.11 ESR inside Omnibus. Plan the cutover to finish before the GitLab release that drops the bundled Mattermost. The supplied material does not give that removal date, so confirm the exact release and its date in GitLab's release notes and with your GitLab account contact before you set a deadline.

Why the version matters Mattermost v10.11 is an Extended Support Release that reached end of life on 2026-08-15. GitLab's support window does not mean Mattermost still publishes fixes for that build. Ask GitLab in writing which Mattermost security fixes, if any, it backports to the bundled version, and treat the gap as an exposure during the migration. Check the Mattermost server releases page for the release line you intend to target, and plan the version jump with the breaking changes for that release in mind.

The short answer on effort Effort depends on the size of the database, the volume of file storage, the number of users and how much downtime your business accepts. The documented procedure needs root or sudo access to the Omnibus server, a new standalone PostgreSQL server, disk space for the database dump, a maintenance window and a full backup of both the database and file storage. The sections that follow explain what drives each of these. Ask for a fixed scope tied to those inputs before you accept any quote.

Which Omnibus-bundled Mattermost parts map cleanly to a standalone server

This table compares what the Omnibus bundle provides with what a standalone Mattermost installation needs. Read the last column first: items that move as data travel with the database and file dump, while rebuilt items need decisions on the new server before cutover. Plan-level items, such as shared file storage for a later high availability cluster, should be settled before the maintenance window starts.

ItemOmnibus bundleStandalone serverHow it moves
Mattermost application and versionBundled Mattermost, supported within Omnibus only up to 10.11 ESRMattermost server binary you install yourself, on a release you choose such as v11.7 ESRRebuild. Confirm target version and upgrade path first
PostgreSQL databaseBundled PostgreSQL managed by the Omnibus packageNew standalone PostgreSQL server you provision and secureMoves as data by dump and restore. Needs free disk space for the dump
File storageUploaded files kept on the Omnibus serverLocal disk for a single node, or S3, an S3-compatible service or NAS if a high availability cluster is plannedMoves as data. Storage type is a plan decision
Server configurationSettings managed through the Omnibus configurationSettings rebuilt in the standalone server configuration fileRebuild and review each setting against the new host names
SSO and AD/LDAP settingsIdentity provider and directory sync configured in the bundled MattermostReconfigured on the standalone server, with sync and SSO settings checked against your planReconfigure. SSO and AD/LDAP sync are listed from the Professional plan
Boards, Playbooks and Calls pluginsPlugins and their data stored in the bundled databasePlugins reinstalled and checked against the restored databaseData moves with the database. Confirm plugin behavior in a test restore
Integrations, webhooks and botsConfigured inside the Omnibus-hosted instanceSame integrations pointed at the new server URL with reissued or verified tokensReconfigure external systems whose callback URLs change
Users, teams and channelsAccounts, teams, channels and messages in the bundled databaseRestored with the database, then matched to the reconfigured sign-in methodMoves as data. Verify sign-in for every user group after cutover
Backups and TLS certificatesBackups produced by Omnibus tooling, certificates managed on the Omnibus hostNew backup jobs for database and file storage, and a certificate issued for the new hostRebuild. Take a full backup of database and file storage before the window

Documented migration path and the tools it relies on

The Mattermost documentation for moving from GitLab Omnibus is the controlling reference, and every step in your runbook should be checked against it. The cards below cover the supporting tools you will touch on the database, backup and file storage sides of the move, plus the scope limits that keep the procedure correct.

Mattermost's documented procedure governs

The Mattermost guide for migrating from GitLab Omnibus to standalone Mattermost is the controlling reference for this move. It sets the order of steps, the prerequisites and the downtime window, and your team and any implementation partner should follow it line by line. Before work starts, confirm that the guide matches the Mattermost version you run today and the version you plan to install, and record the guide revision you used in your change ticket.

Commands must match the target version

Exact commands, flags and configuration keys must come from the current Mattermost procedure for the version you are installing. Articles, forum answers and internal runbooks written for older Mattermost or Omnibus releases can name settings that have since changed or been removed. Ask whoever runs the migration to cite the source for each command in the runbook, and treat any command copied from an older article as unverified until it is checked against the current guide on a test copy.

PostgreSQL dump and restore for the database

The database move relies on PostgreSQL dump and restore, which the PostgreSQL upgrading documentation lists as one of its major-upgrade methods. The dump is taken from the database bundled with Omnibus and loaded into the new standalone PostgreSQL server. Confirm that the dump tool version matches the source and target servers, check that the target PostgreSQL major version is still within its support window under the PostgreSQL versioning policy, and size disk space for the dump file before the maintenance window opens.

GitLab backup and restore for the source side

GitLab's backup and restore documentation covers the source side, so you can recover the Omnibus installation if the move fails partway. Confirm which data that backup captures for your Omnibus version and whether it includes the Mattermost database and configuration you need. The Mattermost procedure requires a full backup of database and file storage before you begin, so the GitLab backup supplements that requirement and does not replace it. Test a restore in a separate environment if you can.

File storage copy alongside the dump

Uploaded files and attachments sit in the file storage location configured on the Omnibus server, and they must reach the standalone server in step with the database dump. Copy them from the same point in time as the dump, then verify ownership, permissions and the storage path in the new configuration. A restored database without its matching files leaves messages that point to attachments which will not open, so check a sample of file links after cutover.

Separate migrations stay out of scope

Mattermost also documents separate migration paths from Slack, Rocket.Chat and MySQL, each with its own tools, data formats and risks. This procedure does not cover those sources. If your source is one of them, use the dedicated guide for that path. Avoid mixing steps from different guides in one runbook, because their tooling and assumptions differ and a step from one path can break another.

What the documented procedure needs before work starts

Five prerequisites in the documented procedure gate the work, and two of them are decisions to make early. The first is root or sudo access to the GitLab Omnibus server. The migration stops the bundled Mattermost, exports its data and reads the existing configuration, so the account needs enough privilege to do all three on that host. The platform team usually owns this access, and the security team should approve any temporary elevation. Confirm early which Mattermost version the Omnibus package runs. GitLab has announced that Omnibus will support Mattermost only up to 10.11 ESR, and Mattermost lists that release as end of life on 2026-08-15, so both the target version and the migration date depend on the answer.

A new standalone PostgreSQL server must be provisioned and reachable from the target Mattermost host before the downtime window opens. The database team usually owns this build, including the network path, TLS settings, authentication method and backup job. Building it inside the window adds risk to the period when users are offline. The PostgreSQL major version is the first decision. Choose a version that the target Mattermost release supports and that is still inside PostgreSQL's support period. According to the PostgreSQL versioning policy, version 14 is supported until November 12, 2026, 15 until November 11, 2027, 16 until November 9, 2028, 17 until November 8, 2029 and 18 until November 14, 2030. Ask the database team to record the end date in the change ticket, because a version that ends support soon after go-live creates a second upgrade project.

Disk space must cover the database dump, the file storage copy and the restored data on the destination. The export writes to the source host, so the Omnibus server needs free space for the dump while it runs. The new server needs room for the restored database and its write-ahead logs. The platform and storage teams usually size this. Measure the current database size and the file storage directory on the source, then add the headroom the change board requires. Base the figure on those measurements, since the size of a dump depends on the installation's history and file volume. Confirm free space on both hosts, and confirm that the filesystem will not fill during a long restore.

A maintenance window with downtime is needed because Mattermost must stop accepting writes while the export runs. Otherwise the database dump and the file copy will not describe the same point in time. The change board and business owners usually agree the window. Its length should come from a rehearsal on a copy of the data, timed end to end, including the restore, the application install and the verification steps. Plan the rehearsal against the target release. Mattermost ships server versions in binary form on the 16th of each month. Version 11.7 is an Extended Support Release, released on 2026-05-15 and supported until 2027-05-15. Version 12.0 was released on 2026-10-16 and supports until 2027-01-15. Confirm with the vendor and your change board whether a monthly release or the ESR fits your support plan.

A full backup of the database and file storage is the rollback path, so take it and test it before the window opens. The backup owner, usually the platform team with security oversight, should confirm that the backup restores into a scratch environment, which proves more than a completed job log. Include the Omnibus configuration files, since the new server needs the encryption keys referenced in the Mattermost configuration to read existing data. Keep the Omnibus installation intact until the new server passes its checks. Record who can authorize a rollback and how long backups are retained. Ask the security team to confirm encryption at rest, access controls on the backup location and the retention period that policy requires.

Sequence to migrate Mattermost from GitLab Omnibus with a rehearsal and cutover

This sequence moves a Mattermost instance bundled with GitLab Omnibus onto its own server and PostgreSQL before GitLab removes the bundled service. It runs from inventory through a rehearsal on copies, a check window and a cutover with a write freeze, and it ends with decommissioning only after a rollback point is confirmed.

  1. Inventory Omnibus settings, data, plugins and integrations

    The team with root or sudo access to the Omnibus host exports the Mattermost configuration, records where the database and file storage live, and lists installed plugins. It also documents integrations such as bots, slash commands, webhooks, outgoing connections and SSO settings, plus any custom values in the Omnibus configuration. The platform owner and the Mattermost administrator review the inventory together. The step is done when the written inventory covers every setting, data store and integration, and each item has an owner and a migration decision.

  2. Provision the standalone server and PostgreSQL

    The infrastructure team builds a Linux server for the Mattermost application and a separate, new PostgreSQL server, since the documented path requires a standalone database rather than the one bundled with Omnibus. They size disk space for the database dump from the inventory, set up backup storage, and configure network access, TLS and firewall rules. Confirm the PostgreSQL major version against the PostgreSQL versioning policy so it is still supported for the planned life of the platform. The step is done when a test connection succeeds from the application host and the PostgreSQL version check passes.

  3. Choose and confirm the target Mattermost release

    Mattermost publishes server releases in binary form on the 16th of each month and also offers Extended Support Releases. The platform owner picks a monthly release or an ESR based on the team's upgrade cadence and confirms that the target version is documented as a migration destination for an Omnibus source. Read the release notes for breaking changes that affect the plugins and integrations in the inventory. The step is done when a written version decision names the target release, its support end date and the reasons for the choice.

  4. Rehearse on a copy of the database and file storage

    The team restores a full copy of the database and file storage to the standalone rehearsal environment and runs the documented procedure against that copy, step by step, exactly as the production run will proceed. They then test the restored instance: the server starts, administrators can reach the console, users can log in including through SSO, old attachments download correctly, and integrations reach their endpoints. Each defect is logged, fixed in the runbook and retested. The step is done when a rehearsal log shows a clean run from start to finish with the observed sequence recorded.

  5. Validate the restored copy in a check window

    During a check window, users stay on the Omnibus source while the team validates a restored copy with test accounts and representative channels, files and integrations. Parallel running for chat is limited, because two live systems can diverge and users may post to the wrong one. For that reason the copy is refreshed from the source as needed, and any write to the copy is treated as test data only. The team records known differences and confirms the freeze method for cutover. The step is done when the validation list passes and the cutover plan names who will freeze writes and when.

  6. Cut over with a write freeze and final restore

    The team announces the maintenance window and freezes new writes on the Omnibus source using the method confirmed in the check window, so no messages, files or configuration changes arrive after the final copy. They take a full backup of the database and file storage, produce the final database dump, and restore it to the standalone server. DNS, load balancer or reverse proxy entries are then pointed at the new server, and integrations that use the public address are checked. The step is done when the production address serves the standalone instance and the source remains frozen.

  7. Validate users, channels, files and integrations

    After cutover, the team checks the production instance against the inventory. They confirm user counts, roles and deactivated accounts, team and channel membership, and message history in sample channels. They download a set of older and newer files, test outgoing and incoming integrations, and confirm email notifications and desktop and mobile client connections. Business owners for each team sign off on their areas. The step is done when a signed validation record covers every category and any open issue has an owner and a fix date.

  8. Decommission Omnibus Mattermost after a rollback point

    The frozen Omnibus instance and its backups stay in place until the team confirms a rollback point, meaning a verified backup of the standalone production data that the team can restore if needed. Only then does the team disable Mattermost in the Omnibus configuration and plan removal alongside the GitLab upgrade schedule. Backups from the source are retained for the period the organization's retention policy requires. The step is done when a decommissioning record names the rollback point, the retention period and the date the Omnibus component was removed.

What drives the cost to migrate Mattermost from GitLab Omnibus

This table lists the cost components of moving Mattermost off GitLab Omnibus and what moves each one up or down. Read it as a checklist for the quote: ask each provider to price the rows against your own database size, plugin count and maintenance window. The main takeaway is that most of the cost sits in internal time and rehearsal, not in server hardware.

Cost driverWhy it changes cost or effortWhat to ask for or confirm
Internal time from platform, database, security and application ownersEach team must approve the target design, the new PostgreSQL server, the access model and the cutover plan. Their time is usually the largest unpriced line in an internal estimate.Effort split by role, with named owners for prerequisites, rehearsal, cutover and validation.
PostgreSQL server provisioning and sizingThe documented path needs a new standalone PostgreSQL server and disk space for the database dump. Larger databases need more storage, more memory and a longer restore.Current database size, dump disk requirement, sizing basis and whether the server is one-time or recurring to run.
Plugins, integrations and SSO or AD/LDAP connectionsEach plugin, integration, SAML, OIDC or AD/LDAP connection must be checked and reconfigured against the new server URL and settings. Counts drive test time.Inventory of plugins, integrations and identity connections, with a check for each one during validation.
Volume of file storage to copy and verifyAttachments must be copied to the new server and checked for completeness. More files and larger volumes lengthen copy and verification runs.File storage size, copy method, checksum or count verification and who signs off the result.
Number of rehearsal runsEach rehearsal repeats the dump, restore and file copy on a copy of production. Repeated failures add runs and internal review time.Number of rehearsals included in the scope, and what happens if a rehearsal fails.
Length of the maintenance window the business acceptsThe documented procedure requires downtime. A shorter window generally means more preparation and tighter rehearsal timings.Agreed window length, the timing of the cutover and the rollback point if the window is exceeded.
Parallel environment for validationA standby standalone server used for testing before cutover adds hardware and setup work. Teams without one usually validate later in the window.Whether a parallel environment is in scope, who provides it and whether it is decommissioned after cutover.
Plan change, such as high availabilityMattermost lists high availability clustering on Enterprise and Enterprise Advanced plans and requires shared file storage for it. This is a separate purchase and project from the migration.Keep plan and licensing costs in a separate quote. Confirm plan prices with Mattermost sales, as public prices are not listed.

How the maintenance window and backups protect the cutover

The documented procedure requires downtime, so the maintenance window has to be agreed with the business before anyone sets a date. Users cannot keep posting while the database is dumped, moved and restored, and the Mattermost administrators and the business owners who depend on the workspace need to accept that outage in writing. Size the window from rehearsal results, not from estimates. Run the full sequence against a copy of the Omnibus data on the standalone target, time each stage separately (dump, transfer, restore, configuration changes and validation), and plan around the slowest run you observed. Record each run so the change board can see where the time went. If the rehearsal shows that the dump needs more disk space than planned, fix that before the window is booked, because a failed dump during cutover uses up the window you agreed.

Take a full backup of both the database and file storage immediately before the cutover, after users have been stopped from writing. The database holds channels, posts, users and settings. File storage holds uploaded attachments that the database only references, so a database backup alone cannot restore a working workspace. Capture the Mattermost configuration file as well, along with the secrets it contains, such as encryption keys and integration settings, and store that material securely alongside the backup. Ask your GitLab administrators to confirm in the GitLab backup and restore documentation for your version which components the backup covers, what it leaves out and whether it includes the Mattermost data you need. Then confirm that the Mattermost procedure for your version lists the same items. Any gap between the two lists is a gap in your recovery plan, so resolve it before the window.

A backup that has not been restored is an assumption. Restore the backup to a separate server built the way the target standalone installation is built, using the same PostgreSQL major version and the same Mattermost version that the cutover will use. Check that the server starts, that test users can sign in, that channel and message counts match the source, that a sample of attachments opens and that search returns expected results. Keep the restore server away from the production network path, or disable outbound email, webhooks and integrations first, so the copy cannot notify users or change data in connected systems. Store checksums and file listings with the backup so the restore can be compared with what was taken, and record who signed off the test.

Decide the rollback plan before the cutover starts. Define the validation checks that the restored standalone instance must pass, and name the person who makes the go or no-go decision if one of them fails. If the restored instance fails, the rollback is to keep the original Omnibus Mattermost stopped but intact, point users back to it and restart it. Do not remove or alter the Omnibus data until the new instance has run long enough for your team to be satisfied, and agree that period in advance. Plan for messages written to the new instance before a rollback: decide whether they will be kept, exported or lost, because returning to the old database without a plan for them creates a split history. Test this rollback path during the rehearsal too, not only the forward path.

PostgreSQL recovery concepts apply to this move in two ways. A logical dump is a snapshot taken at one moment, so it recovers the data as it was when the dump ran. It does not let you return to an arbitrary point in time. Point-in-time recovery depends on a base backup plus archived write-ahead log, as described in the PostgreSQL continuous archiving documentation. Confirm whether the source PostgreSQL bundled with Omnibus archives its log, and whether your standalone server will, because that decides how far back you can restore after cutover. Set backup retention for the period after the move based on your recovery objectives and the records rules your organization follows. Keep at least the pre-cutover backup for as long as the rollback window and any review require, and test a restore from the retained set before you rely on it.

What usually goes wrong when Omnibus Mattermost moves to a standalone server

Most failed moves come from a short list of avoidable gaps: a target that is already out of support, a deadline with no way back, a dump that never finishes, and data that did not arrive intact. The cards below name each gap, the check that catches it, and the step to complete before the downtime window opens.

Unsupported Mattermost or PostgreSQL version

The target must run a Mattermost server release that is still supported and a PostgreSQL major version on the supported list. PostgreSQL 14 is supported only until November 12, 2026, so a new standalone database built on it will reach end of support soon after go-live. Prevention: choose the Mattermost release line and PostgreSQL major version before building the target, confirm both against the lifecycle dates on the vendor pages, and plan an upgrade step if your source version is older than the documented path allows.

Removal date missed with no rollback

GitLab has announced that Mattermost will be deprecated from the Omnibus package with GitLab 19.0, and Omnibus supports Mattermost only up to version 10.11 ESR until final removal. A cutover that slips past that point can leave you without a supported bundled path. Prevention: confirm the removal date for your GitLab version, set a go or no-go date well ahead of it, and leave the Omnibus instance and its verified backup untouched so you can return to them if the standalone server fails validation.

Dump fails for lack of disk space

The documented procedure needs free disk space for the database dump. A dump that fills its volume usually fails partway through and leaves an incomplete file that looks valid until restore. Prevention: estimate the dump size from the current database size, confirm free space on the volume that will hold it with margin left over, avoid writing the dump to the same volume as the live data directory where possible, and confirm the dump completes with a clean exit before any work starts on the target.

File storage copied incompletely

Attachments, avatars and other uploaded files sit in file storage outside the database, so a database dump does not capture them. An incomplete copy shows up later as broken file links, often first reported by users after cutover. Prevention: copy the full file storage tree with a method that preserves ownership and permissions, compare file counts and total size between source and target, and open a sample of attachments of different types on the new server before you call the copy complete.

Settings lost in configuration

A standalone server starts from its own configuration, and settings that existed only in the Omnibus configuration do not carry over automatically. SSO (SAML, OIDC or OAuth), AD/LDAP user sync and SMTP email are the usual losses, and users notice quickly when sign-in or notifications fail. Prevention: export every authentication, email and integration setting from the source, map each one into the new configuration, and test sign-in with a non-admin account and a password reset email before go-live.

Cutover without frozen source or verified backup

A restore is only as good as the copy it starts from. Two failures recur: the backup was never test-restored, or users kept posting to the source while the dump ran, so messages written after the dump are missing on the target. Prevention: stop writes to the source or set it to read-only for the final dump, take a full backup of database and file storage, restore it to a test target, compare message and user counts, and only then point users at the new server.

Questions buyers ask before they hire help to migrate Mattermost from GitLab Omnibus

How much does it cost to migrate Mattermost from GitLab Omnibus?

The cost is quote-based and follows from the written scope, so no fixed figure applies. The main drivers are the number of Mattermost environments (production, staging and rehearsal copies), the size of the database and file storage, how many integrations, SSO connections and custom settings must be verified, and how many rehearsals your change process requires. One-time costs cover planning, rehearsals, cutover and post-migration checks. Recurring costs sit mostly with you: the standalone PostgreSQL server, backup storage and any Mattermost plan you hold. Ask for a written scope that lists each environment, each integration to verify, the number of rehearsals, who runs the backup and restore tests, and which items the quote excludes.

How long does a Mattermost migration from GitLab Omnibus take?

Duration depends on rehearsal results, the size of the database and file storage, and the downtime window the business accepts, so no fixed figure applies. A dry run against a copy shows how long the database dump, transfer, restore and file copy take on your hardware, and that measured time should set the cutover window. Large databases and file stores lengthen every step, and the disk space needed for the dump adds planning work. Ask for a plan that states the rehearsal count, the expected downtime window, the dates each rehearsal depends on, and the change calendar constraints. Confirm the timing against the Mattermost documentation and your own environment before you commit to a date.

What does the migration require from our team and infrastructure?

The documented procedure needs root or sudo access to the Omnibus server, a new standalone PostgreSQL server, disk space for the database dump, a maintenance window with downtime, and a full backup of both the database and file storage. Beyond those, name an owner for each integration, such as bots, webhooks and slash commands, and an owner for SSO and any directory sync. Also name an approver who can sign off change requests during the window. Backup access should be tested before the first rehearsal, not assumed. Confirm these owners early, because integration checks and SSO reconfiguration are where coordination usually slows a migration.

Can our own team migrate Mattermost from GitLab Omnibus without a partner?

Yes, if your team has Linux administration and PostgreSQL skills, the documented procedure, and a written rehearsal plan. Your team should be able to take and test the backup, restore the database dump into the new PostgreSQL server, point Mattermost at the new database, check files and integrations, and roll back to the Omnibus server if a check fails. The steps teams most often shortchange are rehearsal and integration verification, so schedule them as named deliverables from the start. A partner is a fit when the team lacks those skills, lacks capacity during the deadline, or needs an independent rehearsal record for an assessment. Whichever path you choose, agree on the rollback criteria before cutover.

Do we need high availability before we move Mattermost off Omnibus?

No. The documented migration procedure does not require high availability. High availability on Mattermost is available only on the Enterprise and Enterprise Advanced plans, and it needs redundant application servers, redundant database servers and redundant load balancers. A cluster also needs shared file storage on Amazon S3, an S3-compatible service or NAS mounted on each node, because local file storage does not work correctly across nodes and risks corrupting files. Treat high availability as a separate decision after the move, since it changes the file storage design and the licensing. For a single standalone server, focus on backups, a tested restore and monitoring of the PostgreSQL server. Confirm the current plan features with Mattermost before you assume any capability.

What happens if we miss the GitLab Omnibus removal deadline?

Once GitLab removes Mattermost from the Omnibus package, that installation path ends, so plan to finish the move before the removal date. GitLab has announced the deprecation of Mattermost from the Omnibus package with GitLab 19.0, and it supports Mattermost up to version 10.11 ESR within Omnibus until the final removal date. Confirm the removal timeline with GitLab in writing, because that date sets your change window. Choose the target Mattermost release from the server releases page, weighing monthly releases against Extended Support Releases, so the standalone server does not start on a version close to end of support. Work backward from the removal date to set the rehearsal and cutover dates, and keep a rollback plan in case the schedule slips.

What PostgreSQL version should the standalone Mattermost database run?

Choose a PostgreSQL version that is still supported on the day you cut over, and check the PostgreSQL versioning policy for the current dates. At the time of research, supported major versions included 18, 17, 16, 15 and 14, with 14 ending November 12, 2026 and 18 ending November 14, 2030. Confirm that the Mattermost release you plan to run supports the PostgreSQL version you pick, using the Mattermost documentation, before you build the server. Size the host for the dump, the restored data and growth, and place backups on separate storage. Run the rehearsal on the same PostgreSQL major version as production, so the test result describes the production behavior you will get.

How DeployOpen scopes, delivers and supports the Mattermost migration

DeployOpen plans the move of a Mattermost bundled with GitLab Omnibus to its own server and PostgreSQL before GitLab removes the package, following the documented migration procedure. Each engagement starts with a written, fixed scope that records the prerequisites, downtime window and backup steps, and the work runs inside infrastructure you control. The outcome is a standalone Mattermost in your environment, with handover and ongoing support options agreed up front.

How we scope

  • The written scope lists the GitLab Omnibus version, Mattermost version and hosts involved in the move.
  • We confirm root or sudo access on the Omnibus server, a new PostgreSQL server and dump disk space.
  • The scope fixes the maintenance window, downtime expectations and the backup of database and file storage.

How we build

  • We rehearse the documented migration steps against a copy of your database before any production cutover.
  • We move the database to the standalone PostgreSQL server, then point the Mattermost configuration at it and verify it.
  • We check file storage, sign-in, email notifications and integrations against a test plan agreed in the scope.

How we hand over

  • Handover includes a runbook for the new server layout, the PostgreSQL setup and the restore steps used.
  • Backup and restore procedures for the database and file storage are documented and walked through with your team before sign-off.
  • Your team receives the rollback notes and the record of each step run during the maintenance window.

How we support

  • Ongoing support, upgrades and testing can run as a retainer after the migration, scoped in writing.
  • Mattermost server upgrades follow monthly releases and Extended Support Releases, so the upgrade plan joins the handover.
  • PostgreSQL minor updates and planned major upgrades can be included in the support scope if you choose.

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.