GitLab Geo disaster recovery for a self-managed instance: when it is needed and what makes it hard
Your self-managed GitLab instance holds source code, merge requests, review discussions and pipeline history that the business cannot afford to lose or wait long to regain. GitLab Geo answers that exposure with a continuously synchronized warm-standby secondary site in another region, available on Premium and Ultimate for self-managed GitLab. Geo is the right tool when a regional outage, a failed data center or a prolonged loss of the primary site would stop engineering for longer than the business accepts. It does not replace backups, because corruption and accidental deletion can replicate to the standby as quickly as good data does. Decide early which failures Geo must cover, since that decision shapes every later choice.
The secondary is only as current as its replication allows. Changes reach it asynchronously, so work written to the primary shortly before a failure may not exist on the standby. That gap is your recovery point exposure, and it grows with write volume, the network path between regions and the health of replication services on both sites. Ask your team to measure lag during normal peak hours and quiet periods alike, and set an alert threshold that someone is accountable for acting on. Also plan how engineers will recover commits that were pushed to the primary but never reached the secondary, because a developer's local clone may hold the only copy.
Geo does not treat all data the same way. Git repositories, uploaded files, registries, artifacts and the database each follow their own replication and verification path, and the set of covered data classes changes between releases. Configuration and secrets files are a common gap because they sit outside the database, so confirm how your team keeps them consistent across sites. Before accepting the design, check the replication and verification status of each data class for your exact version in the Geo documentation. Then assign each class an owner and a recovery step, so a failover does not surprise the team with missing attachments or stale registry images.
Promotion turns the secondary into the new primary, and it is rarely performed calmly. Someone must decide that the primary is lost and will not recover in time, and that person must know the lag at that moment and accept the data that will be lost. Promotion also changes DNS entries, routing, runner registrations and integrations that point at the old primary, and each one needs a named owner. Document who has authority to declare the failover, who executes it, how the old primary is fenced so it cannot accept writes if it returns, and how the team will fail back later. Write these steps down before an incident, not during one.
A standby is only proven by rehearsing it. A secondary that replicates cleanly every day can still fail at promotion because of a missing dependency, an expired credential, a runner that points at the old hostname or a runbook step nobody has tried. Schedule failover drills on a regular cadence, record the measured lag and elapsed time, and treat every surprise as a defect in the plan. Ask any implementation partner to show drill results and to name which findings were closed. The durations measured in your own drills should set your recovery objectives, and those objectives should be agreed with the business before any contract is signed.
Which GitLab components Geo replicates and which stay outside it
Geo copies a defined set of GitLab data from the primary site to a secondary site. Coverage differs by data class, some depends on storage configuration and release, and some items must be matched or reconfigured by hand before the secondary can run. Map each class below to your own replication inventory before you agree on RPO and RTO.
Primary site as the write source
The primary site accepts all writes, including pushes, merge requests, issues and pipeline activity, and Geo sends those changes to the secondary. The secondary stays a synchronized standby that is not expected to take writes until you promote it. Confirm in the Geo documentation for your exact GitLab version which primary-side changes feed replication, because coverage changes between releases.
Secondary site as promotion target
The secondary must have enough compute, storage and network capacity to serve the full user base after promotion, not only to receive replication. A secondary sized below the primary may keep data current yet fail under production load. Ask your architect to confirm the secondary's reference architecture matches the primary and that DNS and load balancer changes for failover are documented and tested.
PostgreSQL database state
The database holds metadata for users, projects, groups, merge requests, issues, CI definitions and permissions. Geo keeps the secondary database synchronized from the primary, and this is the class that most directly sets your RPO. Confirm the replication mechanism, any database-level prerequisites and how schema migrations during an upgrade affect the secondary for your version.
Git repository data
Git repositories are the core data that teams cannot rebuild from elsewhere, so their replication lag is the first thing to measure during a drill. Confirm in the Geo documentation whether project wikis, design repositories and snippet repositories are in scope for your version. Record any repository type that is excluded so the gap is known before an incident.
Uploads, LFS, artifacts and registries
Large objects such as LFS files, uploads, CI job artifacts, and container or package registry content often depend on your storage backend, and their coverage varies more across releases than database or repository data. Check each object class against the Geo documentation, and confirm whether object storage replication is configured separately from Geo itself.
Secrets, configuration and external services
The secondary needs the same secrets file and gitlab.rb settings as the primary to decrypt data and run after promotion, and these files are not copied by replication alone. Runners, identity providers, DNS, email relays and certificates sit outside Geo, so each needs a documented failover path. Confirm the full list of files and secrets for your version with the Geo and backup documentation.
Choosing Geo, in-site high availability or backups for each recovery goal
This table compares Geo, in-site high availability and backup-only recovery by the failures each one covers and the operational effort each one adds. Read each row against the failure your organization most needs to survive, then check the secondary topology and promotion rows before committing. The main takeaway is that Geo protects against losing a whole site, but it does not protect against data corruption or accidental deletion that replicates to the secondary.
| Decision | Geo warm standby | In-site high availability | Backup-only recovery |
|---|---|---|---|
| Failure it covers well | Loss of the primary site or region | Loss of a single node within the site | Data corruption, accidental deletion and rollback to an earlier point |
| Failure it does not cover | Corruption or deletion that replicates to the secondary before detection | Loss of the whole site, region or account | Long recovery windows when the full restore must be rebuilt from scratch |
| When it fits | Regulated workloads that need a second region with continuously synchronized data and a defined failover | Teams that need node-level resilience with minimal change to the primary site design | Smaller instances or teams that accept a longer restore in exchange for lower running cost |
| Operational effort | Maintain a second site, monitor replication lag, test failover and keep versions aligned across sites | Maintain redundant nodes for the stateful components and rehearse failover within one network | Schedule and verify backups, store them off the primary and rehearse restores regularly |
| Secondary topology: single or multi-node | Single node is simpler to run but leaves the secondary unable to absorb load while the primary is down. Confirm sizing with your reference architecture | Multi-node is the default pattern for larger user counts in the same site | Not applicable; backups are stored on object storage or disk outside the instance |
| Secondary topology: same or different cloud account | A different account or region separates the failure domain from accidental changes to the primary account. Confirm network and identity requirements with your cloud team | Usually the same account and network, which limits protection against account-level loss | Store backups in a separate account or with separate credentials so an attacker or mistake in the primary account cannot remove them |
| Manual promotion | Operators review replication state and run the promotion steps by hand. Slower to start but easier to reason about when data is uncertain | Failover is usually handled by the cluster components, with operators confirming health | Operators perform the restore by hand, which is the normal path for this option |
| Scripted promotion | Repeatable and rehearsed, but a script that runs on a false signal can promote a site that should not take over. Test the trigger conditions | Automated failover reduces manual steps within the site | Restore scripts reduce error during rebuilds but still need a tested runbook |
| What to ask a partner or vendor to confirm | Replication scope for your data types, promotion steps for your version, and whether your tier includes Geo | Reference architecture for your user count and the components that become highly available | Backup scope including secrets and configuration files, retention, and the restore test schedule |
Setting RPO and RTO targets for a Geo secondary
Set the recovery point objective (RPO) and recovery time objective (RTO) for your Geo secondary as two measured numbers per data class, not as defaults copied from a template. The RPO is how much recent data your organization can afford to lose if the primary site fails. The RTO is how long users can be without GitLab before service is back on the secondary. Both numbers depend on your own write volume, network path and promotion procedure, so the reader has to derive them in their environment before they can be agreed or tested. Geo replicates asynchronously, so the secondary is always some distance behind the primary. The RPO you actually get is the replication lag at the moment of failure, which moves with commit and upload volume, peak hours and the health of the link between regions. Measure that lag under normal load and during your busiest period, then look at the worst values seen, not the average. Confirm the replication lag metric names and the commands that expose them in the Geo documentation for your exact GitLab version, and do not assume names carried over from older releases or from monitoring examples.
Data does not all carry the same business weight, so the RPO should not be one number for the whole instance. Ask the business owners to agree an acceptable data loss per data class, for example repository content, merge request and issue metadata, CI job logs and artifacts, and package or container registry content. Some of these may be acceptable to re-create from a developer's local clone or a pipeline rerun, while others may not. Record each agreed value next to the lag you measured for that class. If the measured lag exceeds the agreed value for any class, you have a decision to make: reduce lag through capacity or network changes, accept the gap in writing, or add a separate backup for that class.
The RTO comes from the promotion runbook, and it is only credible when each step has been timed. Break the runbook into stages: detecting the outage, deciding to fail over and who holds that authority, confirming the secondary is healthy, promoting it, switching traffic through DNS or your load balancer, running verification checks and reopening access. Several of these steps are human decisions, and their duration depends on your on-call process and escalation paths, so include them in the estimate. Name the person who can authorize promotion and confirm that they can be reached at any hour. A runbook that has never been executed will consistently understate the time required.
Run a rehearsal to replace estimates with observed values. Schedule a planned promotion drill in a window your business has approved, or use a non-production copy that mirrors your topology, and record the lag immediately before the drill, the elapsed time for each runbook step and the total time until users can complete a standard set of actions, such as cloning a repository, opening a merge request and running a pipeline. Compare the results with the RPO and RTO targets. If the drill misses a target, change the architecture, the runbook or the target itself, and rehearse again. Plan the drill so that it also checks the secondary's ability to serve traffic, not only that the promotion command completed.
Keep the targets under change control. Record each RPO and RTO value with the GitLab version, the date of measurement, the lag metric used and the drill results behind it. Re-measure after GitLab upgrades, significant growth in user or pipeline volume, and changes to network capacity between regions, because any of these can move lag and promotion time. Be clear with the business that Geo protects against site loss by keeping a current copy of data, but a replica also copies unwanted changes such as accidental deletions or corruption. Those cases need the separate backup and restore capability covered elsewhere in this page, and the RPO for them is governed by backup frequency, not by replication lag.
How to build the secondary site and rehearse failover
This sequence takes a GitLab Geo warm standby from licensing through a rehearsed promotion and failback. Each step closes with a check you can record, so the team knows the secondary can take over before an incident forces the question. The rehearsal should repeat on a schedule, not only once.
Confirm tier and matching versions
Confirm that both the primary and the secondary run a Premium or Ultimate license, because GitLab Geo is available only in those tiers for self-managed GitLab. Check that both sites run the same GitLab version and plan Runner versions to stay aligned with it. Your team or the implementation partner records the license, versions and package sources for each site in the build log. The step closes when both sites show the same tier and version in the admin area.
Plan the upgrade path through required stops
Map the current version of the primary to the target version, passing through every required upgrade stop. Since GitLab 17.5 these stops fall at x.2, x.5, x.8 and x.11, so the plan must include each one that applies to your path. Build the secondary on the final target version and schedule the upgrade of both sites together, confirming the mismatch rules in the Geo documentation for the versions involved. The step closes with a reviewed upgrade plan listing each stop, owner and verification check.
Provision the secondary in another region
Provision a second GitLab installation in a separate region, inside your own cloud account or data center, using the same installation method as the primary. Size compute, database, Git storage and object storage for the load the secondary must carry during a failover, and confirm network reachability between the two sites on the ports the Geo documentation requires. The step closes when the new installation answers on its own address and has no replication configured yet.
Configure Geo replication to the secondary
Enable Geo on the primary, then add the secondary as a Geo site using the setup steps in the documentation for your version. Confirm which secrets and configuration files must match on both sites, and move them through a controlled process rather than by hand on each node. Review the replicated data types for your version so the team knows what is in scope. The step closes when the secondary shows as connected in the Geo sites view.
Confirm sync status before testing
Review sync status in the Geo sites view for repositories, uploads, LFS objects and other replicated data types. Record the lag and any failed item counts, and find out why each failure exists before going further. Clone a test repository from the secondary and compare its recent commit history with the primary. The step closes with a baseline sync report signed off by the operations owner.
Run a documented test failover
Schedule the test in a maintenance window agreed with stakeholders, with a named operator and an observer who records every step. Take a fresh backup of the primary first so there is a fallback. Promote the secondary and work through a checklist: users sign in, repositories clone and push, CI pipelines queue and Runners connect. Log each surprise. The step closes when a sample project created on the promoted site is cloned and verified from a client.
Write and time the promotion runbook
Turn the rehearsal log into a runbook with exact commands, decision points, owners, communication steps, DNS or load balancer changes and rollback criteria. Time each step during the rehearsal and record the total, so the expected outage window comes from measured results rather than estimates. Store the runbook somewhere reachable when the primary is down. The step closes when a person who did not write the runbook can follow it from start to finish, with the rehearsal timings attached.
Define failback and repeat the test
Document how the original primary rejoins as a secondary after recovery and how replication reverses so that data written on the promoted site flows back. Failback is a separate procedure from promotion, so rehearse it on its own. Repeat the full failover and failback test on the schedule your risk owners set, and update the runbook with every finding. The step closes when a later rehearsal passes both the failover and failback checks without undocumented manual fixes.
What drives Geo effort and cost
This table lists the factors that raise or lower the effort of a GitLab Geo disaster recovery project, with how to reduce each one and what to request in a written quote. Read each row as a question to answer about your own environment before asking for a fixed-scope proposal. Premium is listed at 29 US dollars per user per month billed annually on the GitLab pricing page, and Geo requires Premium or Ultimate, so license scope is a cost item to confirm, not a project fee.
| Driver | Why it changes effort or cost | How to keep it down | What to ask for in a quote |
|---|---|---|---|
| Data volume and repository count | Geo replicates repositories, LFS objects, uploads and artifacts, so larger volumes lengthen initial sync and widen the lag window the secondary must catch up on. | Archive or clean up inactive projects, move large binaries to object storage, and confirm which data classes replicate before sizing. | Stated data volume by class, initial sync approach, and the verification method for replicated repositories. |
| Users and API load | Higher user counts and API request rates increase the reference architecture and the load the secondary must absorb during a failover test. | Confirm the reference architecture for your user count and size the secondary to match the primary, not a smaller standby. | Reference architecture chosen, sizing assumptions for users and API requests per second, and the load test scope. |
| Single-node or multi-node secondary | A multi-node primary usually means a multi-node secondary, which adds components to build, patch, monitor and fail over. | Decide early whether the secondary must match the primary topology, and document what a single-node standby can and cannot carry. | Node count for each site, components in scope, and whether the quote includes both sites' upgrades. |
| Network path between regions | Replication depends on bandwidth and latency between sites, and a constrained path can leave the secondary behind during peak change periods. | Measure the path under normal and peak load, and agree on the sync lag you will monitor and accept. | Network assumptions, monitoring setup for replication lag, and who owns cross-region connectivity changes. |
| Air-gapped or regulated constraints | Isolated networks need offline package transfer, local license handling and separate patching, and evidence requirements can add documentation work. | Plan offline transfer paths for both sites and agree which evidence (backup logs, sync reports, test records) the assessor needs. | Offline patch process, evidence list, and whether scanner or Duo components must run offline. |
| Customizations and integrations | Custom CI runners, webhooks, system hooks, Jira links and artifact stores each need a failover plan, or they break after promotion. | Inventory integrations first, mark which must fail over, and keep custom code in documented, version-controlled form. | Integration inventory, failover test per integration, and any changes to third-party endpoints the quote assumes. |
| Identity and DNS cutover | Authentication providers (LDAP, SAML, OAuth) and DNS records must point at the promoted site, and mismatched identity settings block logins after failover. | Pre-stage identity configuration on the secondary, use short-lived DNS records where your policy allows, and rehearse the switch. | Identity providers in scope, DNS change procedure, and who approves the cutover and rollback steps. |
| Frequency of rehearsals | Each planned failover test requires coordination, downtime windows and fixes, so more frequent tests raise recurring effort but lower the risk of an unproven recovery. | Agree a rehearsal schedule that matches your recovery objectives, and automate checks between rehearsals where possible. | Number of rehearsals included, test scripts delivered, and whether rehearsals are priced separately or in a retainer. |
Securing the secondary site, secrets and access during failover
A GitLab Geo secondary site holds a continuously synchronized copy of your production data, so it needs the same access, network and encryption controls as the primary. The cards below cover the controls to decide on before failover, and the ones to test while the site is still in standby.
Treat the secondary as production data
The Geo secondary is a warm-standby copy of repositories, uploads, databases and object data, so it holds the same sensitive content as the primary. Confirm who can sign in to the secondary, which administrative accounts exist there, and whether its backups and logs fall under the same data classification rules. A standby site that is less protected than production is a common gap in this design.
Access control on the secondary
Review administrator accounts, SSH access to the secondary hosts and the identity provider settings on the secondary before you need them. Confirm that group and role mappings match the primary, and that accounts removed from production are also removed from the standby. Test sign-in on the secondary with a controlled account, not only the primary login path.
Network paths between sites
Replication runs over a network path between the primary and secondary, and the secondary must reach the primary's database and storage endpoints. Define which ports and source addresses are permitted in each direction, and restrict them to the Geo components that need them. Document the path your network team controls, and confirm it survives a primary site outage without depending on the primary's network.
Encryption in transit and at rest
Confirm that replication traffic between sites uses TLS with certificates your team issues and rotates, and that the secondary's disks, database volumes and object storage buckets use encryption at rest under keys you manage. Check how each replicated data type is encrypted on both sides, because object storage and database volumes are often configured separately. Record the key locations so a promoted site can still decrypt its data.
Secrets needed after promotion
A promoted secondary cannot run without the instance secrets and configuration files from the primary, including the secrets file that holds encryption keys for database columns. Store copies of these secrets in a separate vault that the secondary can reach during failover, and keep them synchronized after each change. Confirm with the GitLab documentation which secrets must match between sites, and test that a promoted site decrypts existing data.
Who may authorize promotion
Promotion changes which site accepts writes, so define in writing who may declare a primary outage and start promotion, and who can approve it when the primary may still be running. Name primary and backup approvers, and state the conditions that trigger the decision. Record each promotion and its approver in your change system, and pair the log with GitLab audit events and your identity provider logs for the same period.
Roll out hardening gradually
GitLab's hardening guidance covers application settings, configuration files, the operating system and CI/CD, and GitLab notes that it is a work in progress to be rolled out gradually. Use it as a starting point for the secondary, apply settings in stages, and test each stage against replication and sign-in before the next. Track which recommendations you accepted, deferred or rejected, and why.
How to test that Geo fails over safely and fails back cleanly
A Geo failover is only safe if you have tested it against your own data, users and network path before you need it. The verification plan starts with replication health on the primary and the secondary site, checked before any test begins and again after each step. Use the Geo sites status view and the replication and verification status for each data type in scope, such as Git repositories, wikis, uploads, LFS objects, CI artifacts and the container and package registries where they are replicated. Record which components show as healthy, which show as pending, and which show verification failures. A failover test that starts from an unhealthy baseline tells you nothing about the failover itself, so treat a red status as a stop condition for the test window. Run the planned failover as a rehearsal in a non-production window with a controlled write freeze on the primary. Announce the freeze, stop pushes, merges and pipeline creation, and wait until the secondary has caught up with the last replicated event before promotion. Then promote the secondary and point users, runners and integrations at it according to your DNS and load balancer runbook. Once the promoted site is serving traffic, validate the work that matters: clone and push to a sample of repositories, open and merge a merge request, run a pipeline that uses a runner registered to the new site, confirm that a representative set of users can sign in through your identity provider, and check that webhooks and API tokens behave as expected. Test with named accounts from each group that carries real work, because group membership and permissions are part of what must survive promotion. Confirm that no data was silently lost by comparing what you expected to exist with what the promoted site holds. Pick a set of marker events before the freeze, such as a known commit SHA, a merge request ID, a pipeline ID and a newly created user, and check that each is present after promotion. Compare repository counts and last-activity timestamps against the pre-freeze inventory, and review the verification checksums that Geo reports for each data type. Any gap should be recorded as a finding, not explained away. Record the actual replication lag at freeze time and the elapsed time for each step, from freeze to promotion to first successful pipeline, and compare those numbers with the recovery point and recovery time targets your business has agreed. If the targets are not written down yet, set them before the test so the result has something to be measured against. A failed promotion must leave the primary intact. Rehearse this deliberately: simulate a promotion that stops partway, such as an unreachable database or a misconfigured external URL, and confirm that the primary still accepts writes after you lift the freeze and that users can continue working there. Ask the implementation team to show exactly which steps are reversible and which are not before the rehearsal starts. Then test failback as its own exercise. Re-establish replication from the promoted site back to the original primary, wait for verification to complete, run the same validation checks in the reverse direction, and only then switch traffic back. Note any drift in configuration, secrets or runner registration that appeared during the time on the secondary. Geo is a replication and promotion mechanism, not a backup. Keep the gitlab-backup process and a tested restore procedure as a separate safety net, because a replicated deletion or a corrupted database is copied to the secondary just as faithfully as valid data. Save the secrets and configuration files that the backup documentation says must be stored separately, and confirm the restore steps for the exact GitLab version you run, since the procedure can change between releases. Schedule a restore test on a separate environment and record how long it takes. Your verification plan is complete only when both the Geo rehearsal and the restore test have passed and their results are written down with the owner of each follow-up.
What to monitor, back up, upgrade and document after Geo goes live
A Geo pair is only useful if it stays healthy between incidents. The cards below cover the recurring work that keeps the secondary site current and ready to promote, from replication monitoring and version alignment to independent backups, rehearsals and the decision record that governs promotion.
Monitor replication health and lag
Track replication status and lag on the secondary site through the Geo dashboard and its health checks, and alert when sync falls behind your recovery point objective. Also watch verification status, because a replica that is current but fails checksum verification cannot be trusted at failover. Confirm which metrics and alert thresholds GitLab documents for your version before you set targets.
Keep both sites on one version
Run the primary and secondary sites on the same supported GitLab version at all times outside a planned upgrade window. Each upgrade must pass through the required upgrade stops, such as x.2, x.5, x.8 and x.11 for current releases, so plan the path from your current version to the target before you touch either site. Confirm the upgrade order for Geo sites in the current GitLab documentation, since it differs from a single-node upgrade.
Run backups independent of Geo
Geo replicates data, but it does not replace backups. Replication copies a corruption or accidental deletion to the secondary site within minutes, so keep a separate backup set created with the gitlab-backup tool on a schedule that matches your retention needs. Store the secrets and configuration files separately, because a restore without them will not bring the instance back. Confirm which items the backup covers and which need manual copies in the current backup documentation.
Keep GitLab Runners aligned
Runners execute CI/CD jobs and sit outside the Geo replication scope, so they are easy to forget during failover. Keep Runner major and minor versions aligned with GitLab on both sites, and confirm that runners registered to the primary can reach the secondary's endpoints after promotion. Test runner reachability as part of each rehearsal, not only during an incident.
Schedule failover rehearsals
Promotion steps that have never been run tend to fail under pressure. Schedule rehearsals on a fixed cadence, record the elapsed time for each step, and compare the result with the recovery time objective agreed for the service. Rehearse both planned failover and a scenario where the primary is unreachable, and confirm which steps GitLab documents for each case before you schedule the first run.
Maintain runbook, contacts and decisions
Keep the failover runbook, the on-call and vendor contact list, and a decision record that names who can declare a disaster and promote the secondary. Review all three after every upgrade, staff change and rehearsal, and version them alongside the GitLab release they describe. A current decision record shortens the time spent deciding during an incident and gives auditors evidence that the process is governed.
Questions buyers ask before outsourcing GitLab Geo disaster recovery
What drives the cost of a GitLab Geo disaster recovery project?
The fixed-scope price follows from the written scope. The main drivers are the number of GitLab sites and nodes in each location, the volume of repository and object data to replicate, the number of failover rehearsals, and how much identity, DNS and network work sits inside the project. Some costs recur outside the project fee: the license tier that includes Geo (the GitLab pricing page lists Premium at 29 US dollars per user per month billed annually, and Ultimate is custom priced), the secondary site's compute and storage, cross-region bandwidth, and admin time for monitoring and upgrades. Ask any quote to separate one-time build work, rehearsal work, handover and optional retainer support, and to state which of your infrastructure costs it assumes. DeployOpen does not publish a price list, so the quote follows from that written scope.
How long does GitLab Geo disaster recovery setup take?
No single duration applies, because the timeline depends on scope and on how many failover rehearsals you need before you rely on the secondary site. Scope includes the number of GitLab sites and nodes, the size of your data, whether the secondary site sits in a separate network and cloud account, and how many external systems such as identity providers and DNS zones must change during promotion. Rehearsals often take the most calendar time, because each drill can expose a gap that needs a fix and a retest. Ask for a timeline in the written quote that lists the phases, the rehearsal count, the change windows you must provide and the steps that wait on your approvals. Treat any figure you hear without that breakdown as an estimate to check.
What does our team need to provide for a Geo engagement?
Your team provides the parts of the path that a partner cannot change alone. That means network access between the primary and secondary sites, firewall and routing rules for replication traffic, identity provider access and configuration for the secondary site, DNS control to point users at the promoted site, and change approvals for maintenance windows and failover drills. You also provide cloud or data center accounts, storage, certificates and a named owner for each approval. Request an access list in the quote, and confirm early the lead time your change process needs. That lead time often sets the schedule more than the build itself does.
Can our own platform team build GitLab Geo disaster recovery without a partner?
Often yes, if the team already runs self-managed GitLab, has strong Linux and PostgreSQL skills, and can commit people to a staged rollout with repeated rehearsals. The GitLab Geo documentation describes the product, but the hard parts are specific to each environment: the network path, the DNS cutover, identity federation, secret handling and runbook testing. Assess your team against those skills honestly. Consider the time engineers will spend away from normal operations, the on-call coverage during drills, and what happens if the person who built the design leaves. A partner can take on the build, the rehearsals and the handover, or review your runbooks as a second set of eyes before go-live.
How is GitLab Geo different from high availability?
Geo protects you from losing a whole site or region, while high availability keeps one GitLab site running when a component fails. GitLab Geo provides a warm-standby secondary site in another region that is continuously synchronized and can be promoted if the primary is lost. High availability uses redundant nodes inside one site, such as Gitaly Cluster with Praefect, PostgreSQL with Patroni, Redis Sentinel and Consul. The GitLab documentation generally recommends high availability for 3,000 or more users. Many teams with strict recovery requirements run both: high availability for component failure and Geo for site failure. Geo also does not replace backups, so plan for all three together.
How is GitLab Geo different from taking backups?
Backups give you a point-in-time copy that you restore, while Geo keeps a live copy in a second site that can be promoted. A restore is a rebuild that takes time and depends on the backup set. Geo narrows the data gap between sites, but the size of that gap depends on replication lag at the moment of failure. Geo is also no substitute for backups, because a bad change or an accidental deletion can replicate to the secondary site. GitLab's backup documentation calls for secrets and configuration files to be saved separately from the database and repository data, so keep both protections in place. Ask the partner how they will test restores and promotion as separate exercises.
What should the handover include after GitLab Geo disaster recovery?
A useful handover contains the as-built design, the replication scope and a clear list of what it excludes, failover and failback runbooks with an owner for each step, the promotion and DNS cutover procedure, and rehearsal reports that record measured recovery times and the gaps found. It should also include monitoring and alert definitions for replication lag, a list of secrets and configuration files that must be protected, upgrade procedures that keep both sites on matching versions, and an access and approval matrix. Ask for the recovery objectives statement agreed with your business owners, plus a schedule of rehearsals after go-live. Your team should be able to run a drill without the partner present before the engagement closes.
What recovery objectives should we agree before scoping GitLab Geo?
Agree your recovery point objective and recovery time objective with the business owners before scoping, because they shape the replication design and the rehearsal plan. The recovery point objective is how much recent data you can accept losing, and it depends mainly on replication lag. The recovery time objective is how long the service can stay down, and it depends on promotion steps, DNS propagation and approvals. Ask the quote to state which objectives it targets and how each one will be measured during rehearsals. Treat a target as met only after a drill confirms it in your own environment, and record the result in the handover so the next review starts from measured numbers.
How DeployOpen scopes, builds, rehearses and hands over GitLab Geo
DeployOpen plans, implements, documents and supports self-hosted open-source platforms inside your own infrastructure, and GitLab Geo disaster recovery follows the same pattern. We agree the scope in writing before work starts, build the secondary site in your own cloud accounts or data centers, and hand over runbooks and evidence your team can operate.
How we scope
- Confirm which GitLab tier your Geo setup requires, since Geo is available in Premium and Ultimate for self-managed GitLab.
- Map which data classes replicate to the secondary site and which must be restored from separate backups.
- Agree written RPO and RTO targets with your business owners, then record which failover steps the fixed scope includes.
How we build
- Stand up the secondary site in another region and confirm continuous synchronization with the primary before any test.
- Document the promotion and failover steps, including how the secondary site is promoted and how traffic is redirected.
- Rehearse failover in a controlled exercise, record measured recovery times and fix gaps before sign-off.
How we hand over
- Deliver runbooks for failover, failback and replication health checks, written for your operations team.
- Provide a record of each rehearsal, including timings, issues found and the changes made afterward.
- Walk your team through Geo monitoring and confirm who on your side owns each step during an incident.
How we support
- Ongoing support is available as a retainer and can cover Geo checks alongside GitLab upgrades and patch releases.
- Schedule periodic failover rehearsals and restore tests, and update runbooks when the GitLab version changes.
- Confirm with your team which upgrade stops and version alignment rules apply before each planned upgrade of both sites.

