This page will walk you through how to export an application from one environment, and import it into another.
Exporting an application compresses it and its associated objects into a package that can be imported on other environments. This is typically done to move work from a development environment into a staging or production environment.
The links between related objects in the application are preserved when importing, but related objects are not exported by default unless they are already in the application. Appian Designer allows you to scan for missing precedents and add them to your application before export to ensure that your work functions properly when imported into a new environment.
Both export and import create an event in the News Feed. For imports, this event has the import log attached. Events for exports have both the export log and the exported package attached. By default, the user performing the export or import is the only viewer of the post, but they can add other users to it to share the logs or export package.
Exported packages will be automatically deleted after 30 days and will no longer be available for download as attachments. You can change the number of days before export package cleanup in the Admin Console Settings.
Applications that contain many objects may take a long time to export. You can navigate away or log out while the export is in progress, and the event will appear in the News Feed when the export is completed.
To combine multiple applications into the same export package, select all the applications from the applications list that you want to export together. These applications must all be on the same page of the applications list.
Deploying applications is covered in detail here.
A precedent is any object that an object relies on to function properly. For deployment to another environment to be successful, all precedents of application objects must either be exported with the application, or already be present on the target environment.
The missing precedents dialog allows you to scan the application for referenced objects that are used by the application, but not associated with the application. An initial scan is performed when the dialog is first opened. From the list of missing precedents, designers can add objects to the application, and run another scan. The Referenced By column in the grid displays the object or objects that require each of the missing precedents, so that designers can tell why the missing precedent appears on the list.
Not all missing precedents need to be added to the application. Objects in related applications are deployed with those applications, and do not need to be added even though they are precedents of objects in this application. To narrow the list to only precedents that need to be added, use the filter options below the grid:
Only save a filter option when the corresponding application will be kept up to date in all environments. For example, any missing precedents from your Common Objects Application should not be added to this application, as the Common Objects Application is intended as a library that other applications can use. Saving that application as a missing precedents filter ensures that you do not accidentally add its objects to your applications.
Selecting all the applications in the list shows only missing precedents that are in no applications. These should always be added to your application, or moved to another application. Setting up these filters correctly allows a designer to confidently add all remaining missing precedents to the application.
The following items are not identified as missing precedents during a scan of your application. Make sure to add these manually.
Once you've checked your application for missing precedents, you are ready to export.
The following steps will walk you through how to export and import an application:
Click the Download package link to download the zip file. If your application contains objects with environment specific or sensitive values, click the Download import customization file link. See this page for more information.
Designers create patches to deploy updates for existing applications. A patch is a collection of application objects, exported and imported from inside the application to modify it directly. Patches are used to enhance existing business solutions without creating new applications, and may include bug fixes, enhancements, or new application objects.
There are two ways you can create patches in Appian: by comparing an application across environments or by adding objects directly in the application view. If you have built out your infrastructure, we highly recommend comparing an application across environments to create your patches.
To compare objects across environments, contact your administrator to add environments in your infrastructure.
Comparing an application across environments allows you detect conflicts, check for missing objects, and inspect a package all before you export a patch.
There are 5 steps that the compare application wizard walks you through: Select Environment, Compare Objects, Review Patch, Inspect Patch, and Export Patch.
When you're ready to export a patch, you can compare an application across environments to easily review changes and catch any conflicts early on. Make sure you are in the correct application and check for missing precedents before comparing an application across environments.
To compare application objects:
a. Progress Bar: Highlights the current step of the compare application wizard.
b. Application Configuration Status: Displays the status of the application.
c. Object Status Filters: All application objects listed will have a status that you can filter by. For more information about object statuses, see this page.
d. Object List Refresh Button: Refresh the object list to see all recent changes.
e. Status Link: View a detailed comparison between the latest version of the object in each environment.
Once you have reviewed your changes in the object list you can add objects to your patch and continue with inspect and export. For more information about inspecting a package, see this page.
To add objects to your patch and export:
You can track the changes over time for specific objects by comparing versions.
It's best practice to build patches incrementally, so you don't spend additional time finding objects when you do decide to deploy.
To create a patch from the application view toolbar:
When you are ready to export, click EXPORT PATCH. From here, you can remove objects and rename your patch package. Click CLEAR PATCH CONTENTS to clear the entire patch and start over. You'll also see a checkbox to Keep patch contents after export, which is checked by default. Unchecking it will clear patch contents on export; the objects will remain a part of your application.
Exporting a patch posts an entry to the News feed just as exporting an application does. Only the author and the entry participants can see the entry.
On your target environment, navigate to the application you are patching and click IMPORT PATCH. Once you upload the patch, you can click INSPECT to check for any conflicted objects before you import. When you’re ready to proceed, click IMPORT. Importing your patch package here adds the objects directly to this application.
Importing a patch using the IMPORT option does not throw an error. The objects are added to the system, but are not added to any application. If this is done accidentally, re-import the patch inside the correct application.
Importing an application using the IMPORT PATCH option does not throw an error. The application is added to the system as normal, but all of its objects are also added to the application you patched. You can remove them by selecting the objects imported with the patch and using the REMOVE FROM APP option in the toolbar.
To export multiple patches from the applications list view:
The IMPORT option in the applications list handles both applications and patches for multiple applications. When you import a file that contains multiple patches, objects are added to the appropriate applications, depending on where they were patched from.