---
title: "Remote sync"
description: "Version control your Library, transforms, and other collections in Git, and publish them from a development Metabase to a read-only production Metabase."
url: "https://www.metabase.com/docs/latest/data-modeling/semantic-layer/remote-sync"
version: "65"
---

> For the complete documentation index, see [llms.txt](https://www.metabase.com/docs/llms.txt).

# Remote sync

> Remote sync is only available on [Pro](https://www.metabase.com/product/pro) and [Enterprise](https://www.metabase.com/product/enterprise) plans (both self-hosted and on Metabase Cloud).

Remote sync stores your [Library](https://www.metabase.com/docs/latest/data-modeling/semantic-layer/library.md), [transforms](https://www.metabase.com/docs/latest/data-modeling/transforms/transforms-overview.md), and the other collections you choose in a Git repository. You develop this content in a development Metabase, push it to Git, review it in a pull request, and a read-only production Metabase pulls in the merged result.

Remote sync syncs:

- The Library: published tables with their segments and measures, metrics, [data apps](https://www.metabase.com/docs/latest/data-apps/build.md#what-syncs-with-a-data-app), SQL snippets, [data actions](https://www.metabase.com/docs/latest/data-modeling/data-actions.md), and the glossary.
- Transforms: their tags, tests, folders, and Python libraries.
- [Other collections](#syncing-other-collections) you choose: their questions, models, dashboards, documents, timelines, and events.

Metabase doesn't sync any of your data. All Metabase stores in Git are [YAML files](https://www.metabase.com/docs/latest/installation-and-operation/serialization.md#example-of-a-serialized-question) that describe your analytics content. Your actual data stays in your databases and never leaves your Metabase.

## How Remote sync works

Here's a basic Remote sync workflow:

1. In your development Metabase (Read-write mode), publish a table or create a metric in the Library, or build a dashboard in a synced collection.
2. From the development Metabase, push the change to a Git branch.
3. Open a pull request for review.
4. Merge the pull request to your main branch.
5. Your production Metabase (Read-only mode) pulls in the change.

Two Metabases that point at the same branch share the same Library. A new Metabase has nothing to push, so its first pull doesn’t conflict.

## Treat write access to your repository like admin access

When a Metabase pulls from your repository, it loads the YAML files on its branch _without_ checking who wrote them. Anyone who can push to that branch can change that Metabase's synced content. If you turn on [auto-sync](#pulling-changes-automatically), changes merged to the branch show up in your Metabase within minutes, and no one in Metabase approves them first.

Your repository can't change users, groups, or permissions, because those [don't sync](#what-metabase-syncs). But when a pull creates a new collection, that collection gets the same permissions as its parent.

## Key concepts

### Remote sync has two modes for different roles

- **Read-write mode for your development Metabase**: Create and edit Library content, transforms, and the content of other synced collections. You can [push](#pushing-changes-to-git) and [pull](#pulling-changes-from-git) changes to and from your repository. Multiple Metabases can connect in Read-write mode, each working on [different branches](#branch-management).
- **Read-only mode for your production Metabase**: Read-only Metabases only [pull](#pulling-changes-from-git) changes, typically from your main branch. In Read-only mode, you can't edit content in the Library or other synced collections, create segments or measures on published tables, or edit transforms. You can set up [auto-sync](#pulling-changes-automatically) to pull approved changes every five minutes. Keep your production Metabase in Read-only mode so that every change goes through Git.

### Content is stored as YAML files

Remote sync stores your content as [YAML files](https://www.metabase.com/docs/latest/installation-and-operation/serialization.md#example-of-a-serialized-question) in your Git repository. Each published table, metric, transform, and item in a synced collection becomes a YAML file that can be reviewed in pull requests and versioned like code.

### Remote sync excludes table metadata

Table metadata doesn't sync. Table metadata includes things like table names, column types, descriptions, and visibility settings. If you need to version table metadata, use [serialization](https://www.metabase.com/docs/latest/installation-and-operation/serialization.md) instead.

### One branch at a time per Metabase

You can only have [one branch at a time per Metabase](#branching-limitations).

## Setting up Remote sync

You'll need to be an admin to set up Remote sync.

1. [Set up a repository to store your content](#1-set-up-a-repository-to-store-your-content)
2. [Create a token for your development Metabase](#2-create-a-token-for-your-development-metabase)
3. [Connect your development Metabase to your repository](#3-connect-your-development-metabase-to-your-repository)
4. [Push your changes to your repository](#4-push-your-changes-to-your-repository)
5. [Create a token for your production Metabase](#5-create-a-token-for-your-production-metabase)
6. [Connect your production Metabase to your repository](#6-connect-your-production-metabase-to-your-repository)

### 1. Set up a repository to store your content

Before you connect Metabase to your Git repository, create a new repository. Supported providers include:

- [GitHub](https://docs.github.com/en/repositories/creating-and-managing-repositories/creating-a-new-repository)
- [GitLab](https://docs.gitlab.com/user/project/index.html#create-a-blank-project)
- [Bitbucket](https://support.atlassian.com/bitbucket-cloud/docs/create-a-repository/)
- [Local repo](#local-file-repositories): a bare git repo on your own filesystem.

Initialize the repo with a README.md.

Anyone who can push to this repository can change content in your synced Metabases, so [limit who has write access](#treat-write-access-to-your-repository-like-admin-access).

### 2. Create a token for your development Metabase

> Skip this step if you're using a [local repo](#local-file-repositories).

Create a personal access token with read and write repository access. Copy the token immediately; you won't be able to see the token again.

- **GitHub**: Create a [fine-grained personal access token](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens) with **Contents: Read and write** and **Metadata: Read-only** permissions.
- **GitLab**: In **User Settings** > **Personal access tokens**, [create a token](https://docs.gitlab.com/user/profile/personal_access_tokens/) with **read_repository** and **write_repository** scopes. Tokens have an expiration date (your admin may set a maximum lifetime).
- **Bitbucket**: In your Bitbucket repository, go to **Repository settings** > **Security** > **Access tokens** and click **Create access token**. Give it a name and, under **Scopes**, select:

  - **Repositories**: **Read** and **Write**
  - **Pull requests**: **Read** and **Write**

  Click **Create** and copy the token immediately, you can't view the token again after closing the dialog.

  The created token must have these scopes (visible in the **View access token** dialog after creation):

  - `repository`
  - `repository:write`
  - `pullrequest`
  - `pullrequest:write`

### 3. Connect your development Metabase to your repository

You can put any Metabase into Read-write mode. We also offer [Development instances](https://www.metabase.com/docs/latest/installation-and-operation/development-instance.md) that you can use for Remote sync or any other kind of development.

In the Metabase that you use for development:

1. Go to **Admin** > **Settings** > **Remote sync**. You can also click **Set up remote sync** at the bottom of the Data Studio sidebar.

2. Enter your repository URL:

   - For example, `https://github.com/your-org/your-repo` or `https://bitbucket.org/your-workspace/your-repo` (note the `https`). The repository must already exist and be initialized with at least one commit.

3. Select **Read-write mode**.

4. Add your access token:

   - Paste the personal access token (PAT) you created earlier. Make sure the token has [read and write permissions](#2-create-a-token-for-your-development-metabase). Metabase encrypts your token before storing it.

5. Test the connection:

   - Click **Test connection** to check whether Metabase can reach your repository. If the connection fails, make sure your token has the appropriate permissions and hasn't expired. If you copied the token incorrectly, generate a new one.
   - Metabase also checks the connection when you save your settings.

6. Choose what to sync:

   - Under **Collections to sync**, Metabase turns on the Library and **Transforms** for you.
   - To version questions, models, dashboards, and documents, turn on **Sync** for the collections that hold them. See [Syncing other collections](#syncing-other-collections).
   - If you started from the Data Studio sidebar, you won't see this section. You can choose your collections in **Admin** later.

7. Save your settings.

When you save, Metabase creates the Library if it doesn’t exist yet.

### 4. Push your changes to your repository

Once you've added content to your Library, a yellow dot appears next to the Library section that changed (for example, **Semantic layer**), indicating uncommitted changes.

1. At the top of the Data Studio sidebar, click the branch name and select **Push changes**.

2. (Optional) Describe your changes (e.g., "Published the Mammoth Populations table").

3. Click **Push changes** to commit and push your changes to your repository.

Check your repository. You should see a `collections` folder with the Library and a `databases` folder with your published tables.

By default, you push to your repository's main branch. You can choose (or create) a different branch so you can open pull requests for review. See [Branch management](#branch-management) for details on creating and switching branches.

### 5. Create a token for your production Metabase

Create a personal access token with read-only repository access. Copy the token immediately; you won't be able to see the token again.

- **GitHub**: Create a [fine-grained personal access token](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens) with **Contents: Read-only** and **Metadata: Read-only** permissions.
- **GitLab**: In **User Settings** > **Personal access tokens**, [create a token](https://docs.gitlab.com/user/profile/personal_access_tokens/) with **read_repository** scope only.
- **Bitbucket**: In your Bitbucket repository, go to **Repository settings** > **Security** > **Access tokens** and click **Create access token**. Under **Scopes**, select:

  - **Repositories**: **Read**
  - **Pull requests**: **Read**

  Leave Write and all other scope groups unchecked. Click **Create** and copy the token immediately.

  The created token must have these scopes (visible in the **View access token** dialog after creation):

  - `repository`
  - `pullrequest`

### 6. Connect your production Metabase to your repository

In your production Metabase:

1. Go to **Admin** > **Settings** > **Remote sync**.

2. Enter your repository URL:

   - Use the same repository as your development Metabase, for example, `https://github.com/your-org/your-repo` (note the `https`).

3. Select **Read-only mode**.

4. Add your access token:

   - Paste the read-only personal access token you created for this production Metabase.

5. Test the connection:

   - Click **Test connection** to check whether Metabase can reach your repository. If the connection fails, verify your token has the appropriate permissions and hasn't expired.
   - Metabase also checks the connection when you save your settings.

6. Sync your content:
   - Click **Pull changes now** to immediately sync content from your repository.
   - To keep your production Metabase automatically updated, toggle on **Auto-sync with git**. Metabase pulls changes from your main branch every five minutes.

A Read-only Metabase doesn’t create a Library of its own. It gets the Library from the pull.

At this point, you should be all set up. Exit Admin, then reload your browser. You should see the Library in your production Metabase.

## Syncing transforms

Remote sync versions your [transforms](https://www.metabase.com/docs/latest/data-modeling/transforms/transforms-overview.md), including their tags, tests, folders, and Python libraries. Some things to keep in mind:

- **Jobs don't sync.** Each Metabase keeps its own jobs. Tag your transforms with the built-in hourly, daily, weekly, or monthly tags so the matching built-in jobs run them on every Metabase, or create the jobs you need on each Metabase.
- **Built-in tags and the default `common.py` don't sync.** Only custom tags and Python libraries you've changed are tracked.
- **Transform syncing is all or nothing.** Metabase syncs your entire transforms namespace. You can't selectively sync specific transform folders.
- **You can't edit transforms in Read-only mode.** Keeping transforms read-only prevents unintended overwrites on subsequent pulls.
- **Use different databases for dev and production.** If you use transforms with Remote sync, your development and production Metabases should connect to separate databases that share _identical_ schemas. If you use the same database for both, dev transforms would also change production data.

## Local file repositories

Remote sync can point at a bare git repo on the same filesystem as your Metabase process, via a `file://` URL. Local repos come in handy for local development, especially alongside the [agent-driven development workflow](https://www.metabase.com/docs/latest/ai/agent-driven-development.md).

Create a bare git repo on the same filesystem as your Metabase process:

```sh
git init --bare /path/to/your-repo.git
```

Remote sync needs at least one commit on the repository. To add one, clone the bare repo, make an empty commit, and push it:

```sh
git clone /path/to/your-repo.git seed && cd seed
git commit --allow-empty -m "init" && git push origin HEAD:main
```

A bare repo is required because Remote sync pushes into it the same way it would push to a hosted remote. Non-bare repos refuse pushes to a checked-out branch.

### Point Metabase to your local repo

Use the `file://` scheme with an absolute path:

```
file:///absolute/path/to/your-repo
```

Note the three slashes: `file://` plus the leading `/` of the absolute path.

Leave the access token field blank. Local `file://` repositories don't need one.

If Metabase runs in Docker, you'll need to mount the directory as a volume and the **`file://` URL must use the container's path**, not the host path. Metabase's process runs inside the container and can only see paths visible from inside it.

With `docker-compose.yml`:

```yaml
services:
  metabase:
    image: metabase/metabase
    ports:
      - "3000:3000"
    volumes:
      - /Users/you/local-repo:/Users/you/local-repo
```

Then in Metabase, you'd enter:

```
file:///Users/you/local-repo
```

## An example dev-to-production workflow

Let's say your team wants to publish a new table and create a metric from it. Here's a workflow that ensures all production content goes through a review process.

### Step 1: Create a new branch

In your development Metabase, go to **Admin** > **Settings** > **Remote sync** and [create a new branch](#creating-a-branch) for your work, like `feature/megafauna-metric`.

### Step 2: Create content in your development Metabase

In Data Studio, publish the `Megafauna` table to the Library and add a measure to it. Create a metric called "Megafauna count" in the Library.

### Step 3: Push to your development branch

[Push your changes](#committing-and-pushing-your-changes) to `feature/megafauna-metric` with a commit message like "Add a Megafauna table and metric".

### Step 4: Create a pull request

In your Git repository:

1. Create a pull request from your branch, `feature/megafauna-metric`, to the main branch `main`.
2. Review the changes to the YAML files representing your published table, measure, and metric.
3. Someone who knows what they're doing approves and merges the PR.

### Step 5: Production automatically updates

On your production Metabase:

1. Within five minutes, Auto-sync detects the new commits on `main` (you can also manually pull the changes).
2. The published table and the "Megafauna count" metric appear in the Library.
3. The content is read-only (people can view and use it, but can't edit it).

## How the Library works in Read-write mode

### The Library in the UI

When the Library has unsynced changes, a yellow dot appears next to the Library section that changed (for example, **Semantic layer**). At the top of the Data Studio sidebar, click the branch name to push or pull changes.

In the main Metabase sidebar, the Library sections (Data and Metrics) show a sync icon to indicate that they are versioned.

### Moving and deleting Library content

When you remove content from the Library in Read-write mode and push that change, Metabase also removes the content from your production Metabase when it syncs. This applies to moving content out of the Library or deleting it entirely.

Content in other Metabases that depended on this item may break, because the dependency is no longer in the Library.

### Library content must be self-contained

Everything an item in the Library needs must be synced too. For example, Metabase won't let you move a metric to a synced Library if the metric is built on a saved question or model. The Library can't hold questions or models, so build the metric on a table instead.

## What Metabase syncs

Remote sync uses the same serialization format as the [Metabase CLI serialization feature](https://www.metabase.com/docs/latest/installation-and-operation/serialization.md), storing your content as YAML files in your Git repository.

**What syncs:**

- The Library's collection structure
- Published tables with their segments and measures
- Metrics
- [Data apps](https://www.metabase.com/docs/latest/data-apps/build.md#what-syncs-with-a-data-app). Metabase syncs the app's manifest, bundle, and collection, but ignores the app's source code. You (or your agent) commit all of these to the same repository, including the source code, so that you can edit the app over time.
- SQL snippets
- [Data actions](https://www.metabase.com/docs/latest/data-modeling/data-actions.md)
- The glossary
- Transforms, including tags, tests, folders, and Python libraries

If you [sync other collections](#syncing-other-collections), Metabase also syncs the questions, models, dashboards, documents, timelines, and events in those collections.

**What doesn't sync:**

- Users, groups, and permissions
- Alerts and subscriptions
- Database connections (see [Synced content that uses a database your Metabase doesn't have](#synced-content-that-uses-a-database-your-metabase-doesnt-have))
- Transform jobs
- Built-in transform tags and the default `common.py`
- Personal collections, and any other collections you don't [choose to sync](#syncing-other-collections)
- Table metadata (table names, column types, descriptions, visibility settings, etc.)
- A data app's live or draft status, and its group access

### Synced content that uses a database your Metabase doesn't have

Synced content points to databases by their display name, so give the database the same name on your development and production Metabases. If a pull brings in content that uses a database your Metabase doesn't have, Metabase creates a placeholder for that database, without connection details. In **Admin** > **Databases**, the placeholder's status is **Stubbed**. Questions and transforms that use the database can't run until an admin opens the stubbed database and enters its connection details. Once you save the connection details, the status changes to **Active**.

## Branch management

Branching is only available in Read-write mode.

### Creating a branch

You can create branches in Metabase or directly in your Git repository. Branches created in Git appear in Metabase once Metabase syncs with your repository.

Before creating branches, push an initial commit to your main branch.

To create a new branch in Metabase:

1. Go to **Admin** > **Settings** > **Remote sync**.
2. Under **Sync branch**, click the current branch.
3. Type a name for the new branch and click **Create branch "[name]"**.

The new branch is created from your current commit (not the latest commit from the remote), and Metabase switches to it.

### Switching branches

1. Go to **Admin** > **Settings** > **Remote sync**.
2. Under **Sync branch**, click the current branch and select a different branch. This will change the branch for everyone in your Metabase (see [limitations](#branching-limitations)).

If the branch doesn't appear, ensure it exists in your Git repository and that the name matches exactly (branch names are case-sensitive).

If you have unsynced changes, Metabase lists them and asks what to do:

- **Push changes to the current branch, [branch]:** Commits your changes to the current branch. You stay on that branch, so pick the other branch again afterward.
- **Create a new branch and push changes there:** Commits your changes to a new branch and switches you to it.
- **Delete unsynced changes (can't be undone):** Throws away your uncommitted changes and switches you to the branch you picked.

You can't switch to Read-only mode while you have unpushed changes.

### Branching limitations

- **Only admins can manage branches**. Non-admins don't see the branch controls.
- **The current branch is instance-wide**. This means that everyone on the same Metabase is on the same branch at the same time. You can't have different people working on different branches in a single Metabase.

Limiting a Metabase to a single branch at a time means that the typical Git feature-branch workflow is a bit different here: only admins can switch branches, create new branches, or push and pull changes. If you need multiple branches worked on simultaneously, the workaround is to spin up multiple Metabases in Read-write mode, one Metabase per branch.

These limits only apply in Metabase. In your Git repository, anyone with write access can create branches and push changes, and Metabase loads those changes when it pulls. See [Treat write access to your repository like admin access](#treat-write-access-to-your-repository-like-admin-access).

## Pushing changes to Git

You can only push changes in a Metabase with Remote sync set to Read-write mode.

### Committing and pushing your changes

When you make changes to the Library or to transforms, a yellow dot appears next to the section that changed (indicating uncommitted changes). To commit and push your changes:

1. At the top of the Data Studio sidebar, click the branch name and select **Push changes**.
2. (Optional) Describe your changes.
3. Click **Push changes** to push your changes to Git.

If the branch has new commits since you last pulled, Metabase asks how to handle them before it pushes yours: merge them with yours (when they don't conflict), push your changes to a new branch, or force push over them.

## Pulling changes from Git

You can pull changes when in Read-write or Read-only mode.

In Read-write mode, click the branch name at the top of the Data Studio sidebar and select **Pull changes**. Metabase imports the latest content from Git.

In Read-only mode, go to **Admin** > **Settings** > **Remote sync** and click **Pull changes now**.

If changes don't appear after pulling:

- Verify you're on the correct branch.
- Hard refresh your browser (Cmd/Ctrl + Shift + R).
- If you encounter sync errors, review error messages in the sync dialog, manually resolve conflicts in your Git repository, then pull again.

### Handling unsynced changes when you pull

If you have local uncommitted changes when you pull, Metabase lists them and asks what to do:

- **Merge the remote changes into your local content:** Only offered when the changes merge cleanly.
- **Create a new branch and push changes there:** Saves your work to a new branch.
- **Force push to [branch], discarding and overwriting everything (can't be undone):** Overwrites the remote branch with your local content.
- **Delete unsynced changes (can't be undone):** Throws away your uncommitted changes to accept what's in Git.

When in doubt, create a new branch and push changes to that branch. That way you won't lose any work.

### Pulling changes automatically

In Read-only mode, you can set Metabase to auto-sync changes from your main branch.

1. Go to **Admin** > **Settings** > **Remote sync**.
2. Turn on **Auto-sync with git**.

By default, Metabase pulls changes from the branch you specify every five minutes. You can also manually sync as needed.

## Syncing other collections

The Library can't hold questions, models, dashboards, or documents. To version them, sync the collections that hold them.

In your development Metabase:

1. Go to **Admin** > **Settings** > **Remote sync**.
2. Under **Collections to sync**, turn on **Sync** for each collection you want to version. The list has the Library, Transforms, and the top-level collections in Our analytics. If you use tenants, it also has your [shared tenant collections](https://www.metabase.com/docs/latest/embedding/tenants.md#collection-types).
3. Click **Save changes**.
4. [Push your changes](#committing-and-pushing-your-changes).

Your production Metabase gets these collections when it pulls, and they're read-only there. You can't change which collections sync on a Metabase in Read-only mode.

If a collection uses items from a collection that isn't synced, Metabase shows you what's missing when you save. You can sync those collections from there. See [Items in synced collections must be self-contained](#items-in-synced-collections-must-be-self-contained).

### Items in synced collections must be self-contained

The same rule that applies to the [Library](#library-content-must-be-self-contained) applies to any synced collection. Everything a dashboard or question needs must be inside one of the synced collections. This includes:

- Questions that reference other questions
- Dashboards with questions
- Click behaviors linking to other items
- Filters that pick values from other questions
- @ mentions of other items in documents

### Moving and deleting content in synced collections

When you remove content from a synced collection in Read-write mode and push that change, Metabase also removes the content from your production Metabase when it syncs. This applies to moving content out of a synced collection or deleting it entirely.

Content in other Metabases that depended on this item may break, because the dependency is no longer in a synced collection.

### Making sub-collections appear at the top level

Sometimes you might want synced content to appear at the top level of your navigation rather than nested under a synced collection. If you use [Tenants](https://www.metabase.com/docs/latest/embedding/tenants.md), you can accomplish that with synced shared collections.

If you aren't using tenants, you can use permissions to control how the collection hierarchy appears to different groups.

1. **Organize content in sub-collections of your synced collection**. For example, you might have `Analytics/Mammoth Statistics` and `Analytics/Giant Sloth Statistics`.

2. In your production Metabase, **set up permissions for embedded groups:** Groups should have:
   - **No view access** to the top-level synced collection itself
   - **View access** to specific sub-collections within the synced collection

For groups with these permissions, the sub-collections they can access appear at the top level of navigation, as if they were root-level collections. They won't see the top-level synced collection that you have in your development Metabase.

What you see in Read-write mode:

```
Collections
└── Analytics
    ├── Mammoth Statistics
    ├── Giant Sloth Statistics
```

What embedding groups see in Read-only mode (with no access to Analytics, but access to Mammoth Statistics and Giant Sloth Statistics):

```
Collections
├── Mammoth Statistics
└── Giant Sloth Statistics
```

## Disabling Remote sync

To disable Remote sync:

1. Go to **Admin** > **Settings** > **Remote sync**.
2. Click **Disable remote sync**.
3. In the confirmation dialog, click **Disable**.

- Metabase clears all Remote sync settings, including the repository URL, access token, and branch information.
- Your Library, transforms, and any other synced content remain in your Metabase (they're not deleted).
- Synced collections become regular collections that you can edit like any other collection.
- You can re-enable Remote sync later by reconnecting to a repository, but any changes you made after disabling can be overwritten when you enable sync again.

## Migrating existing content to Remote sync

If you already have content in your Metabase, you can adopt Remote sync gradually. Where the content goes depends on what it is:

- **Tables and metrics**: Publish the tables and move the metrics into the Library. These metrics can't depend on saved questions or models, since [Library content must be self-contained](#library-content-must-be-self-contained).
- **Questions, models, dashboards, and documents**: The Library can't hold these. To version them, [sync their collections](#syncing-other-collections). Everything they need must be in a synced collection too. See [Items in synced collections must be self-contained](#items-in-synced-collections-must-be-self-contained).

Content you don't sync stays as it is, and you can keep working with it normally.

### If you already have a repo with serialized Metabase data

Keep doing what you're doing.

If you want to switch fully to Remote sync, we recommend starting with a new repo:

1. Check out a new branch in your Metabase in Read-write mode.
2. Import your data to your Metabase with the serialization command as you normally would.
3. Publish the tables and move the metrics you want to sync into the Library, and [sync the collections](#syncing-other-collections) that hold your other content.
4. Push up your changes to the new repo.

Remote sync does NOT sync table metadata, so if you're importing and exporting your [table metadata](https://www.metabase.com/docs/latest/data-modeling/metadata/metadata-editing.md), you should stick with serialization.

## Further reading

- [Library](https://www.metabase.com/docs/latest/data-modeling/semantic-layer/library.md)
- [Transforms](https://www.metabase.com/docs/latest/data-modeling/transforms/transforms-overview.md)
- [Serialization](https://www.metabase.com/docs/latest/installation-and-operation/serialization.md)
