Articles in this section

Plan an ILM development lifecycle

An integration lifecycle management (ILM) development lifecycle lets you build and test changes in one copy of an integration, and then promote them through each stage, such as development, QA, and production, by pulling and merging. Use this article to choose a lifecycle pattern before you set it up. Celigo recommends that you create environments to separate your development, test, and production integrations if you use ILM regularly.

How teams use ILM

ILM supports teams that work in parallel, test changes, and need to roll them back.

Clone a production integration into a development environment, and start building. Each clone is independent, so other integration specialists can work in their own clones without changing yours. Update a flow or API, test it in development, and create a snapshot whenever you want a restore point. When you're ready, pull the approved changes into the next environment, review the differences in the Review changes panel, and merge. Promote each change in sequence, from development to QA to production, rather than pushing directly to production. If something breaks after a promotion, revert to an earlier revision.

Cloning requires Manage access, and promotion happens through pulls, so ILM helps you control what reaches production. Each pull shows every change before you merge it. Have a user with Manage access to the production integration create and merge each pull.

ILM covers flows, APIs, and tools, including tools used as a step in a flow. See ILM supported resources and limits.

Why use multiple environments

Without multiple environments, you build several integrations in one environment. That works for a few integrations, but it gets confusing when one environment holds several versions of the same integration, such as development and QA. With multiple environments, you separate each stage into its own environment, track every stage, and reduce the risk of pulling changes into production by accident.

Each environment keeps its own isolated resources. To promote an integration into the next environment the first time, you clone it. After that, you pull changes.

Choose a lifecycle pattern

Pattern Use it when How changes move
Two environments (development and production) You have one development stage before production. From the development environment directly into production.
Three environments (development, QA, and production) You need a separate QA stage between development and production. Through the chain in sequence. You can't skip an environment.
One environment Your account doesn't have non-production environments. Through daisy-chained clones in a single environment.

If you clone an integration directly from development to production, you can't add a QA environment later and move changes from development to QA to production. The development and production integrations are already a direct clone pair, and a QA integration you add later isn't part of that chain.

To set up a pattern, see Practicing lifecycle management.

Example: one source integration and its clones

In this example, the original integration, Amazon-NetSuite, runs in production. You clone it to create integration A, named "Clone of Amazon-NetSuite." The original is the source, and integration A is the clone. To keep the two in sync, or to introduce changes, make and test a change in one integration, and then pull it into the other. In a development lifecycle, you make changes in the development integration and pull them into the production integration.

You can create several clones of the original. This helps when you maintain many integrations based on one common source. You introduce changes in the source and pull them into any of the clones.

One original integration and its clone.

One original integration with several clones.

Clones of clones.

For how a clone is created and configured, see Clone an integration for Integration Lifecycle Management (ILM).

Split work among teams or developers

You can separate work into development and QA teams by creating clones of each integration and granting each team access to its clones. Give developers Manage access only to the development integrations, and give the QA team Manage access only to the QA integrations. When development work is complete, the QA team pulls the changes into the QA integration for testing. When everything works, a user with Manage access to the original integration pulls the final changes into it.

To let developers work independently, assign a clone to each developer. When a developer completes a task, a user with Manage access to the original integration pulls the changes into it. Other developers then pull from the original to bring those changes into their own clones.

Legacy Production and Sandbox accounts

If you can switch between Production and Sandbox at the top of integrator.io, your account uses the legacy environment structure. In legacy accounts, the two environments share the same underlying resources, including connections, imports, exports, flows, scripts, and API tokens. A resource you create, edit, or delete in one environment appears immediately in the other. Use caution when you edit resources in either environment. This doesn't apply to accounts that use the multi-environment structure, where each environment keeps its own isolated resources.

You can still use ILM across Sandbox and Production in a legacy account. Develop and test changes in a Sandbox integration, and then pull the stable changes into your Production integration. Create your development and QA integrations in the Sandbox environment and your production integration in the Production environment.

ILM works the same way after you move to the multi-environment structure. See Upgrade to the multiple-environment structure.