Application Lifecycle

Every application created in Appian goes through a similar lifecycle. Applications are typically created in a development environment, deployed to a staging environment for user acceptance testing or integration testing, and then deployed to the production environment.

Create an application

When a designer first begins building a new business solution, they start by creating a new application to hold and organize their work. They may also perform some basic setup, such as setting the security of the application or creating a folder structure for future design objects.

Build objects

Most of a designer's time is spent building, editing, and refining application objects. All new objects are created directly from the application, though the user may further edit and develop those objects in other designer interfaces.

Test for completeness

Designers usually test each piece of functionality for correctness as they work, checking that each new object behaves as expected. This is usually done with each object as it is developed, and Appian design interfaces provide feedback so that designers can quickly determine whether their object has been correctly configured.

Appian Designer provides tools for users to check whether they have all of the objects in their application that they need, and to understand the relationships between those objects to better visualize their functionality and have confidence that is has been built correctly.


When the application is complete, the user exports it, creating a compressed package that can be imported on the target environment to deploy their functionality.

Patches and incremental updates

After the initial deployment, designers perform maintenance or create enhancements to this business solution by continuing to work in the same application. The life cycle for these updates is similar, though a more thorough change management process should be followed for applications with existing versions already deployed to a production environment.

It is important to note that applications are not deployed in their entirety each time new functionality is introduced. Designers usually test each piece of functionality separately to ensure that each new feature behaves as expected. These incremental changes are deployed to testing and production environments as a patch.

A patch is a collection of design objects representing new and updated functionality for an application already in production. The most common uses for creating patches are:

  • Building functionality incrementally
  • Enhancing functionality already in production
  • Introducing new features
  • Applying bug fixes

Patches are created, exported, and imported directly within the context of the application being patched. Appian persists patch contents for each user, so you can build the patch as you are making changes in each application.

Open in Github

On This Page