Tenant forks & version pinning
Make room to experiment. Keep production familiar.
Give each team its own copy of a workspace. Pin production to the release your users know, so new screens and feature changes arrive when you choose to upgrade.
Tenant forks
A workspace for every rehearsal.
In Copies & versions → Copy tenant, start a private sandbox from a shared tenant. It opens with a snapshot of your configuration, business records and history. Create as many environments as your team needs, including forks of existing sandboxes. Each creator can run one copy at a time.
- Development. Try a new role rule against the identities and entitlements it would affect.
- Test. Fork that development workspace to check which people gain or lose the role. Developers can keep editing their own copy.
- Acceptance. Give a reviewer access to a separate copy to walk through the approval experience with a fresh request.
Each fork starts with schedules disabled. Credentials stay behind, and sandbox controls block remote provisioning and email. Only the creator has access until they admit other eligible users. Changes stay in the fork. You can promote a private fork to an independent production tenant, but there is no merge back into its source.
Production versions
Choose when the interface changes.
Shared tenants follow the current published release. Where production hosting is enabled, open Copies & versions → Version and updates and select Pin current version for your private production tenant. Once the pin takes effect, publishing a newer release leaves your users on the feature set they already know. Compatible bug fixes and security patches still reach them.
When Update available appears, your team can review the newer release in a shared environment and prepare users for changes. Request the forward upgrade when you’re ready. An operator completes the move during maintenance.
Create your self-service forks before moving production to a pinned line. If you need a new copy directly from pinned production, your hosting operator handles it.
Release engineering
How a fix reaches a pinned version
A tenant fork copies data and configuration. Git branches serve a different purpose in release engineering. They let maintainers select which code changes go into a build.
Suppose the next release introduces a redesigned review screen and also fixes a date filter. A maintainer can backport just the filter fix to a maintenance branch, test it against the older screen and build a new immutable Docker image. The operator registers that image as a patch on the existing release line. Every tenant pinned to that line gets the fix when the operator applies the patch.
Containers & capacity
What runs when you add an environment?
A new sandbox adds tenant records to the shared installation. Teams can run parallel trials without deploying a new application stack for every copy. For pinned production, the unit of deployment is a release line. Tenants on the same line share its Docker runtime and PostgreSQL database. Tenant permissions and database row-level security govern access within that pool.
Shared installation
Development · Test · Acceptance
Pinned line A
Production tenants on line A
Pinned line B
Production tenants on line B
Sizing a deployment. Each fork consumes storage for its snapshot and processing time for the work you run. Ten sandboxes doing simultaneous imports can need more capacity than ten idle ones. In compact mode, the API and background jobs share one process. Operators can switch a busy line to separate API and worker containers during maintenance, giving web requests and background jobs their own processes.
Published lines keep their containers running even when empty. Operators size the host for concurrent requests, imports and job bursts across all lines. The gateway and PostgreSQL server are shared infrastructure.
Moving production
From upgrade request to the first login
Request
The administrator selects a newer published line and requests the move.
Rehearse
The operator migrates a temporary tenant copy to the exact target patch and validates its schema. Connectors and mail stay offline.
Transfer
During maintenance, workers drain and source writes pause. A fresh copy carries the latest records, history and pending jobs to the target.
Switch traffic
After checks pass, the gateway routes the same tenant URL to the new line. Its frontend and API now serve the same release.
Plan a maintenance window. A move can briefly affect other tenants sharing the runtime. The original tenant stays frozen so only the destination can process new work.
YOUR NEXT STEP
See governance in practice.
Explore the public demo or bring your applications and governance questions to a guided conversation.