A snapshot is the complete configuration of an Application captured as a portable JSON document. It contains every artifact that defines how the Application is wired, ports, pipelines, pipeline component source, custom function source, message types, schemas, maps, variables, constants definitions, NuGet package registrations, and routing, and it does not contain any of the transactions that have flowed through it. A snapshot describes how the system is set up, not what it has been doing.

The code artifacts travel with the rest. Because Pipeline components, Custom functions, and NuGet packages belong to the Application rather than to the platform, a snapshot carries their source and their registrations, and applying it into another environment brings the code across with the wiring.

Those references travel by name. A pipeline names the pipeline components it runs rather than pointing at an internal identifier, and because component and function names are unique inside an Application, the name is all that is needed to resolve the reference once the snapshot is applied to a target Application.

A snapshot is scoped to a single Application, its configuration, attached to that Application's snapshots list. It can be applied to put the configuration back in place, or exported as a JSON file to share, archive, or move to another environment.

Almost everything inside a snapshot travels as plain JSON. Two specific pieces are the exception: the values stored inside an application's Authentications, and the values held against its Constants. They are governed together by a single Credentials switch at snapshot time; turn it on and the snapshot is password-protected for those values, the same way a PDF can be password-protected. The same password is required to import them elsewhere.

Both go in or both stay out; there is no way to take one without the other. The password is asked for only when something is being encrypted, so with Credentials left off the snapshot is entirely plain JSON. Turn it on and a single password protects both members.

For the background on each of the two encrypted members, see Authentications and Constants.

Open the Snapshots panel to see every snapshot you have access to, both snapshots taken locally and snapshots imported from a file. Each snapshot lives attached to the Application it captures.

Each row in the list displays the following columns:

The list view follows the platform's Selected Application behavior, with an Application selected, the list filters to that Application's snapshots; with no selection, the list spans every Application you have access to and the Application column is shown.

From a row, the available actions are Apply, Export, and Delete. Above the list, a primary Take Snapshot button creates a new entry, and an Import Snapshot button brings in a snapshot file from disk.

Open the Snapshots panel and click Take snapshot.

1. Enter a Name. It is required and nothing is generated for you. The row already records when the snapshot was taken and by whom, so name it for what it captures.

2. Enter a Description. Also required: record the change you are about to make, or the state you want to be able to come back to.

3. Decide whether to include Credentials:

• Off, the snapshot captures configuration only and is entirely plain JSON.
• On, every Authentication object the Application owns and the current value of every Constant in it are both added to the encrypted payload. The two go together; there is no way to include one without the other. Constant definitions (names, descriptions, and every {{Constant.Name}} reference) travel in the clear regardless of this choice.

4. If Credentials is on, the dialog reveals two password fields. Enter a password and confirm it, the same as setting a password on a PDF. The same password is required to import the encrypted values elsewhere; applying the snapshot locally needs no password. Forget it, and an import still succeeds, just without the Authentications and Constants values.

5. Click Take Snapshot. The new snapshot appears at the top of the list, marked Taken in the Source column and tagged with your username under Created By. A lock indicator appears on the row if the snapshot contains an encrypted payload.

Applying a snapshot reconciles its contents with the configuration the target Application already holds. No password is needed, snapshots already in the list are decrypted in place when needed.

Every apply is governed by an apply policy you choose before it runs. The policy decides three cases for each item: an item in the snapshot the target is missing, an item present in both, and an item the target has that the snapshot does not.

• Overwrite, missing items are created and items present in both are overwritten with the snapshot's version; items the target has that the snapshot does not are left untouched. Pushes a known-good configuration onto a target without disturbing anything extra already there. Never deletes.
• Restore, the target is made to match the snapshot exactly, missing items created, items in both overwritten, and anything not in the snapshot deleted. The only policy that removes items. Returns the Application to precisely the captured state.
• Add missing, only items the target lacks are created; items present in both are left as they are, and extras are left untouched. Nothing existing is ever changed or removed. Introduces new artifacts from a snapshot without touching a running configuration.
• Prompt, the snapshot's items are listed one by one and you set each individually to Overwrite (take the snapshot's version) or Skip (keep what the target has). Items the target has that the snapshot does not are left untouched. For when no single blanket rule fits and you want to decide item by item.

1. Locate the snapshot in the list and click Apply on its row.

2. Choose the apply policy, Overwrite, Restore, Add missing, or Prompt. A confirmation dialog summarizes what the chosen policy will do to the target.

3. If you chose Prompt, work down the item list and set each item to Overwrite or Skip.

4. Confirm to proceed. The target Application is reconciled with the snapshot according to the policy.

Click Delete on the snapshot's row and confirm. The snapshot is removed from the list and cannot be recovered. Deleting a snapshot has no effect on the live configuration, it only removes that saved copy. If you may want it back later, export it to a file first.

Exporting writes a snapshot that is already in the list to a .json file you can store, send, or import into another environment. It packages only what was captured, so the order is take the snapshot first, then export it.

1. Click Export on the snapshot's row.

2. The dialog confirms which snapshot is selected, its Application, and whether it includes an encrypted payload. There is nothing to choose: the file carries exactly what the snapshot holds.

3. The encrypted payload travels exactly as it was sealed at snapshot time, under the password given then. No password is asked for at export, and the recipient needs the original one to import the encrypted parts. Without it the import still succeeds, minus Authentications and Constants values.

4. Click Export to File. Your browser downloads the snapshot as a .json file.

Importing brings a snapshot file from disk into the snapshots list. The file may have been exported from this environment or any other.

Import is not apply. Importing stores the snapshot JSON in the Application's snapshot repository and does nothing else. No artifact is created, no artifact is changed, and nothing is overwritten. The live configuration is untouched until you run Apply on the row, and what happens then is decided entirely by which of the four apply policies you pick.

1. Open the Snapshots panel and click Import Snapshot.

2. Choose the .json snapshot file from your computer.

3. Enter a Name and a Description. Both are required, and both are yours: the name and description the snapshot carried in the environment it came from are not kept, so this is where the file's provenance gets recorded.

4. If the file carries an encrypted payload, a password field appears once the file is selected, and Art2link ESB prompts for the password.

• Enter the correct password and click Import Snapshot to bring the snapshot in with its encrypted payload unsealed. The Authentications and the Constants values are held inside the stored snapshot, and reach the Application when you apply it.
• Or click Import Snapshot with the password field left empty (or with the wrong password). Art2link ESB asks whether you want to proceed without the encrypted payload. Confirm to store the structure only: the Authentication objects are discarded and the Constants carry no values, so applying it later leaves those value slots empty for an operator to fill in.

5. The snapshot appears in the list, marked Imported in the Source column and tagged with your username under Created By. It is a stored snapshot and nothing more at this point. Apply it from the list whenever you are ready.