---
title: "How to create plans that run a sequence of other plans"
canonical: "https://support.appfire.com/space/SUPPORT/89136324/How%20to%20create%20plans%20that%20run%20a%20sequence%20of%20other%20plans"
format: markdown
---
# Description

For complex build processes that entail multiple steps (both automatic and manual), often it is good practice to subset the build into sub-builds that handle more specific responsibilities and can be defined and tracked separately. This enables the entire process to be automated while making it easier to maintain and debug individual builds. More importantly, allowing good retry capabilities that smaller scale the the larger process. 

The Bamboo CLI queueBuild advanced support enables such a plan to be constructed easily using [Plan Creation Scripting](https://appfire.atlassian.net/wiki/spaces/BCLI/pages/65937621) and the CLI **runFromList** support.

The same technique can also be used to kick off builds on other Bamboo servers if you run multiple Bamboo servers.

We use techniques like this to build and release the [Appfire Command Line Interface (CLI)](https://appfire.atlassian.net/wiki/spaces/ACLI) to automate our release process that involves many steps and deliverables including artifact building, testing, documentation construction and uploads, deployments, and release uploads. 

# Example

```
-a createPlan   --plan MYPROJECT-MYPLAN --replace

... (other plan level definitions like triggers or similar)

# Queue other plans
-a runFromList --plan @plan@ \
                   --list  "BUILD1,   BUILD2,  BUILD3,   BUILD4,   BUILD5" \
                   --list2 ",         ,        --manual  --manual, ,     " \
                   --common "--plan @plan@" \
                   \
                   --input "-a addStage --stage @entry@ @entry2@" \
                   --input "-a addJob --stage @entry@ --job @entry@" \
                   --input "-a removeTask --job @entry@ --task @all" \
                   --input " \
                       -a addTask --job @entry@ --taskKey SCRIPT --description ""queue @entry@ wait"" \
                                  --field scriptLocation=INLINE \
                                  --field ""scriptBody = \
                                      acli.sh ${bamboo.localSite} -a queueBuild --wait \
                                          --plan MYPROJECT-@entry@ \
                                          --field started=${bamboo.planKey} \
                                          --field state=SUCCESSFUL \
                                  "" \
                   "
```

## Notes

| **Action** | **Description** |
| --- | --- |
| list | The first list is a list of builds that will be run. In this example, the project is the same for all the builds, so we just use the plan key in the list. Otherwise, include the project key in the name and adjust the script below to not reference the project. |
| list2 | Most complex processes need some manual decision points and stages. The second list controls whether the stage is automatic (blank entry) or manual (using the --manual parameter on the stage definition). |
| addStage, addJob | Each build is going to be kicked-off using its own stage with a single job. |
| removeTask | Optional and only needed if the plan has a repository defined for some other reason. The script task does not need to clone the repository and this removes the clone task that gets automatically added to jobs in plans that have a repository. |
| addTask | We use a script task to run the CLI action to queue the build. If you have [Run CLI Actions in Bamboo](https://appfire.atlassian.net/wiki/spaces/BCLIP) you could modify this to use Bamboo CLI task instead of a script task.<br>- This assumes you have an appropriate **acli.sh** start script (on your path) and configuration suitable for accessing your build servers (see [Getting Started with configuration for Mac and Linux](https://appfire.atlassian.net/wiki/spaces/ACLI/pages/60562817) or similar).
- Either hard code your build server name defined in your acli configuration or use a standard practice to refer to a global Bamboo variable that defines the local bamboo server. In this example, variable is named **localSite**.
- Note we use the **wait** parameter so the entire process is sequential and the results of the queued build are returned to the main build. |
| --filed started=... | This uses the advanced **queueBuild** feature that understands the status of the independent plan and whether or not it needs to be queued again based on if the plan was successfully run (likely with retries!!!) AFTER the main plan was started.<br>- This is a common technique for complex processes to take a long time to complete and may have glitches that need to be handled without having to start the process from the very beginning. Especially when debugging your complex process automation. |

> ✅ Recommend [CLI 8.7](https://appfire.atlassian.net/wiki/spaces/ACLI/pages/60562240) or higher. Older 7.x and 8.x releases support the similar capability with some minor modifications.