Copy and Move Apps

Use a package to copy a built App to another account or installation. Use a development copy to edit and test an App separately within the same account.

Choose how to copy

An imported package is a built App: edit its source in the development environment, then import a new package to update it. Importing does not create an editable Git copy.

Export a package

In the Apps list, open the App's ... menu, or open App settings > App actions, and choose the export option you need. Export uses the published version, or the latest Ready version if the App has not been published. Check that this is the version you intend to deliver. Developers can select a different Ready version through MCP export.

Export to another account is for accounts that share the same Knowi installation and App artifact store. It does not need portable-package signing keys or a rebuild for portability. The JSON file refers to the build; it does not contain the build's files.

Export to another server includes the build's files. It appears only where package signing is configured, and it needs a build made by a compatible builder. The destination must trust the signing key and support the build's platform and App features. Ask your administrator to complete the installation setup before transferring the ZIP.

A ZIP can be built in a development environment and installed on a separate customer system. That destination does not need access to the source Git host or cloud, an AI provider, or an App builder just to run it. If the App itself uses AI or another integration, that feature still needs its own configuration at the destination.

What a package carries

A package includes the build or its same-installation reference, the App's data requirements, sign-in branding, report-page definitions, and any declared managed-database schema. It lists secret names configured on the source App so you can enter their values at the destination. Add any other secrets the code needs too.

It does not copy source dataset rows, secret values, managed-database rows, Git credentials, sharing, custom domains, or Knowi menu placement. Configure destination connections and access before publishing. Write actions and other integrations also need configuration there; copying the App does not copy their credentials or grant permission to use them.

Import an App

A new import keeps the source access mode. For a Knowi sign-in App, the destination must have App sign-in configured before import; ask its administrator if the check fails.

1. Sign in to the destination account and open Apps. You need permission to create Apps; publishing is separate.
2. Select Import package and choose the JSON or ZIP file.
3. Select New app, then enter an App name and available URL slug.
4. For each dataset or dashboard, choose the destination resource the App should use. You must have access to it. Matching a source name or ID does not grant access.
5. Review the field check. Missing required fields block import. Type differences produce a warning; check that the App can use the destination values. Extra fields are allowed.
6. Select Import app.

The import creates a Ready version. It does not publish it. Open Data & actions and App settings to finish the checklist shown during import: configure write actions, ask your administrator to configure HTTP or workspace connections, enter secrets, and turn on managed storage if required.

Preview the App, check its access mode and sharing, then publish when ready. Test live integrations with controlled data; preview deliberately skips operations such as writes and email delivery. See preview versus live.

Use sample data

If real data is not ready, select Use sample data where no dataset is selected. This creates sample datasets from the package's known field names and types. It leaves datasets you already selected in place.

Sample data is optional and off by default during import. It requires datasource creation permission and works only for datasets with a known field structure, not dashboards. The default is 200 rows per dataset; the limit is 2,000. The rows are generated examples, not copied source data.

Use real destination data before publishing an App for production use.

Update an imported App

1. Export a new package from the App's development environment.
2. In the destination, select Import package and choose the file.
3. Select Update an imported app, then choose the App to update. You need write access to it.
4. Review its data connections. Existing connections are retained when their keys and types still match; select destinations for new or changed entries.
5. Select Update app, review the new Ready version, then publish it explicitly.

The existing live version keeps running until you publish the update. The destination keeps its App name, URL slug, access settings, and secret values. Review any new secret names, schema requirements, or integrations before publishing. Saved App data is not replaced by package data.

Create a development copy

Use this when you want to change an editable App without changing its original source branch or live version. The source must have a writable Git repository, App sign-in must be configured, and the copy stays in the same account. Packaged Apps cannot be used as editable source copies. Finish or reconcile newer source changes in the original before making a copy.

1. Open the source App's ... menu and select Create development copy.
2. Enter a name and available URL slug.
3. Choose data for the copy. Sample data is selected by default for unmapped datasets; turn it off and select real datasets if needed. Dashboards must be selected separately.
4. Review the checks and create the copy.

The copy starts from the published version, or the latest Ready version if none is published, on a new Git branch. It requires Knowi sign-in and is private to its creator until shared. It does not copy source secret values, saved App data, sharing, custom domains, menu placement, or embedding settings.

Edit through Knowi, an MCP assistant, or local Git. Configure separate secrets and storage if your tests need them. Build and preview the copy. You can publish it separately when you need to test live behavior without replacing the original App.

Prepare a live update

When the development copy is ready:

1. Select Prepare live update from its ... menu.
2. Review the latest Ready version and the original App's data connections. Select data for any new or missing connections.
3. Select Prepare update.
4. Open the original App, review the new Ready version, and publish it when approved.

The original keeps its data connections and secrets. Sample data from the copy is not copied back. Preparing an update advances the original Git branch and creates a Ready version; it does not publish it.

Start a new development copy after preparing an update, or if the original App changes. This prevents an older copy from overwriting newer source changes.

Troubleshooting

• A JSON package cannot find its build: use it in the same Knowi installation and artifact store. For a separate installation, export a ZIP instead.
• ZIP export asks for signing setup or a rebuild: ask the source administrator to configure signing and deploy compatible Apps services, then rebuild the App. Same-installation JSON export remains available.
• A ZIP fails signature verification: the destination administrator must trust the source's public signing key. Do not edit the ZIP; export it again if needed.
• The build's platform or features are unsupported: align the destination runtime and supported platform with the build. An AWS environment must meet these requirements too; see installation guidance.
• A data check fails: select an accessible destination dataset with the required fields, or create sample data when a field structure is available. Dashboards need a real destination selection.
• The imported App is read-only: this is expected for source code. Edit in its development environment and import an updated package.
• Preparing a live update reports that the original changed: finish or reconcile the newer source changes in the original, then create a fresh development copy and apply your changes there.