# Pipelines ## Getting Started -------------------------------------------------------------------------------- title: "Introduction" description: "Learn about the Catalyst ConvoKraft service that provides abilities to integrate powerful chat bot assistants in your Catalyst application." last_updated: "2026-09-08T11:23:56.916Z" source: "https://docs.catalyst.zoho.com/en/pipelines/getting-started/introduction/" service: "Pipelines" -------------------------------------------------------------------------------- # Getting Started # Introduction Pipelines is a continuous integration and continuous delivery (CI/CD) service offered by Catalyst that helps to streamline and automate your software development and deployment process. With Catalyst Pipelines, you can efficiently build, test, and deploy applications across various platforms and cloud environments. By providing scalable infrastructure, along with seamless integration with popular version control systems and other Catalyst services, the Pipelines service empowers development teams to deliver high-quality software faster, with reduced manual intervention and improved collaboration. Before delving into specifics, let us begin by exploring the general concepts of CI/CD. ### Continuous Integration Continuous Integration (CI) is a software development practice where any updates to the source code repository trigger an automated build process. This process produces deployable release artifacts that progress through the continuous delivery pipeline and are deployed to the designated environments. The key features of Continuous Integration include: **Version Control Integration** CI seamlessly integrates with version control systems like GitHub, GitLab, and Bitbucket. The source code repository is continuously monitored; whenever commits are pushed to the integrated system, the pipeline automatically initiates the compilation, build, and test processes. This ensures that the latest version of the application is always available. **Automated Builds and Testing** CI systems support concurrent builds, which reduces build waiting times and accelerates the overall development process. By running builds in parallel and testing them simultaneously, feedback on multiple code changes is provided more quickly, enhancing productivity and allowing developers to address issues sooner. After the build process, CI systems can automatically run a suite of tests on the new code to identify any issues or regressions. **Instant Feedback** Continuous Integration aims to provide swift feedback on code changes, empowering teams to rectify issues early in the development cycle. This process enhances software quality, minimizes risks, and facilitates faster delivery of new features. ### Continuous Delivery Continuous Delivery builds upon the Continuous Integration (CI) process by taking the deployable release artifacts and automatically deploying them to selected environments. This software engineering approach emphasizes automating the software delivery pipeline, ensuring rapid deployments with minimal manual intervention. The key features of Continuous Delivery include: **Automated Deployments & Environment Management** Continuous Delivery streamlines the deployment of code changes across various environments, including development, testing, staging, and production, ensuring consistent and reliable deployment procedures. It efficiently manages multiple environments with different configurations, allowing code changes to be deployed and tested in isolated environments before being pushed to production. **Incremental Updates & Faster Time to Market** CD enables the smooth delivery of small, incremental changes to production environments. By breaking updates into manageable segments, CD reduces the risks associated with large-scale deployments. This approach promotes quicker feedback loops, allowing for prompt identification and resolution of issues. Ultimately, Continuous Delivery accelerates the time to market for new features and enhancements, ensuring faster delivery of value to end-users. ### CI/CD in Catalyst Pipelines Catalyst Pipelines employs the CI/CD approach to automate the building, testing, and deployment of your applications to preferred environments. Whether you are developing web or mobile applications, you can effortlessly deploy them to any platform, including Catalyst AppSail, Amazon S3, Google Cloud Platform, Heroku, Microsoft Azure, Firebase, and more. Regardless of your programming language, Catalyst Pipelines supports seamless automation for application building and deployment. You can check out some common examples of deployment targets from this help page. You can fully leverage the Catalyst ecosystem in the following ways: * Deploy any application in Catalyst using the Catalyst AppSail service. * Deploy Catalyst applications built with the Catalyst Serverless Functions component to the Catalyst cloud. In both cases, you can seamlessly automate the entire process of building, testing, and deploying your application using the Catalyst Pipelines service. You can create the pipeline directly from the Catalyst console. Catalyst Pipelines are executed based on the YAML-based declarative code defined in the catalyst-pipelines.yaml file, where you must define the execution flow of the pipeline. You can define the flow by adding necessary components using our built-in YAML code editor or visual builder according to your specific needs. You can check out this help page to learn more about the pipeline components. For more details on configuring the pipeline, refer to this help page. You can choose to integrate your pipeline with any Git provider you prefer, such as GitHub, GitLab or Bitbucket, to automate the execution process. We will delve deep into this topic in this help page. You can also implement our Pipeline SDK methods in **Java**, **Node.js** and **Python** in your application, to fetch the details of the pipeline and execute a pipeline. Let us first understand the key advantages of using a pipeline in the next section. -------------------------------------------------------------------------------- title: "Benefits" description: "Learn about the Catalyst ConvoKraft service that provides abilities to integrate powerful chat bot assistants in your Catalyst application." last_updated: "2026-09-08T11:23:56.917Z" source: "https://docs.catalyst.zoho.com/en/pipelines/getting-started/benefits/" service: "Pipelines" -------------------------------------------------------------------------------- # Benefits **Expedite the software development lifecycle** Catalyst Pipelines automates the process of building, testing, and deploying code to selected environments, minimizing manual intervention and enabling rapid delivery of features to end-users. Furthermore, Catalyst pipelines accelerates the development process by providing prompt feedback to developers, facilitating quicker issue resolution and enhancing iteration speed and refinement. Ensuring Reliability and Minimizing Risk By employing automated deployment processes and testing procedures, Catalyst pipelines effectively mitigates the risk of deploying faulty code to production environments. This proactive strategy minimizes the likelihood of service interruptions and downtime. Automation significantly reduces the potential for human error during deployments, ensuring reliable delivery. Ultimately, these practices enhance the overall efficiency of the deployed source code. **Versatility in Development** Catalyst Pipelines facilitates the build process for a diverse range of programming languages, platforms, and tools, providing adaptability for developing, testing, and deploying applications. **Easily customizable & reusable configurations** The Catalyst Pipelines service uses a YAML-based declarative syntax for defining pipelines, allowing you to reuse pipeline definitions according to your needs. You can easily customize the workflow of the pipelines using our built-in YAML code editor or visual builder in the Catalyst console. **Scale up cost effectively** Catalyst Pipelines can handle projects of any size and complexity, from small personal projects to large enterprise-level applications due to its scalable infrastructure. This means it maintains workflow efficiency as the size of the codebase increases proportionally, without any increase in maintenance effort from your end. The automation process paves the way to cost savings in terms of time and resources. Additionally, earlier detection of bugs and issues can prevent costly rework later in the development cycle. **Automating workflows in the Catalyst ecosystem** Catalyst Pipelines seamlessly integrates with other Catalyst services, such as Catalyst Serverless Functions and Catalyst AppSail, enabling application development, streamlined workflow automation, and deployment within the Catalyst ecosystem. -------------------------------------------------------------------------------- title: "Usecases" description: "Learn about the Catalyst ConvoKraft service that provides abilities to integrate powerful chat bot assistants in your Catalyst application." last_updated: "2026-09-08T11:23:56.917Z" source: "https://docs.catalyst.zoho.com/en/pipelines/getting-started/use-cases/" service: "Pipelines" -------------------------------------------------------------------------------- # Use cases Here are some ideal use cases that showcase the versatility and efficiency of the Catalyst Pipelines service: 1. **Rapid Iteration for Startups :** For startups developing web applications, speed and agility are crucial. Catalyst Pipelines enables small teams to: * Quickly deploy new features and updates. * Automatically run tests before each deployment. * Roll back changes easily if any issue arises. * Maintain a stable production environment while experimenting with new ideas. This allows startups to stay competitive and responsive to market demands without sacrificing code quality or stability. 2. **Large-Scale Enterprise Deployments :** Enterprises managing complex web applications across multiple environments can leverage Catalyst Pipelines to: * Standardize deployment processes across teams and projects. * Coordinate deployments across staging, development, and production environments. * Manage A/B testing and other common testing methods at scale This ensures consistency, reduces human error, and streamlines the deployment pipeline for large organizations. 3. **DevOps Culture Enablement :** Organizations transitioning to a DevOps culture can use Catalyst Pipelines to: * Bridge the gap between development and operations teams. * Implement infrastructure-as-code practices. * Automate repetitive deployment tasks. * Provide real-time deployment status and metrics to all stakeholders. This fosters collaboration, increases transparency, and accelerates the software delivery lifecycle. 4. **Quality Assurance and Testing Automation :** QA teams can leverage Catalyst Pipelines to: * Automatically run comprehensive test suites before deployment. * Integrate various testing tools (unit, integration, performance, security). * Generate test reports and code coverage metrics. * Prevent deployments if critical tests fail. This ensures that only high-quality code makes it to production, reducing the risk of introducing bugs or security vulnerabilities. The possibilities are endless with Catalyst Pipelines as it supports a wide range of web application deployment scenarios. From small startups to large enterprises, and from simple websites to complex micro services architectures, the Pipelines service provides the tools necessary for efficient, reliable, and scalable deployments. -------------------------------------------------------------------------------- title: "Quick Start Guide" description: "Learn about the Catalyst ConvoKraft service that provides abilities to integrate powerful chat bot assistants in your Catalyst application." last_updated: "2026-09-08T11:23:56.917Z" source: "https://docs.catalyst.zoho.com/en/pipelines/getting-started/quick-start-guide/" service: "Pipelines" -------------------------------------------------------------------------------- # Quick Start Guide This section details the entire process of utilizing the Catalyst Pipelines service, from creating the pipeline and configuring it by defining the necessary components in a YAML file, to executing the pipeline. Let us have a look at the steps in detail: 1. **Create a Catalyst project:** Access the Catalyst console to create a new project. After the project creation is done, you will be able to access the Catalyst Pipelines service in the console. You can also explore other Catalyst services from the console. 2. **Create a pipeline:** In the Catalyst Pipelines service, you can create a pipeline directly from the console. Refer to his help page to know the detailed steps to create a pipeline. * **Connect an Integration Source** - When creating a pipeline, you can choose to integrate it with any Git provider, such as GitHub, GitLab, or Bitbucket. To enable this, you need to configure the pipeline execution flow in the catalyst-pipelines.yaml file and commit this file to the integrated Git provider repository. This setup will automatically trigger the pipeline whenever changes are pushed to the linked repository. When the pipeline is triggered, the complete source code from the integrated Git repository, along with the YAML file, will be automatically fetched and downloaded as a ZIP file to Catalyst. Note that this integration is optional. Note: You can also create the pipeline without integrating it with an external repository. In that case, you will need to manually trigger the pipeline every time from the Catalyst console. 3. **Configure the pipeline:** You can configure the pipeline execution flow by defining necessary components like stages, jobs, runners, images, conditions and variables based on your requirements in the catalyst-pipelines.yaml. You can use our built-in YAML code editor or visual builder for this purpose. Refer to this page for more details on configuring the pipeline. 4. **Commit the catalyst-pipelines.yaml file:** This step applies only if you have linked an integration source with the pipeline during its creation. Once you have finished configuring the pipeline, you need to commit the catalyst-pipelines.yaml file to any preferred branch in your source repository. The YAML file will be committed to the branch in the selected integration source from **Step 2**. It is mandatory to commit the YAML file each time any changes are made to the pipeline flow. Note: If you have not connected the pipeline with an integration source, you can skip this step and proceed to execute the pipeline. 5. **Execute the pipeline:** After configuring the pipeline, you can initiate its execution directly from the Catalyst console. If the pipeline is linked to an integration source, it will automatically execute whenever any changes are pushed to the linked repository. Additionally, you can monitor the execution status and access detailed logs of the pipeline execution using the **Basic** and **Advanced** tabs within the **Execution History** section of the console. We will discuss this in detail in this help page. ## Help Components ### catalyst-pipelines.yaml -------------------------------------------------------------------------------- title: "Introduction" description: "Learn about the Catalyst Pipelines service and the basics of YAML schema definitions." last_updated: "2026-09-08T11:23:56.925Z" source: "https://docs.catalyst.zoho.com/en/pipelines/help/catalyst-pipelines.yaml/introduction/" service: "Pipelines" related: - Pipeline Triggers (/en/pipelines/help/triggers/introduction) -------------------------------------------------------------------------------- # catalyst-pipelines.yaml # Introduction The catalyst-pipelines.yaml file serves as the core component for executing the pipeline, where we define its workflow. You can define the execution flow of the pipeline in this file by adding the required pipeline components using our built-in code editor or visual builder. You can check out this help page to learn more about configuring the pipeline. Whether the pipeline is triggered manually or automatically, this file dictates the pipeline's actions. If your pipeline is linked to a version control system, any modifications to the source code in the linked repository automatically trigger the pipeline execution, running the workflow defined in this file. Similarly, when the pipeline is triggered manually from the Catalyst console, this file is executed directly from the console interface. Before delving into the pre-defined YAML schema definitions of Catalyst Pipelines and its usage, let's take a moment to explore YAML in broader terms. A YAML file is a versatile format for representing structured data across various contexts, such as configuration files, data interchange, and serialization. The common characteristics of a YAML file include : * YAML is not tied to any specific programming language, making it suitable for exchanging data between different systems and platforms. * This file comprises of simple key-value pairs, lists, and maps, which can be combined and nested to represent complex data structures and configurations. * It uses indentation to define the structure of data. * YAML supports various data types, including scalars (strings, integers, floats, booleans, null), lists, maps (key-value pairs), and nested structures. Catalyst Pipelines follows its own YAML schema standards, which must be strictly followed when configuring the pipeline. In the next section, we'll delve deeper into the Catalyst YAML schema definitions. -------------------------------------------------------------------------------- title: "Schema Reference" description: "Learn in detail about the pre-defined schema definitions of the catalyst-pipelines.yaml file." last_updated: "2026-09-08T11:23:56.925Z" source: "https://docs.catalyst.zoho.com/en/pipelines/help/catalyst-pipelines.yaml/schema-reference/" service: "Pipelines" -------------------------------------------------------------------------------- # Schema Reference The YAML schema reference for Catalyst Pipelines outlines the pre-defined keys for various components of the pipeline. By using these keys, you can incorporate the necessary components and define the execution flow of the pipeline. We will be discussing the components in detail in their respective help pages. You can get started from here. Refer to this page to learn more about configuring the pipeline from the Catalyst console. ### YAML Definitions Here's the list of keys supported in Catalyst for the catalyst-pipelines.yaml file. <table class="content-table"> <thead> <tr> <th>Keyword</th> <th>Description</th> </tr> </thead> <tbody> <tr> <td>version</td> <td>The pipeline version can be defined as any integer value, serving the purpose of preserving pipeline configurations as distinct and reusable versions.</td> </tr> <tr> <td>runners</td> <td>A runner is a virtual machine configuration that can be defined at the stage level or job level. You can define the runner specification as a value of the config-id key in runners. Learn more about this detail from this help page.</td> </tr> <tr> <td>images</td> <td>An image is a package or set of dependencies required for the execution of jobs in the pipeline. Images can be defined at the stage level or job level. You can define the name of the image in the image key and the URL of the external package registry (like Dockerhub) in the registry key. You must also define the auth key to authenticate the specified registry. Learn more about this detail from this help page. </td> </tr> <tr> <td>auth</td> <td>To authenticate any external registry accounts and pull the required packages for job execution, you will need to specify the username and password keys in the auth key. You can refer to this help section to know more about this.</td> </tr> <tr> <td>variables</td> <td>This keyword is used to store placeholder values at the pipeline level or job level. Check out this help page for more details.</td> </tr> <tr> <td>steps</td> <td>They are a set of commands that can be defined to carry out the build, test, and deploy processes in the pipeline. You can define the steps based on the applications you build, the testing procedures for it, and the environments in which the application has to be deployed. Refer to this help page to learn more about steps.</td> </tr> <tr> <td>jobs</td> <td>A job is a sequence of steps defined in a stage. You can define up to five jobs within a stage, and under each job, you can define steps, variables, runners, and images using the jobs key. If you have configured the pipeline to build your application before testing or deploying it, you can temporarily store the generated build files of your code in the Catalyst Stratus service. These configurations can be defined using the artifacts key. This key includes two other sub-keys named notify and approve. You can learn more about this in detail from this help page. </td> </tr> <tr> <td>notify</td> <td>This key allows you to send notifications either at the start of job execution or upon successful completion of the job. You can use the on-start or on-end keys for this purpose. Check out this help section for more details.</td> </tr> <tr> <td>approve</td> <td>This key is used for approval jobs to define the details of the job reviewer and the custom approval message. You can set the approval type using the type-name sub-key and add the email address of the reviewer and a custom review message in the type-variables key that includes the reviewers and message sub-keys, respectively. </td> </tr> <tr> <td>artifacts</td> <td>This key is used to represent the upload and download process of the application build files generated during pipeline execution. For this, you can set the values in the upload and download keys respectively. You can learn more about artifacts from its help page. </td> </tr> <tr> <td>upload</td> <td>This key is used to store the generated build zip files in the Catalyst Stratus service. You must define the name of the build file, the location in which the file has to be stored, and other file conditions using the name, location, and files sub-keys respectively.</td> </tr> <tr> <td>download</td> <td>This key can be used to retrieve the stored build zip files from the Catalyst Stratus service. You can also define the name, location, and files sub-keys similar to the upload keyword.</td> </tr> <tr> <td>stages</td> <td>A stage is a distinct phase that contains multiple jobs in it. You can define up to five stages in a pipeline, each containing a set of jobs. You can also define runners and images at the stage level.</td> </tr> <tr> <td>when-equal</td> <td>This key can be used to evaluate whether two values exactly match with one another and proceed with the specified execution flow of the pipeline, only if the validation holds true.</td> </tr> <tr> <td>when-not</td> <td>This key can be used to evaluate whether a particular condition is either true or false. Based on the result of the evaluation, the defined pipeline flow will be executed.</td> </tr> <tr> <td>when-not-equal</td> <td>This key can be used to evaluate whether two values do not match with one another, then proceed with executing the defined pipeline flow.</td> </tr> <tr> <td>when-and</td> <td>This key can be used to evaluate whether the two conditions defined in the and key hold true. If yes, then the flow defined in the when condition gets executed.</td> </tr> <tr> <td>when-or</td> <td>This key can be used to evaluate whether either one of the conditions defined in the or key holds true. If yes, then the pipeline flow defined in the when key gets executed.</td> </tr> <tr> <td>pipeline-when</td> <td>The conditional logic that can be defined at the pipeline level, which dictates the execution flow of the whole pipeline. You can use the and, equal, or, not, not-equal key along with the pipeline-when condition.</td> </tr> <tr> <td>pipeline-runner</td> <td>This key can be used to define a runner at the pipeline level, which is accessible across all stages and jobs.</td> </tr> <tr> <td>pipeline-image</td> <td>This key can be used to define an image at the pipeline level, which is accessible across all stages and jobs.</td> </tr> </tbody> </table> Note: When defining the pipeline execution flow in the pipeline-image file, ensure to utilize the exact keywords designated by Catalyst as keys and assign the corresponding data to each key. -------------------------------------------------------------------------------- title: "Implementation" description: "Learn about the step-by-step instructions to configure the pipeline directly from the Catalyst console." last_updated: "2026-09-08T11:23:56.926Z" source: "https://docs.catalyst.zoho.com/en/pipelines/help/catalyst-pipelines.yaml/implementation/" service: "Pipelines" related: - Runners (/en/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/runners) - Images (/en/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/images) - Artifacts (/en/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/artifacts) - Variables (/en/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/variables) - When-condition (/en/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/when-condition) - Steps (/en/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/steps) - Jobs (/en/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/jobs/introduction) - Stages (/en/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/stages/introduction) - YAML Schema Reference (/en/pipelines/help/catalyst-pipelines.yaml/schema-reference) - Pipeline Triggers (/en/pipelines/help/triggers/introduction) -------------------------------------------------------------------------------- # Implementation You can build a pipeline using the built-in visual builder or code editor directly from the Catalyst console. Please ensure to follow the below listed steps: Let us begin by configuring the pipeline using the code editor. 1. After you create the pipeline, the code editor opens automatically. A basic YAML code will be pre-defined in this file, you can start updating it as required. 2. In the Assistant panel on the right, click **Add Variable**. Enter the key-value pairs and click **Generate**. 3. Click **Add to Code**. The variables are now added in the YAML code. 4. Now, let us add the required images for the pipeline execution. Click **Create Image**. In the **Create Image** pop-up, enter the Image Variable name, image name, the registry URL, the username and password of the registry. Click **Generate**. Click **Add to Code**. The image is now added in the YAML code. 5. Click **Add Runners**. Enter the runner name and choose the runner configuration. You can learn more about runner configurations from this help page. Click **Generate**. Click **Add to Code**. The runner is now added in the YAML code. 6. Let us now add the required jobs for the pipeline. Click **Add Job**. Provide a name for the job. You can create the job using any one of the following options: * **Create using Steps** : This option allows you to define your own set of commands in the script editor below. You can select the required runner and image configurations for the job. Add the path of the current working directory as shown below. Click **Generate**. * **Create using Approvals** : This creates an approval job for the pipeline. Select the required approver email address and enter a message as shown below. Click **Generate**. * **Create using Templates** : This creates the jobs using the pre-defined templates available in Catalyst. If your use case fits into any of these operations, you can directly choose the template. Click **Generate**. Click **Add to Code** and the job will be added to the YAML. 7. Now, let us define the stages of the pipeline. Click **Add Stage**. Provide the stage name and select the required jobs for the stage. Click **Show Advanced Options** and enable **Checks** if you need to add any conditional logic within the stage execution. You can add checks as shown below and click **Add to Stage**. Click **Generate** and click **Add to Code**. The stage is now added in the YAML code. Once you have completed configuring the YAML, you can click **Save**. When you need to save your configurations partially and continue editing them later, you can click **Save as Draft**. You can choose the branch in which the YAML file has to be committed as shown in the screenshot below and click **Commit**. Enter the commit message and click **Commit**. The catalyst-pipelines.yaml file will be updated in your Git repository. Similarly, you can configure the same pipeline using the visual builder. First, switch to the **Builder tab** as shown in the screenshot below. The drag-and-drop builder interface will open automatically. Here, you can simply drag and drop the components and follow the same steps as mentioned above. After configuring the YAML for the first time, you can make changes anytime by clicking on **Configure YAML**. You can also add global variables that are accessible throughout the pipeline by simply clicking on **Global Variables**. Add the variable name as key and its corresponding value. Click **Save**. We will be discussing executing the pipeline in the next section. #### Build a Pipeline -------------------------------------------------------------------------------- title: "Runners" description: "Learn about the Catalyst Pipelines runners in detail, the associated keywords and sample code snippets." last_updated: "2026-09-08T11:23:56.926Z" source: "https://docs.catalyst.zoho.com/en/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/runners/" service: "Pipelines" related: - Configure the Pipeline (/en/pipelines/help/catalyst-pipelines.yaml/implementation) -------------------------------------------------------------------------------- # Build the Pipeline In this section we will be discussing about the various pipeline components in detail, their usage in the catalyst-pipelines.yaml file, how to incorporate these components directly from the Catalyst console and build a Catalyst pipeline. Let us get started! # Runners ## Introduction A runner is an agent or computing resource that executes the jobs defined in a pipeline. Catalyst runners offer a robust and flexible infrastructure for efficiently and reliably building, testing, and deploying software applications. You can define the required runners for the pipeline as key-value pairs using the runners keyword. The runner configurations supported by Catalyst Pipelines are listed below: <table class="content-table"> <thead> <tr> <th>Runner config</th> <th>RAM Storage</th> <th>CPU Capacity</th> <th>Disk Space</th> </tr> </thead> <tbody> <tr> <td>Low</td> <td>1 GB</td> <td>0.8 vCPU</td> <td>2 GB</td> </tr> <tr> <td>Medium</td> <td>2 GB</td> <td>1.2 vCPU</td> <td>4 GB</td> </tr> <tr> <td>High</td> <td>4 GB</td> <td>2.0 vCPU</td> <td>8 GB</td> </tr> </tbody> </table> Note: 1. Defining a runner is not mandatory. If a runner is not specified, the medium config runner is taken by default to execute the jobs. 2. You can define runners at the pipeline level, stage level, or job level. In case of multiple definitions, the one specified at the lowest level (i.e., job) takes precedence. ### Properties of a Runner <table class="content-table"> <thead> <tr> <th>Key</th> <th>Value</th> <th>is Mandatory</th> </tr> </thead> <tbody> <tr> <td>Runner name (The runner variable name used to access the runner)</td> <td></td> <td>Yes</td> </tr> <tr> <td>config-id</td> <td>The ID of the required runner configuration. Low = config-id : 1<br/> Medium = config-id :2<br/> High = config-id : 3 </td> <td>Yes</td> </tr> </tbody> </table> ### YAML Code Snippet for Runner runners: runner1: config-id: 2 runner2: config-id: 3 ### Global Configuration You can also define the runners at the pipeline level, if required. This runner configuration will be accessible to all the stages and jobs. You can configure a runner at the pipeline level as follows: pipeline-runner:runner1 -------------------------------------------------------------------------------- title: "Images" description: "Learn about the Catalyst Pipelines images in detail, the associated keywords and sample code snippets." last_updated: "2026-09-08T11:23:56.926Z" source: "https://docs.catalyst.zoho.com/en/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/images/" service: "Pipelines" related: - Configure the Pipeline (/en/pipelines/help/catalyst-pipelines.yaml/implementation) -------------------------------------------------------------------------------- # Images # Introduction An image is an executable package that contains dependencies needed to run a job in the pipeline. Catalyst Pipelines seamlessly integrates with container registries such as Docker Hub or other private registries to pull images and dependencies during the pipeline execution. You can pick from a wide range of images supporting varied operating systems, programming languages, frameworks, and tools to suit your specific requirements. Additionally, using predefined images ensures consistency and reproducibility across different stages of the pipeline and environments. You can pull images by specifying the container registry URL explicitly using the registry key. If the registry URL is not defined, the images are pulled from the Dockerhub container by default. You can define the required images for the pipeline using the images key. ### Properties of an Image <table class="content-table"> <thead> <tr> <th>Key</th> <th>Value</th> <th>is Mandatory</th> </tr> </thead> <tbody> <tr> <td>Image Variable Name</td> <td>The image variable name used to access the image</td> <td>Yes</td> </tr> <tr> <td>image</td> <td>The name of the image</td> <td>Yes</td> </tr> <tr> <td>registry</td> <td>The URL from which the image has to be fetched.</td> <td>No</td> </tr> <tr> <td>auth</td> <td>Contains the username and password keys.</td> <td>Yes</td> </tr> <tr> <td>auth</td> <td>Contains the username and password keys.</td> <td>Yes</td> </tr> <tr> <td>username</td> <td>The account username credential of the specified registry.</td> <td>Yes</td> </tr> <tr> <td>password</td> <td>The account password credential of the specified registry.</td> <td>Yes</td> </tr> </tbody> </table> Note: 1. Defining an image is not mandatory. If an image is not specified, the default Ubuntu image with Catalyst CLI pre-installed is taken by default to execute the jobs. 2. You can define images at the pipeline level, stage level, or job level. In case of multiple definitions, the one specified at the lowest level (i.e., job) takes precedence. 3. If the same image is specified for two jobs within a stage, the cached image will automatically be reused for the second job, enhancing performance speed. 4. If the image name is specified and the registry URL is not given, then make sure to provide the username and password credentials of your Dockerhub account in the auth key. The image will be pulled from DockerHub by default. For security reasons, we highly recommend you store your password information as a variable in the global configuration and access it using << env.{variable_name} >> in the catalyst-pipelines.yaml file. You can refer to this help section to learn how to configure variables globally from the console. ### YAML Code Snippet for Image Here's an example code snippet for images that can be defined in a pipeline: images: testImage1: image: node:18 registry: my.private.registry.com auth: username: ameliab password: zylker@123 testImage2: image: node:20 auth: username: ameliab password: zylker@123 The above code snippet illustrates the following: * Two images are defined in the pipeline(testImage1 and testImage2). * The testImage1 uses the node18 dependencies from the defined registry URL. We have added the authentication credentials for the registry to the keyword auth. * By default, since the registry is not specified, the testimage2 uses the node20 dependencies from Dockerhub. ### Global Configuration You can also define the image at the pipeline level, if required. This image configuration will be accessible to all the stages and jobs. You can configure an image at the pipeline level as follows: pipeline-image: image1 -------------------------------------------------------------------------------- title: "Variables" description: "Learn about the Catalyst Pipelines variables in detail, the associated keywords and sample code snippets." last_updated: "2026-09-08T11:23:56.926Z" source: "https://docs.catalyst.zoho.com/en/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/variables/" service: "Pipelines" related: - Configure the Pipeline (/en/pipelines/help/catalyst-pipelines.yaml/implementation) -------------------------------------------------------------------------------- # Variables # Introduction A variable is a placeholder value that can be defined at the job level or pipeline level as required. You cannot define a variable at the stage level. You can define the required variables for the pipeline as key-value pairs using the variables key. ### Properties of a Variable <table class="content-table"> <thead> <tr> <th>Key</th> <th>Value</th> <th>is Mandatory</th> </tr> </thead> <tbody> <tr> <td>Variable Name</td> <td>Specify a string value for the variable</td> <td>Yes</td> </tr> </tbody> </table> ### YAML Code Snippet for Variable You can declare a variable at the job level in the catalyst-pipelines.yaml file using the below syntax: variables: target:'app3.1' ### Global Variables You can define a variable at the pipeline level directly from the console. Refer to this help page to know the exact steps to create a variable. Note: You must mandatorily set a global variable named CATALYST_TOKEN and input the token generated from your Catalyst CLI, in case you have used Catalyst CLI in the pipeline execution. To fetch your token, please refer to the steps mentioned in this help section. ### Access the Variable A variable can be accessed by using any of the following methods: * **<< variables.{variable_name} >>** : This can be used to access any variable defined at the job level. * **<< event.{variable_name} >>** : This can be used to access any variables passed in the event JSON while triggering the pipeline manually from the console. * **<< env.{variable_name} >>** : This can be used to access variables defined at the pipeline level. -------------------------------------------------------------------------------- title: "When Condition" description: "Learn about the Catalyst Pipelines conditions in detail, the associated keywords and sample code snippets." last_updated: "2026-09-08T11:23:56.926Z" source: "https://docs.catalyst.zoho.com/en/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/when-condition/" service: "Pipelines" related: - Configure the Pipeline (/en/pipelines/help/catalyst-pipelines.yaml/implementation) -------------------------------------------------------------------------------- # When Condition # Introduction The when condition is a basic logic that can be configured to define the execution flow of the pipeline. You can define the when condition at the stage level, job level, or the pipeline level. It is important to note that the when condition can be applied at any of these levels, and the order of the components is not significant. The following operators can be used along with the when condition: ### when-equal when: equal: - << status.build.package >> - success when-not-equal ### when-not-equal not-equal: - << status.build.package >> - failed ### when-not when: -not:true ### when-and/when-or when: or: - and: - equal: - << pipeline.status.build >> - success - not-equal: - << pipeline.status.build.hello-world >> - failed - equal: - << pipeline.event.{{Event Variable Placeholder}} >> Note: You will not be able to configure when conditions for approval jobs. ### Global Configuration You can define a when condition at the pipeline level, if required. This condition solely determines the pipeline execution flow. You can configure the condition as follows: pipeline-when: equal: - << event.ref >> - refs/heads/main -------------------------------------------------------------------------------- title: "Steps" description: "Learn about the Catalyst Pipelines steps in detail, the associated keywords and sample code snippets." last_updated: "2026-09-08T11:23:56.927Z" source: "https://docs.catalyst.zoho.com/en/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/steps/" service: "Pipelines" related: - Configure the Pipeline (/en/pipelines/help/catalyst-pipelines.yaml/implementation) -------------------------------------------------------------------------------- # Steps # Introduction A step is the smallest building block of a pipeline. They are a set of commands to be executed to build, deploy, or test the source code. You can define the steps for your job, by adding the commands using a hyphen (-). You can define the steps for the pipeline using the steps key. ### YAML Code Snippet for Steps steps: - ls - >- catalyst deploy appsail --name spring-boot --build-path "/catalyst/SNAPSHOT.jar" --stack java17 --platform javase --command "sh -c 'java -jar SNAPSHOT.jar --server.port=\${X_ZOHO_CATALYST_LISTEN_PORT}'" --verbose -------------------------------------------------------------------------------- title: "Artifacts" description: "Learn about the Catalyst Pipelines artifacts in detail, the associated keywords and sample code snippets." last_updated: "2026-09-08T11:23:56.927Z" source: "https://docs.catalyst.zoho.com/en/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/artifacts/" service: "Pipelines" related: - Configure the Pipeline (/en/pipelines/help/catalyst-pipelines.yaml/implementation) -------------------------------------------------------------------------------- # Artifacts # Introduction An artifact is a file or zip generated upon the application build process during the execution of the pipeline. These artifacts are deployable entities, which include infrastructure and apps. You can store and retrieve the artifacts during the pipeline execution in the Catalyst Stratus service. There are two types of artifacts : * **A single artifact file :** This build file can be directly uploaded to a bucket in Catalyst Stratus and then downloaded when required. * **An artifact zip :** This type includes configuring regular expressions to pick the relevant files, zip them and upload to a bucket in Catalyst Stratus and then download the zip when required. You can define the required artifacts for the pipeline as key-value pairs using the artifacts key. These artifacts can be included as a part of the jobs created using steps, in the Catalyst console. You can refer to this help section to learn more about artifact configuration in jobs. However they are not applicable to parallel and approval jobs. ### Properties of an Artifact #### Upload <table class="content-table"> <thead> <tr> <th>Key</th> <th>Value</th> <th>is Mandatory</th> </tr> </thead> <tbody> <tr> <td>upload</td> <td>This key contains the configurations required for the artifact upload process.</td> <td>Yes</td> </tr> <tr> <td>type</td> <td>Provide the value as either file or zip.</td> <td>Yes</td> </tr> <tr> <td>name</td> <td>The name of the artifact. (file name or zip name) For example : SNAPSHOT.jar (for file type) Build.zip (for zip type) </td> <td>Yes</td> </tr> <tr> <td>file</td> <td>The source path of the artifact file. For example : target/demo-0.0.1-SNAPSHOT.jar </td> <td>Yes (if the artifact type is file)</td> </tr> <tr> <td>regex</td> <td>The regular expression pattern that identifies files and compresses all the matching ones. For example : - /catalyst/node_modules/**/ </td> <td>Yes (if the artifact type is zip)</td> </tr> <tr> <td>location</td> <td>The location path in Stratus where the file or zip has to be uploaded. For example : stratus://<<env.BUCKET_NAME >>/ (destination) </td> <td>Yes</td> </tr> </tbody> </table> #### Download <table class="content-table"> <thead> <tr> <th>Key</th> <th>Value</th> <th>is Mandatory</th> </tr> </thead> <tbody> <tr> <td>download</td> <td>This key contains the configurations required for the artifact download process.</td> <td>Yes</td> </tr> <tr> <td>type</td> <td>file or zip. Provide this value based on your preference.</td> <td>Yes</td> </tr> <tr> <td>name</td> <td>The name of the artifact in Stratus. For example : SNAPSHOT.jar (for file type) Build.zip (for zip type) </td> <td>Yes</td> </tr> <tr> <td>file</td> <td>The destination path where the file has to be downloaded. For example : /SNAPSHOT.jar. </td> <td>Yes (if the artifact type is file)</td> </tr> <tr> <td>location</td> <td>The Stratus location from which the file has to be downloaded. For example : stratus://<<env.BUCKET_NAME >>/ artifact name </td> <td>Yes</td> </tr> </tbody> </table> Note: If the artifact type is set to zip, the zip file will be downloaded to the root directory by default. Refer to this section for a sample YAML code snippet configured with artifacts. -------------------------------------------------------------------------------- title: "Stages" description: "Learn about the Catalyst Pipelines stages in detail, the associated keywords and sample code snippets." last_updated: "2026-09-08T11:23:56.927Z" source: "https://docs.catalyst.zoho.com/en/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/stages/" service: "Pipelines" related: - Configure the Pipeline (/en/pipelines/help/catalyst-pipelines.yaml/implementation) -------------------------------------------------------------------------------- # Stages # Introduction A stage is a pivotal component in a pipeline that organizes the execution sequence of jobs within a pipeline. Each stage represents a distinct phase in the software delivery process, such as building, testing, or deploying an application. Stages allow for logical grouping and separation of jobs, thereby enabling parallel execution for faster build and deployment times. They also facilitate efficient management of complex pipelines by breaking down the workflow into manageable units, providing clarity and control over the entire deployment process. You can define the required stages for the pipeline as key-value pairs using the stages key. You can fetch the current status of a stage by using &lt;&lt; status.{stage_name} &gt;&gt;. Note: 1. Multiple stages in a pipeline run sequentially by default, proceeding one after the other. You have the option to define conditions for stage execution, allowing for personalized control over when each stage is triggered. Refer to this section to learn about defining conditions in the pipeline. 2. In a pipeline configuration, there must be at least one stage and no more than five stages. Additionally, each stage can accommodate a maximum of five jobs, which includes parallel jobs. ### Properties of a Stage You can define the stages in your pipeline with one or more combinations of the below listed attributes: <table class="content-table"> <thead> <tr> <th>Key</th> <th>Value</th> <th>is Mandatory</th> </tr> </thead> <tbody> <tr> <td>name</td> <td>Provide the stage name as a string value.</td> <td>Yes</td> </tr> <tr> <td>jobs</td> <td>An array of jobs</td> <td>Yes</td> </tr> </tr> <tr> <td>runner</td> <td>The name of the runner upon which the jobs have to be executed</td> <td>No</td> </tr> <tr> <td>image</td> <td>The name of the image which is used for job execution in the particular stage. </td> <td>No</td> </tr> <tr> <td>when</td> <td>The conditional logic based on which the stage must be executed. You can use "and", "or", "not", "not-equal", or "equal" operators along with the base condition. </td> <td>No</td> </tr> </tbody> </table> ### YAML Code Snippet for Stage Here's an example code snippet for stages that can be defined in a pipeline: stages: - name: testStage1 runner: runner1 image: testImage1 jobs: - testJob1 when: - and: - equal: - << pipeline.event.branch >> - master - true - name: testStage2 jobs: - testJob1 - - testJob2 - testJob3 The above code illustrates the following workflow: * There are two stages defined in the pipeline - testStage1 and testStage2. * The stage testStage1 executes one job(testJob1)and the stage testStage2 executes three jobs(testJob1 and a parallel job).The parallel job includes the jobs testJob2 and testJob3,respectively. * The runner and image have been defined at the stage level and will be utilized by both the stages. * The when condition validates if the current branch points to master, and if that holds true, the testJob1 will be executed. ##### Jobs -------------------------------------------------------------------------------- title: "Introduction" description: "Learn about the Catalyst Pipelines jobs in detail, the associated keywords and sample code snippets." last_updated: "2026-09-08T11:23:56.927Z" source: "https://docs.catalyst.zoho.com/en/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/jobs/introduction/" service: "Pipelines" related: - Configure the Pipeline (/en/pipelines/help/catalyst-pipelines.yaml/implementation) -------------------------------------------------------------------------------- # Jobs # Introduction A job is a sequence of steps to be executed in the pipeline. It is mandatory to define at least one job in the pipeline. You can define the required jobs for the pipeline as key-value pairs using the jobs key. Apart from the regular jobs defined in the pipeline, you can configure the following jobs as well : * **Approval Job** * **Parallel Job** You can retrieve the status of a job by using &lt;&lt; status.{stage_name}.{job_name} &gt;&gt;. ### Properties of a Job <table class="content-table"> <thead> <tr> <th>Key</th> <th>Value</th> <th>is Mandatory</th> </tr> </thead> <tbody> <tr> <td>variables</td> <td>An array of variables</td> <td>No</td> </tr> <tr> <td>artifacts</td> <td>This includes the upload and download keys. Refer to this help page for more details.</td> <td>No</td> </tr> <tr> <td>notify</td> <td>This key can be configured to send notification emails about the job before it starts execution and after the job execution completes. Contains the sub-keys on-start and on - end </td> <td>No</td> </tr> <tr> <td>on-start / on -end</td> <td>Contains the sub-keys notify-type and notify-variables.</td> <td>Yes (if notify is used)</td> </tr> <tr> <td>notify-type</td> <td>Provide the value as email .</td> <td>Yes (if notify is used)</td> </tr> <tr> <td>notify-variables</td> <td>Provide the email address to be notified when the job execution starts (for on-start) and the email address to be notified when the job successfully completes execution (for on-end )</td> <td>Yes (if notify is used)</td> </tr> <tr> <td>runner</td> <td>Specify the runner name in which the jobs need to be executed.</td> <td>No</td> </tr> <tr> <td>image</td> <td>Specify the name of the image needed for the specific job execution.</td> <td>No</td> </tr> <tr> <td>cwd</td> <td>Specify the current working directory in which the job has to be executed.</td> <td>No</td> </tr> <tr> <td>steps</td> <td>An array containing the scripts that need to be executed in the pipeline.</td> <td>Yes</td> </tr> <tr> <td>when</td> <td>Specify the conditions that determine whether the job has to be executed or not.</td> <td>No</td> </tr> </tbody> </table> ### YAML Code Snippet for Job Here's an example code snippet for jobs that can be defined in a pipeline: jobs: testJob1: steps: - echo "Enter your scripts here" testJob2: variables: BRANCH: main artifacts: upload: - name: artifactTest type: zip location: stratus://mybucket/home/artifacts files: - '**/*' download: - name: artifactTest type: zip location: stratus://mybucket/home/artifacts notify: on-start: - notify-type: email notify-variables: to: amelia.burrows@zylker.com on-end: - notify-type: email notify-variables: to: amelia.burrows@zylker.com runner: runner2 image: testImage1 cwd: cd ./src steps: - echo "Enter your scripts here" and: - equal: - << pipeline.event.branch >> - main - true testJob3: steps: - echo "Hello" The above code illustrates the following workflow: * There are three jobs defined in the pipeline - testJob1, testJob2, testJob3. * The testJob2 is configured to be executed only if the current working branch in the repository is the main branch. * The testJob2 handles the process to store and retrieve the generated build files to and from Catalyst Stratus. This is defined using the upload and download keys. * It also sends a notification to the defined email address in order to keep them informed about the start of the job execution and the completion of the job as well. This is achieved using the notify on-start and on-end keys. -------------------------------------------------------------------------------- title: "Approval Job" description: "Learn about the Catalyst Pipelines approval jobs in detail, the associated keywords and sample code snippets." last_updated: "2026-09-08T11:23:56.927Z" source: "https://docs.catalyst.zoho.com/en/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/jobs/approval-job/" service: "Pipelines" related: - Configure the Pipeline (/en/pipelines/help/catalyst-pipelines.yaml/implementation) -------------------------------------------------------------------------------- # Approval Job # Introduction The crucial tasks that require a manual review to proceed further can be defined as an approval job in the pipeline. The steps defined in the approval job are usually a set of validations required before a deployment runs. When an approval job is configured, the pipeline execution pauses until the approver approves the job. The approver will be sent an email notification to approve the job. They can also approve it from the console directly. Learn more about approving a job from the console in this help section. You can define the approval jobs for the pipeline as key-value pairs using the approve key. ### Properties of an Approval Job <table class="content-table"> <thead> <tr> <th>Key</th> <th>Value</th> <th>is Mandatory</th> </tr> </thead> <tbody> <tr> <td>type</td> <td>This key contains the sub-key type-name.</td> <td>Yes</td> </tr> <tr> <td>type-name</td> <td>Specify this value as "approval".</td> <td>Yes</td> </tr> <tr> <td>type-variables</td> <td>This key contains the sub-keys reviewers and message.</td> <td>Yes</td> </tr> <tr> <td>reviewers</td> <td>Specify the email addresses of the reviewers who can approve this job.</td> <td>Yes</td> </tr> <tr> <td>message</td> <td>Provide the message that has to be sent to the approver.</td> <td>Yes</td> </tr> </tbody> </table> Note: 1. You can add only a single reviewer for the approval job. 2. The approval job has no specific timeout, meaning the pipeline execution will remain paused until the approver takes action. ### YAML Code Snippet for Approval Job Here's an example code snippet for an approval job: approve: type: type-name: approval type-variables: reviewers: - amelia.b@zylker.com message: Review this -------------------------------------------------------------------------------- title: "Parallel Job" description: "Learn about the Catalyst Pipelines parallel jobs in detail, the associated keywords and sample code snippets." last_updated: "2026-09-08T11:23:56.927Z" source: "https://docs.catalyst.zoho.com/en/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/jobs/parallel-job/" service: "Pipelines" related: - Configure the Pipeline (/en/pipelines/help/catalyst-pipelines.yaml/implementation) -------------------------------------------------------------------------------- # Parallel Job A parallel job can include two distinct jobs that can be executed in parallel. You can define a parallel job by adding two hyphens (--) before the first job name and a single hyphen (-) before the second job name. This symbolically denotes that both the jobs will be executed in parallel. Note: A sequential job can be defined simply using a single hyphen(-). ### YAML Code Snippet for Parallel Job Here's an example code snippet for a parallel job: name: testStage1 jobs: - testJob1 - - testJob2 - testJob3 ### Deployment -------------------------------------------------------------------------------- title: "Deploy to AppSail" description: "Learn more about the sample YAML code snippet to deploy an application to Catalyst AppSail using the Pipelines service." last_updated: "2026-09-08T11:23:56.927Z" source: "https://docs.catalyst.zoho.com/en/pipelines/help/deployments/deploy-to-appsail/" service: "Pipelines" related: - Catalyst AppSail (/en/serverless/help/appsail/introduction/) -------------------------------------------------------------------------------- # Deploy to AppSail After building and testing your application, it has to be deployed to any virtual machine for users to use it. You can customize the deployment flow in the pipeline based on your specific needs. You can either automate the entire process or partially automate it by including an approval job to complete the deployment process. Here's a sample YAML code snippet that can be used to deploy a Java application built using Springboot framework in Catalyst AppSail service. Before executing the pipeline, you will have to configure the following keys as global variables in your pipeline. You can refer this help section to learn about configuring variables. * CATALYST_TOKEN : A unique token to access the Catalyst CLI from the YAML. Refer to this help page to learn more about token generation. * DOCKER_PASS : The password of your Docker Hub account. * BUCKET_NAME : The name of your Stratus bucket. version: 1.0 runners: high: config-id: 3 pipeline-when: equal: - << event.ref >> - refs/heads/main images: maven: image: maven:3.8.5-openjdk-17 auth: username: ameliaburrows password: << env.DOCKER_PASS >> jobs: unit-test: steps: - mvn surefire-report:report artifacts: upload: - type: zip regex: - /catalyst/target/surefire-reports/** name: junit.zip location: stratus://<< env.BUCKET_NAME >>/ package: steps: - mvn clean package -DskipTests=true artifacts: upload: - type: file name: SNAPSHOT.jar file: target/demo-0.0.1-SNAPSHOT.jar location: stratus://<< env.BUCKET_NAME >>/ catalyst-deploy: when: equal: - << status.build.package >> - success steps: - npm install -g zcatalyst-cli@beta - >- catalyst deploy appsail --name spring-boot --build-path "/catalyst/SNAPSHOT.jar" --stack java17 --platform javase --command "sh -c 'java -jar SNAPSHOT.jar --server.port=\${X_ZOHO_CATALYST_LISTEN_PORT}'" --verbose artifacts: download: - type: file name: SNAPSHOT.jar file: /SNAPSHOT.jar location: stratus://<< env.BUCKET_NAME >>/ stages: - name: test image: maven jobs: - unit-test - name: build image: maven jobs: - package - name: deploy jobs: - catalyst-deploy -------------------------------------------------------------------------------- title: "Deploy to Catalyst" description: "Learn more about the sample YAML code snippet to deploy an application to Catalyst using the Pipelines service." last_updated: "2026-09-08T11:23:56.928Z" source: "https://docs.catalyst.zoho.com/en/pipelines/help/deployments/deploy-to-catalyst/" service: "Pipelines" related: - Deploy Basic Web Client (/en/cli/v1/deploy-resources/deploy-client/) -------------------------------------------------------------------------------- # Deploy to Catalyst In this section, we'll look into a sample YAML code to automate the deployment of a basic Catalyst web client and Catalyst Serverless Functions component. This code is applicable to **Java**, **Node.js** and **Python**. You will have to configure the following keys as global variables in your pipeline. You can refer this help section to learn about configuring variables. * PROJECT_ID : The unique ID of your project assigned by Catalyst. You can fetch this value from the General Settings in the console. * CATALYST_ORG : The Catalyst organization to which the current project belongs. You can fetch this value from the Multi-Org portal in the console. * CATALYST_TOKEN : A unique token to access the Catalyst CLI from the YAML. Refer to this help page to learn more about token generation. * USER_NAME : The username of your Docker Hub account. * USER_PASSWORD : The password of your Docker Hub account. version: 1 runners: Machine: config-id: 2 images: DeployMachine: image: ubuntu auth: username: << env.USER_NAME >> password: << env.USER_PASSWORD >> jobs: Deploy_Client_Functions: steps: - apt-get update - apt-get -y install openjdk-17-jdk curl - curl -fsSL https://deb.nodesource.com/setup_18.x | bash - - apt-get install -y nodejs - apt-get update && \ - apt-get install -y software-properties-common wget curl && \ - add-apt-repository ppa:deadsnakes/ppa && \ - apt-get update && \ - apt-get install -y python3.10 python3.10-distutils && \ - wget https://bootstrap.pypa.io/get-pip.py && \ - python3.10 get-pip.py && \ - rm get-pip.py - npm i -g zcatalyst-cli - catalyst -v - cd functions/Node - npm install - cd ../.. - catalyst deploy --project << env.PROJECT_NAME >> --org << env.CATALYST_ORG >> --token << env.CATALYST_TOKEN >> stages: - name: build image: DeployMachine jobs: - Deploy_Client_Functions ### Pipelines -------------------------------------------------------------------------------- title: "Introduction" description: "Learn about the basics of Catalyst Pipelines and the overall workflow of the service and its implementation" last_updated: "2026-09-08T11:23:56.928Z" source: "https://docs.catalyst.zoho.com/en/pipelines/help/pipelines/introduction/" service: "Pipelines" related: - Java SDK (/en/sdk/java/v1/pipelines/get-pipeline-details) - JavaScript SDK (/en/sdk/javascript/v1/pipelines/get-pipeline-details/) - Python SDK (/en/sdk/python/v1/pipelines/get-pipeline-details) - Configure the Pipeline (/en/pipelines/help/catalyst-pipelines.yaml/implementation) -------------------------------------------------------------------------------- # Pipelines # Introduction A pipeline is the highest level unit of work in the Catalyst Pipelines service. It includes a customizable sequence of stages, such as compiling code, running tests, and deploying applications, all orchestrated seamlessly to streamline your software lifecycle process. You can create a pipeline and configure the flow of the pipeline directly from the Catalyst console. We will be discussing the detailed steps to this section in this section. While creating the pipeline, you can choose to integrate the pipeline with an external version control system such as GitLab, GitHub or Bitbucket. This integration enables you to link a particular repository in the version control system with the pipeline, and whenever any changes are pushed to the repository, the pipeline will get triggered automatically. You can also manually trigger the pipeline from the Catalyst console, if needed. For more information on pipeline triggers, you can refer to this section. Catalyst pipelines orchestrate based on the YAML code specified in the catalyst-pipelines.yaml file. You can refer to this page to understand the YAML schema definitions for Catalyst Pipelines and tailor the pipeline according to your specific needs. This YAML file is executed directly from the console for manual triggers or directly from the external version control system in the case of automatic triggers. You can also implement the manual pipeline trigger and fetch the details of an existing pipeline within your application code using our Pipelines SDK package available in Java, Node.js and Python. To define the execution flow of the pipeline in the YAML file, you have two options: you can either use our built-in drag-and-drop visual builder for an intuitive approach, or you can configure the YAML code using our code editor. You can find the step-by-step instructions to configure the pipeline in this help page. Now, let us explore the components of the pipeline, its hierarchical structure, and usage. -------------------------------------------------------------------------------- title: "Components of Pipeline" description: "Learn about the various components of Catalyst Pipelines, their usage functionality and hierarchy." last_updated: "2026-09-08T11:23:56.928Z" source: "https://docs.catalyst.zoho.com/en/pipelines/help/pipelines/components-of-pipeline/" service: "Pipelines" related: - Configure the Pipeline (/en/pipelines/help/catalyst-pipelines.yaml/implementation) -------------------------------------------------------------------------------- # Components of a Pipeline The pipeline can include any combination of the following components, each of which defines the sequence of execution of the pipeline. You can learn more about configuring the execution flow of the pipeline from this help section. * **Pipeline** : A tool for automating the build, test, and deployment processes of software applications. * **Runner** : A virtual machine or container that provides the underlying infrastructure to execute the pipeline. * **Image** : An external resource that a pipeline relies on, such as libraries, packages, or services, to complete its execution successfully. * **Variable** : The placeholders for values that can be reused at multiple instances within the scope of the pipeline. * **Artifact** : The zip file produced during the application build process and stored in the Catalyst Stratus service, which can be deployed to specified environments. * **When Condition** : The conditional logic that can be defined to instruct the execution flow of the pipeline. * **Step** : A step is the lowest building block in a pipeline. It contains a set of commands to perform specific operations such as compiling code, running tests, or deploying an application. * **Job** : A job is a series of sequential or parallel steps that execute within the pipeline. * **Stage** : The highest level of organization in the Catalyst Pipeline, representing distinct phases of the software delivery process. Each stage encompasses multiple jobs. You can code the execution flow of the pipeline by defining any of the above mentioned components in the catalyst-pipelines.yaml file based on your specific requirements. Within the Catalyst pipeline, stages, and jobs, you have the flexibility to configure the other components such as images, runners, variables, and conditions, each playing a distinct role in the pipeline execution. The following illustration provides a comprehensive overview of the components that can be defined at each level: We will be discussing in detail about each component in their respective help pages. Refer to this help page to get started. The below diagram demonstrates the hierarchical sequence of the various pipeline components. ## Key considerations 1. A pipeline can contain up to five stages, with each stage accommodating a maximum of five jobs, including parallel jobs. 2. It is mandatory to include at least one stage and job in the pipeline. 3. You can define variables, images, and runners at the pipeline level, stage level, or job level. In case of multiple definitions, the one specified at the lowest level (i.e., job) takes precedence. -------------------------------------------------------------------------------- title: "Pipeline Workflow" description: "Learn about the various CI/CD processes involved in the Catalyst Pipelines service." last_updated: "2026-09-08T11:23:56.928Z" source: "https://docs.catalyst.zoho.com/en/pipelines/help/pipelines/pipeline-workflow/" service: "Pipelines" related: - Configure the Pipeline (/en/pipelines/help/catalyst-pipelines.yaml/implementation) - Pipeline Triggers (/en/pipelines/help/triggers/introduction) - Catalyst Serverless Functions (/en/serverless/help/functions/introduction/) - Catalyst AppSail (/en/serverless/help/appsail/introduction/) -------------------------------------------------------------------------------- # Pipeline Workflow The below architecture diagram depicts the end-to-end flow of a Catalyst Pipeline. ### Trigger the Pipeline When creating a Catalyst pipeline, you can choose to integrate your pipeline with any of the supported version control systems (i.e., GitHub, GitLab or Bitbucket). This integration determines the mode of trigger for your pipeline : * **Automatic Pipeline Trigger :** The pipeline will be automatically triggered every time you push any code changes to the linked repository in the integrated version control system. When the pipeline is triggered, the complete source code from the integrated Git repository, along with the YAML file, will be automatically fetched and downloaded as a ZIP file to Catalyst. * **Manual Pipeline Trigger :** You can manually trigger the pipeline from the Catalyst console. This is suitable for one-time tasks that do not require integration with the version control system. In both the above-mentioned cases, upon triggering the pipeline, the pipeline workflow coded in the catalyst-pipelines.yaml file will be executed. Refer to this section to learn in detail about Catalyst pipeline triggers and its implementation. ### Execute the Pipeline On trigger, the pipeline will be executed sequentially, one stage after another. The commonly achieved goals of executing a pipeline include the following: #### Build You can configure the pipeline to build applications of any scale using the Catalyst Pipelines service. Here are a few examples of commonly built applications: * **Web Applications :** You can build web applications developed with frameworks including ASP.NET, Node.js, Django, Flask or more. * **Mobile Applications :** Build mobile apps for platforms like iOS, Android, or Windows using frameworks like Xamarin, React Native, or Flutter. * **API services :** Build RESTful APIs or micro services using frameworks including Express.js, ASP.NET Web API, Spring Boot or more. * **Serverless Applications :** You can build serverless applications using Catalyst Serverless Functions, Azure Functions, AWS Lambda, or Google Cloud Functions. * **Containerized Applications :** Build containerized applications using Docker, Kubernetes, or other container orchestration tools. There are vast options of applications that can be built automatically using the Catalyst Pipelines service. You will need to configure the steps component in the pipeline with the specific commands to be executed in order to build the application efficiently. #### Test Once the application is built automatically, you can proceed to test it before deploying it to any environment. Similar to the build process, you can specify the required commands to test the application in the catalyst-pipelines.yaml file. Here's a list of common tests that can be executed in the pipeline: * **Unit Tests:** Running unit tests for individual components or modules of the application to ensure they function correctly in isolation. * **Integration Tests:** Performing integration tests to verify interactions between various components or modules of the application. * **API Tests:** Testing the functionality, performance, and security of APIs used by the application, including both manual and automated API tests. * **Regression Tests:** Running regression tests to ensure that recent code changes have not introduced new bugs or regressions into the application. #### Deploy You can deploy your application in any environment, such as development, staging, or production, based on your specific needs. Here's a list of common deployment targets: * **Platform as a Service (PaaS):** Platforms like Catalyst AppSail, Heroku, or Google App Engine provide a managed environment for deploying web applications without needing to manage the underlying infrastructure. Developers can focus on writing code without worrying about server management. * **Containerization:** Using containerization technologies like Docker to package the web application along with its dependencies into containers. These containers can then be deployed consistently across different environments, providing portability and scalability. * **Container Orchestration:** Tools like Kubernetes enable automated deployment, scaling, and management of containerized applications. Kubernetes helps in deploying and managing containers at scale, providing features like load balancing and automatic scaling. We will be discussing the common deployment targets and the step-by-step instructions to configure the pipeline in this help page. -------------------------------------------------------------------------------- title: "Create a Pipeline" description: "Learn about the Catalyst Pipelines service and the step-by-step instructions to bots that provide conversation assistance to your application's end users." last_updated: "2026-09-08T11:23:56.928Z" source: "https://docs.catalyst.zoho.com/en/pipelines/help/pipelines/create-a-pipeline/" service: "Pipelines" related: - Configure the Pipeline (/en/pipelines/help/catalyst-pipelines.yaml/implementation) - YAML Schema Reference (/en/pipelines/help/catalyst-pipelines.yaml/schema-reference) -------------------------------------------------------------------------------- # Create a Pipeline To create a pipeline in the Catalyst console, please ensure to follow the below steps: 1. Click the **Pipelines** service icon from the left menu in the Catalyst console. 2. Click **Create Pipeline**. 3. In the pop-up that appears, provide a name for the pipeline. 4. Select your preferred integration source. Note: This step is completely optional. If you choose not to integrate your pipeline with any Git provider, then you can directly proceed with Step 8. 5. Add a new Git account by clicking the **+Add account** option. If you have any Git accounts integrated with your Catalyst project previously, they will be listed in the dropdown. Simply choose the account and proceed. 6. Select the organization your chosen account belongs to. Note: This attribute refers to the name of your organization in GitHub, the project name in GitLab, and the workspace name in Bitbucket. 7. Select the repository where you want to commit the new catalyst-pipelines.yaml file. Click **Continue**. Note: If a YAML file already exists in your repository, please ensure to name it catalyst-pipelines.yaml mandatorily. 8. The code editor is now opened. You can proceed to configure the pipeline by adding the required pipeline components in the editor. Also, you can select the branch in which the file has to be committed, as shown in the screenshot below. After you have defined the pipeline execution flow, click **Commit**. You can also save as a draft and work on the logic later, if required. You can choose to configure the pipeline in **Builder** mode by switching the tabs, as shown in the screenshot below. We will be discussing more about configuring the pipeline in this help page. ### Triggers -------------------------------------------------------------------------------- title: "Introduction" description: "Learn about the various pipeline triggers and their usage." last_updated: "2026-09-08T11:23:56.928Z" source: "https://docs.catalyst.zoho.com/en/pipelines/help/triggers/introduction/" service: "Pipelines" -------------------------------------------------------------------------------- # Triggers # Introduction ### Automatic Trigger Automatic Trigger in Catalyst Pipelines is the process of initiating pipeline runs based on certain events or conditions. When you create a pipeline from the console, you will have the option to integrate your pipeline with an external version control system. You can refer to this section to learn more about this integration. It is important to note that connecting pipelines to version control systems is the recommended approach and offers many benefits, such as traceability, collaboration, and the ability to trigger builds based on code changes. When you have integrated your pipeline with an external version control system, the pipeline will start executing every time a push or merge event occurs in the linked repository. You can view the execution status of the pipeline from the Catalyst console. Refer to this section to learn more about monitoring the execution status of the pipeline. ### Manual Trigger In case when you have not integrated your pipeline with any external version control system, then you can execute the pipeline manually every time from the Catalyst console. To execute the pipeline directly from the console, follow the below-listed steps: 1. Click **Execute Pipeline**. 2. Provide any event details for the pipeline in the JSON format, if required. Click **Execute**. The event details are optional here. The pipeline execution will start now. The status of the pipeline will progress from **QUEUED** to **RUNNING** to **SUCCESS/FAILED**. You can view the status of the pipeline in the **Execution History** section. We will discuss it in the next section. -------------------------------------------------------------------------------- title: "Monitor Execution Status" description: "Learn about the Catalyst ConvoKraft bots that provide conversation assistance to your application's end users." last_updated: "2026-09-08T11:23:56.928Z" source: "https://docs.catalyst.zoho.com/en/pipelines/help/triggers/monitor-execution-status/" service: "Pipelines" -------------------------------------------------------------------------------- # Monitor Execution Status After the pipeline execution is triggered either automatically or manually, you can view the execution status of the pipeline directly from the Catalyst console. 1. In the **Execution History** section, you can view the details of the pipeline execution. 2. Click on the execution record to view detailed information regarding the execution. The **Basic tab** allows you to view the execution status of each stage and job defined in the pipeline as an overview. You can switch to the **Advanced tab** to see live logs of the pipeline execution. Note: While the pipeline is running, it will be paused if an approval job is configured for the pipeline. In that case, the pipeline execution will be resumed only after the reviewer approves the job. The reviewer can approve the job directly from the console in the **Basic Tab**. --- ## API Reference — Pipelines -------------------------------------------------------------------------------- title: "Get Pipeline Details" description: "This API enables you to fetch the details of an existing Catalyst Pipeline from the Catalyst console." last_updated: "2026-09-08T11:23:56.932Z" source: "https://docs.catalyst.zoho.com/en/api/code-reference/pipelines/get-pipeline-details/" service: "Pipelines" -------------------------------------------------------------------------------- # Catalyst Pipelines Catalyst Pipelines is a Catalyst CI/CD service that enables you to automate the build, test, and deploy processes of your applications. You can create-a-pipeline from the Catalyst console. We will be discussing the APIs that can be leveraged to trigger the pipeline and get the details of an existing pipeline in the next sections. # Get Pipeline Details This API enables you to fetch the details of a pipeline created in the Catalyst console. This can be done by passing the pipeline_id and the project_id in the request URL. The API fetches the details of the project in which the pipeline is created and the details of the pipeline. ### Request Details #### Request URL <p>{api-domain}/baas/v1/project/{project_id}/pipeline/{pipeline_id}</p> The domain URL of your DC The unique ID of the project in which the pipeline has been created The unique ID of the pipeline for which the details have to be fetched. #### Request Headers **Authorization:** Zoho-oauthtoken {oauth_token} <br> Content-Type: application/json <br> **Optional Headers** <br> **CATALYST-ORG:** {org_id}<br> **Environment:** Development #### Scope pipeline.READ ### Response Details The pipeline details object will be returned as a response. It includes the details such as the name of the pipeline, details of the project including the project_name and project_type, the details of the user who has created the pipeline including the user_id, email_id, first_name, last_name and user_type, the status of the pipeline, the details of the users who had modified the pipeline along with the modified time details and also the default runner configuration of the pipeline. curl -X GET \ https://api.catalyst.zoho.com/baas/v1/project/4000000006007/pipeline/29810101101 \ -H "Authorization: Zoho-oauthtoken 1000.910*************************16.2f*************************57" \ { "status": "success", "data": { "pipeline_id": "29810101101", "name": "test1", "project_details": { "project_name": "Project-Rainfall", "id": "4000000006007", "project_type": "Live" }, "created_by": { "zuid": "20257791", "is_confirmed": false, "email_id": "amelia.burrows@zylker.com", "first_name": "Amelia", "last_name": "Burrows", "user_type": "Admin", "user_id": "5000000000056" }, "created_time": "Mar 19, 2024 11:28 AM", "modified_by": { "zuid": "20257791", "is_confirmed": false, "email_id": "amelia.burrows@zylker.com", "first_name": "Amelia", "last_name": "Burrows", "user_type": "Admin", "user_id": "5000000000056" }, "modified_time": "Mar 19, 2024 11:28 AM", "git_account_id": "", "mask_regex": [ null ], "pipeline_status": "Active", "config_id": 2, "integ_id": 1 } } Get Pipeline Details - Java SDK<br/><br/> Get Pipeline Details - Node.js SDK<br/><br/> Get Pipeline Details - Python SDK -------------------------------------------------------------------------------- title: "Execute Pipeline" description: "This API enables you to execute an existing Catalyst Pipeline from the Catalyst console." last_updated: "2026-09-08T11:23:56.932Z" source: "https://docs.catalyst.zoho.com/en/api/code-reference/pipelines/execute-pipeline/" service: "Pipelines" -------------------------------------------------------------------------------- # Execute Pipelines This API enables you to trigger the pipeline on a particular branch in the Git repository. This can be done by passing the branch name as a parameter in the request body. When triggering manual pipelines, you can simply ignore the branch name parameter in the request JSON. On triggering this API, the pipeline will be executed, and the status of execution will be returned as a response. # Get Pipeline Details This API enables you to fetch the details of a pipeline created in the Catalyst console. This can be done by passing the pipeline_id and the project_id in the request URL. The API fetches the details of the project in which the pipeline is created and the details of the pipeline. ### Request Details #### Request URL <p>{api-domain}/baas/v1/project/{project_id}/pipeline/{pipeline_id}/run</p> The domain URL of your DC The unique ID of the project in which the pipeline has been created The unique ID of the pipeline for which the details have to be fetched. #### Request Headers **Authorization:** Zoho-oauthtoken {oauth_token} <br> Content-Type: application/json <br> **Optional Headers** <br> **CATALYST-ORG:** {org_id}<br> **Environment:** Development<br> **branch:**{{Git branch name}} Note:branch can be used when you need to trigger a manual pipeline. #### Scope ZohoCatalyst.pipeline.execution.CREATE #### Request JSON Properties Provide any event details Any additional parameter required Note: We have added the EVENT and URL keys as environment variables. You can pass any required keys for the execution of the pipeline in the event JSON. ### Response Details An object containing the pipeline creation history details will be returned as a response. The object includes details such as the history_id, event_time, history_status. curl -X POST \ https://api.catalyst.zoho.com/baas/v1/project/4000000006007/pipeline/29810101101/run -H "Authorization: Zoho-oauthtoken 1000.910*************************16.2f*************************57" \ -H 'Content-Type: application/json' \ -d ‘{ "BRANCH_NAME" : "main", \ "EVENT": "push", \ "URL": "https://www.google.com" \ } { "status": "success", "data": { "history_id": "5000000021007", "pipeline_id": "29810101101", "event_time": "Mar 20, 2024 02:02 PM", "event_details": { "BRANCH_NAME": "main", "EVENT": "push", "URL": "https://www.google.com" }, "history_status": "Queued" } } Execute Pipeline - Java SDK<br/><br/> Execute Pipeline - Node.js SDK<br/><br/> Execute Pipeline - Python SDK --- ## SDK — Java — Pipelines -------------------------------------------------------------------------------- title: "Get Pipeline Instance" description: "This page describes the method to fetch pipeline instance and use it for other pipeline operations." last_updated: "2026-09-08T11:23:56.937Z" source: "https://docs.catalyst.zoho.com/en/sdk/java/v1/pipelines/get-pipeline-instance/" service: "All Services" related: - Catalyst Pipelines (/en/pipelines/help/pipelines/introduction) - Create a Pipeline (/en/pipelines/help/pipelines/create-a-pipeline) - JavaScript SDK (/en/sdk/javascript/v1/pipelines/create-instance/) - Python SDK (/en/sdk/python/v1/pipelines/get-pipeline-instance) - REST API (/en/api/code-reference/pipelines/get-pipeline-details) -------------------------------------------------------------------------------- # Catalyst Pipelines Catalyst Pipelines implements a CI/CD approach to enable automation of building, testing, and deployment of web or mobile applications to preferred environments. You can create a pipeline from the Catalyst console.Using the SDKs below, you can retrieve the details of a Catalyst Pipeline and also execute a pipeline by incorporating the code snippets in your application. #### Sample Code Snippet <br> import com.zc.component.pipeline.ZCPipeline; import com.zc.component.pipeline.ZCPipelineDetails; import com.zc.component.pipeline.ZCPipelineRunHistory; # Get Pipeline Instance A component instance is an object that can be used to access the properties specific to a particular component. You can create a component instance to perform the below listed actions in Catalyst Pipelines. You can create a new pipelines_service instance as shown below. This component instance will be used for all Pipeline operations in the Java SDK. ZCPipeline pipelines_service = ZCPipeline.getInstance(); -------------------------------------------------------------------------------- title: "Get Pipeline Details" description: "This page describes the method to fetch all the details of an existing Catalyst Pipeline." last_updated: "2026-09-08T11:23:56.937Z" source: "https://docs.catalyst.zoho.com/en/sdk/java/v1/pipelines/get-pipeline-details/" service: "All Services" related: - JavaScript SDK (/en/sdk/javascript/v1/pipelines/create-instance/) - Python SDK (/en/sdk/python/v1/pipelines/get-pipeline-instance) -------------------------------------------------------------------------------- # Get Pipeline Details You can fetch the details of the Catalyst Pipeline by passing the pipeline ID as a parameter to the getPipelineDetails() method. The name of the pipeline, details of the Catalyst project in which the pipeline has been created, the details of the user who created the pipeline, the time of creation, and if modifications have been done, the details of the user who modified the pipeline, the modified time, the status of the pipeline and other details like runner specifications are returned as response to this method. The pipelines_service reference used below is already defined in this component instance page. ZCPipelineDetails pipeline_details = pipelines_service.getPipelineDetails(16965000000019202L); A sample response is shown below: { "status": "success", "data": { "pipeline_id": "16965000000019202L", "name": "test1", "project_details": { "project_name": "Project-Rainfall", "id": "5000000000072", "project_type": "Live" }, "created_by": { "zuid": "20257791", "is_confirmed": false, "email_id": "amelia.burrows@zylker.com", "first_name": "Amelia", "last_name": "Burrows", "user_type": "Admin", "user_id": "5000000000056" }, "created_time": "Mar 19, 2024 11:28 AM", "modified_by": { "zuid": "20257791", "is_confirmed": false, "email_id": "amelia.burrows@zylker.com", "first_name": "Amelia", "last_name": "Burrows", "user_type": "Admin", "user_id": "5000000000056" }, "modified_time": "Mar 19, 2024 11:28 AM", "git_account_id": "", "mask_regex": [ null ], "pipeline_status": "Active", "config_id": 2, "integ_id": 1 } } -------------------------------------------------------------------------------- title: "Execute Pipeline" description: "This page describes the method to run the Catalyst Pipeline manually." last_updated: "2026-09-08T11:23:56.937Z" source: "https://docs.catalyst.zoho.com/en/sdk/java/v1/pipelines/execute-pipeline/" service: "All Services" related: - JavaScript SDK (/en/sdk/javascript/v1/pipelines/create-instance/) - Python SDK (/en/sdk/python/v1/pipelines/get-pipeline-instance) -------------------------------------------------------------------------------- # Execute Pipeline You can initiate a Catalyst pipeline run by passing the pipeline ID and the branch name as parameters to the runPipeline() method. You can also pass environment variables required for the pipeline execution in a JSON object to this method, and it is completely optional. This method returns the execution history details of the pipeline as the response. JSONObject env = new JSONObject(); env.put("EVENT", "push"); env.put("URL", "https://www.google.com"); ZCPipelineRunHistory run = pipelines_service.runPipeline(8431000000161112051L,main,env); A sample response is shown below: { "status": "success", "data": { "history_id": "5000000021007", "pipeline_id": "8431000000161112051L", "event_time": "Mar 20, 2024 02:02 PM", "event_details": { "BRANCH_NAME": "detective_pre", "EVENT": "push", "URL": "https://www.google.com" }, "history_status": "Queued" } } --- ## SDK — Modular JavaScript SDK — Pipelines -------------------------------------------------------------------------------- title: "Overview" description: "This page describes the method to perform operations using the components in Pipelines services." last_updated: "2026-09-08T11:23:56.938Z" source: "https://docs.catalyst.zoho.com/en/sdk/javascript/v1/pipelines/overview/" service: "Pipelines" related: - Catalyst Pipelines (/en/pipelines/help/pipelines/introduction/) - Java SDK Documentation (/en/sdk/java/v1/pipelines/) - Python SDK Documentation (/en/sdk/python/v1/pipelines/) - REST API Documentation (/en/api/code-reference/smartbrowz/browser-grid/list-all-grids/#ListallBrowserGrids) -------------------------------------------------------------------------------- # Pipelines JavaScript SDK # Overview Pipelines is a Catalyst service, that allows you to implement a CI/CD approach. This enables the automation of building, testing, and deployment of web and mobile applications to preferred environments. ### Prerequisites You will need to install the following package to be able to use the Pipelines SDK methods. npm install @zcatalyst/pipelines Info: Ensure that you have applied the required authentication configuration to use the SDK methods of this component. ### Import Requirement You will need to import the following modules to use the SDK methods of Pipelines components. const { Pipelines } = require('@zcatalyst/pipelines');//Pipelines module ### List of SDK Methods <table border="1" cellpadding="8" cellspacing="0"> <thead> <tr> <th>Category</th> <th>SDK Method</th> <th>Required Scope</th> </tr> </thead> <tbody> <tr> <td>General Operations</td> <td>Get Pipelines Instance</td> <td>No requirement</td> </tr> <tr> <td>Pipelines Operations</td> <td> <ul> <li>Get Details of a Pipeline</li> <li>Execute Pipeline</li> </ul> </td> <td>Admin</td> </tr> </tbody> </table> <br /> Info: Learn more about the Pipelines service. -------------------------------------------------------------------------------- title: "Create Pipelines Instance" description: "This page describes the method to perform operations using the components in the Pipelines Services." last_updated: "2026-09-08T11:23:56.938Z" source: "https://docs.catalyst.zoho.com/en/sdk/javascript/v1/pipelines/create-instance/" service: "Pipelines" related: - Catalyst Pipelines (/en/pipelines/help/pipelines/introduction/) - Java SDK Documentation (/en/sdk/java/v1/pipelines/get-pipeline-instance/) - Python SDK Documentation (/en/sdk/python/v1/pipelines/get-pipeline-instance/) - REST API Documentation (/en/api/code-reference/pipelines/get-pipeline-details/#GetPipelineDetails) -------------------------------------------------------------------------------- # Create Pipelines Instance Note: Ensure you have installed the required package to use this SDK method. You can get the pipelines component reference as shown below. This will not fire a server-side call. You will refer to this component instance in various code snippets of working with Pipelines. const pipelines = new Pipelines(); //Get a Pipelines instance -------------------------------------------------------------------------------- title: "Get Details of a Pipeline" description: "This page describes the method to perform operations using the components in SmartBrowz Services." last_updated: "2026-09-08T11:23:56.938Z" source: "https://docs.catalyst.zoho.com/en/sdk/javascript/v1/pipelines/get-pipeline-details/" service: "Pipelines" related: - Catalyst Pipelines (/en/pipelines/help/pipelines/introduction/) - Java SDK Documentation (/en/sdk/java/v1/pipelines/get-pipeline-details/) - Python SDK Documentation (/en/sdk/python/v1/pipelines/get-pipeline-details/) - REST API Documentation (/en/api/code-reference/pipelines/get-pipeline-details/#GetPipelineDetails) -------------------------------------------------------------------------------- # Get Details of a Pipeline Note: Ensure you have installed the required package to use this SDK method. You can fetch the details of a Pipeline by passing the pipeline ID to the getPipelineDetails() SDK method. The pipelines reference used in the code snippets below is the component instance created to perform these operations. // get the pipeline details const pipeline_details = pipelines.getPipelineDetails("16965000000019146"); #### Example of Expected Response The name of the pipeline, details of the Catalyst project in which the pipeline has been created, the details of the user who created the pipeline, the time of creation, and if modifications have been done, the details of the user who modified the pipeline, the modified time, the status of the pipeline, and other details like runner specifications are returned as response to this method. { "pipeline_id": "16965000000019146", "name": "test1", "project_details": { "project_name": "Project-Rainfall", "id": "5000000000072", "project_type": "Live" }, "created_by": { "zuid": "20257791", "is_confirmed": false, "email_id": "amelia.burrows@zylker.com", "first_name": "Amelia", "last_name": "Burrows", "user_type": "Admin", "user_id": "5000000000056" }, "created_time": "Mar 19, 2024 11:28 AM", "modified_by": { "zuid": "20257791", "is_confirmed": false, "email_id": "amelia.burrows@zylker.com", "first_name": "Amelia", "last_name": "Burrows", "user_type": "Admin", "user_id": "5000000000056" }, "modified_time": "Mar 19, 2024 11:28 AM", "git_account_id": "", "mask_regex": [null], "pipeline_status": "Active", "config_id": 2, "integ_id": 1 } -------------------------------------------------------------------------------- title: "Execute Pipeline" description: "This page describes the method to perform operations using the components in SmartBrowz Services." last_updated: "2026-09-08T11:23:56.938Z" source: "https://docs.catalyst.zoho.com/en/sdk/javascript/v1/pipelines/execute-pipeline/" service: "Pipelines" related: - Catalyst Pipelines (/en/pipelines/help/pipelines/introduction/) - Java SDK Documentation (/en/sdk/java/v1/pipelines/execute-pipeline/) - Python SDK Documentation (/en/sdk/python/v1/pipelines/execute-pipeline/) - REST API Documentation (/en/api/code-reference/pipelines/execute-pipeline/#ExecutePipeline) -------------------------------------------------------------------------------- # Execute Pipeline Note: Ensure you have installed the required package to use this SDK method. You can initiate a Catalyst pipeline run by passing the pipeline ID and the branch name to the runPipeline() SDK method. You can also pass environment variables required for the pipeline execution in a JSON object to this method, and it is completely optional. This method returns the execution history details of the pipeline as the response. The pipelines reference used in the code snippets below is the component instance created to perform these operations. // run the pipeline const execution_details = pipelines.runPipeline("PIPELINE_ID", 'BRANCH_NAME',{"EVENT": "push", "URL":"https://www.google.com"}); // replace the params with your pipeline id, branch, event and url #### Example of Expected Response { "history_id": "5000000021007", "pipeline_id": "8431000000162051", "event_time": "Mar 20, 2024 02:02 PM", "event_details": { "BRANCH_NAME": "main", "EVENT": "push", "URL": "https://www.google.com" }, "history_status": "Queued" } --- ## SDK — Node JS — Pipelines -------------------------------------------------------------------------------- title: "Get Pipeline Instance" description: "This page describes the method to fetch pipeline instance and use it for other pipeline operations." last_updated: "2026-09-08T11:23:56.939Z" source: "https://docs.catalyst.zoho.com/en/sdk/nodejs/v2/pipelines/get-pipeline-instance/" service: "All Services" related: - Catalyst Pipelines (/en/pipelines/help/pipelines/introduction) - Create a Pipeline (/en/pipelines/help/pipelines/create-a-pipeline) - Java SDK (/en/sdk/java/v1/pipelines/get-pipeline-instance) - Python SDK (/en/sdk/python/v1/pipelines/get-pipeline-instance) - REST API (/en/api/code-reference/pipelines/get-pipeline-details) -------------------------------------------------------------------------------- # Catalyst Pipelines Note: This SDK is currently in deprecation. Migrate to JavaScript SDK now. Catalyst Pipelines implements a CI/CD approach to enable automation of building, testing, and deployment of web or mobile applications to preferred environments. You can create a pipeline from the Catalyst console.Using the SDKs below, you can retrieve the details of a Catalyst Pipeline and also execute a pipeline by incorporating the code snippets in your application. # Get Pipeline Instance A component instance is an object that can be used to access the properties specific to a particular component. You can create a component instance to perform the below listed actions in Catalyst Pipelines. The app reference used in the code below is the Node object returned as a response during SDK initialization. You can create a new pipelines_service instance as shown below. const pipelines_service = app.pipeline() This component instance will be used for all Pipeline operations in the Node.js SDK. -------------------------------------------------------------------------------- title: "Get Pipeline Details" description: "This page describes the method to fetch all the details of an existing Catalyst Pipeline." last_updated: "2026-09-08T11:23:56.939Z" source: "https://docs.catalyst.zoho.com/en/sdk/nodejs/v2/pipelines/get-pipeline-details/" service: "All Services" related: - Catalyst Pipelines (/en/pipelines/help/pipelines/introduction) - Create a Pipeline (/en/pipelines/help/pipelines/create-a-pipeline) - Java SDK (/en/sdk/java/v1/pipelines/get-pipeline-instance) - Python SDK (/en/sdk/python/v1/pipelines/get-pipeline-instance) - REST API (/en/api/code-reference/pipelines/get-pipeline-details) -------------------------------------------------------------------------------- # Get Pipeline Details Note: This SDK is currently in deprecation. Migrate to JavaScript SDK now. You can fetch the details of the Catalyst Pipeline by passing the pipeline ID as a parameter to the getPipelineDetails() method. The name of the pipeline, details of the Catalyst project in which the pipeline has been created, the details of the user who created the pipeline, the time of creation, and if modifications have been done, the details of the user who modified the pipeline, the modified time, the status of the pipeline and other details like runner specifications are returned as response to this method. The pipelines_service reference used below is already defined in this component instance page. let pipline_details = pipelines_service.getPipelineDetails("16965000000019146") A sample response is shown below: { "status": "success", "data": { "pipeline_id": "16965000000019146", "name": "test1", "project_details": { "project_name": "Project-Rainfall", "id": "5000000000072", "project_type": "Live" }, "created_by": { "zuid": "20257791", "is_confirmed": false, "email_id": "amelia.burrows@zylker.com", "first_name": "Amelia", "last_name": "Burrows", "user_type": "Admin", "user_id": "5000000000056" }, "created_time": "Mar 19, 2024 11:28 AM", "modified_by": { "zuid": "20257791", "is_confirmed": false, "email_id": "amelia.burrows@zylker.com", "first_name": "Amelia", "last_name": "Burrows", "user_type": "Admin", "user_id": "5000000000056" }, "modified_time": "Mar 19, 2024 11:28 AM", "git_account_id": "", "mask_regex": [ null ], "pipeline_status": "Active", "config_id": 2, "integ_id": 1 } } -------------------------------------------------------------------------------- title: "Execute Pipeline" description: "This page describes the method to run the Catalyst Pipeline manually." last_updated: "2026-09-08T11:23:56.939Z" source: "https://docs.catalyst.zoho.com/en/sdk/nodejs/v2/pipelines/execute-pipeline/" service: "All Services" related: - Catalyst Pipelines (/en/pipelines/help/pipelines/introduction) - Create a Pipeline (/en/pipelines/help/pipelines/create-a-pipeline) - Java SDK (/en/sdk/java/v1/pipelines/get-pipeline-instance) - Python SDK (/en/sdk/python/v1/pipelines/get-pipeline-instance) - REST API (/en/api/code-reference/pipelines/get-pipeline-details) -------------------------------------------------------------------------------- # Execute Pipeline Note: This SDK is currently in deprecation. Migrate to JavaScript SDK now. You can initiate a Catalyst pipeline run by passing the pipeline ID and the branch name as parameters to the runPipeline() method. You can also pass environment variables required for the pipeline execution in a JSON object to this method, and it is completely optional. This method returns the execution history details of the pipeline as the response. The pipelines_service reference used below is already defined in this component instance page. let execution_details = pipelines_service.runPipeline("8431000000162051", main,{"EVENT": "push", "URL":"https://www.google.com"}) A sample response is shown below: { "status": "success", "data": { "history_id": "5000000021007", "pipeline_id": "8431000000162051", "event_time": "Mar 20, 2024 02:02 PM", "event_details": { "BRANCH_NAME": "main", "EVENT": "push", "URL": "https://www.google.com" }, "history_status": "Queued" } } --- ## SDK — Python — Pipelines -------------------------------------------------------------------------------- title: "Get Pipeline Instance" description: "This page describes the method to fetch pipeline instance and use it for other pipeline operations." last_updated: "2026-09-08T11:23:56.948Z" source: "https://docs.catalyst.zoho.com/en/sdk/python/v1/pipelines/get-pipeline-instance/" service: "All Services" related: - Catalyst Pipelines (/en/pipelines/help/pipelines/introduction) - Create a Pipeline (/en/pipelines/help/pipelines/create-a-pipeline) - Java SDK (/en/sdk/java/v1/pipelines/get-pipeline-instance) - JavaScript SDK (/en/sdk/javascript/v1/pipelines/create-instance/) - REST API (/en/api/code-reference/pipelines/get-pipeline-details) -------------------------------------------------------------------------------- # Catalyst Pipelines Catalyst Pipelines implements a CI/CD approach to enable automation of building, testing, and deployment of web or mobile applications to preferred environments. You can create a pipeline from the Catalyst console.Using the SDKs below, you can retrieve the details of a Catalyst Pipeline and also execute a pipeline by incorporating the code snippets in your application. # Get Pipeline Instance A component instance is an object that can be used to access the properties specific to a particular component. You can create a component instance to perform the below listed actions in Catalyst Pipelines. The app reference used in the code below is the Python object returned as a response during SDK initialization. You can create a new pipelines_service instance as shown below. pipelines_service = app.pipeline() This component instance will be used for all Pipeline operations in the Node.js SDK. -------------------------------------------------------------------------------- title: "Get Pipeline Details" description: "This page describes the method to fetch all the details of an existing Catalyst Pipeline." last_updated: "2026-09-08T11:23:56.948Z" source: "https://docs.catalyst.zoho.com/en/sdk/python/v1/pipelines/get-pipeline-details/" service: "All Services" related: - Catalyst Pipelines (/en/pipelines/help/pipelines/introduction) - Create a Pipeline (/en/pipelines/help/pipelines/create-a-pipeline) - Java SDK (/en/sdk/java/v1/pipelines/get-pipeline-instance) - JavaScript SDK (/en/sdk/javascript/v1/pipelines/create-instance/) - REST API (/en/api/code-reference/pipelines/get-pipeline-details) -------------------------------------------------------------------------------- # Get Pipeline Details You can fetch the details of the Catalyst Pipeline by passing the pipeline ID as a parameter to the get_pipeline_details() method. The name of the pipeline, details of the Catalyst project in which the pipeline has been created, the details of the user who created the pipeline, the time of creation, and if modifications have been done, the details of the user who modified the pipeline, the modified time, the status of the pipeline and other details like runner specifications are returned as response to this method. The pipelines_service reference used below is already defined in this component instance page. pipeline_details = pipelines_service.get_pipeline_details("16965000000027475") A sample response is shown below: { "status": "success", "data": { "pipeline_id": "16965000000027475", "name": "test1", "project_details": { "project_name": "Project-Rainfall", "id": "5000000000072", "project_type": "Live" }, "created_by": { "zuid": "20257791", "is_confirmed": false, "email_id": "amelia.burrows@zylker.com", "first_name": "Amelia", "last_name": "Burrows", "user_type": "Admin", "user_id": "5000000000056" }, "created_time": "Mar 19, 2024 11:28 AM", "modified_by": { "zuid": "20257791", "is_confirmed": false, "email_id": "amelia.burrows@zylker.com", "first_name": "Amelia", "last_name": "Burrows", "user_type": "Admin", "user_id": "5000000000056" }, "modified_time": "Mar 19, 2024 11:28 AM", "git_account_id": "", "mask_regex": [ null ], "pipeline_status": "Active", "config_id": 2, "integ_id": 1 } } -------------------------------------------------------------------------------- title: "Execute Pipeline" description: "This page describes the method to run the Catalyst Pipeline manually." last_updated: "2026-09-08T11:23:56.948Z" source: "https://docs.catalyst.zoho.com/en/sdk/python/v1/pipelines/execute-pipeline/" service: "All Services" related: - Catalyst Pipelines (/en/pipelines/help/pipelines/introduction) - Create a Pipeline (/en/pipelines/help/pipelines/create-a-pipeline) - Java SDK (/en/sdk/java/v1/pipelines/get-pipeline-instance) - JavaScript SDK (/en/sdk/javascript/v1/pipelines/create-instance/) - REST API (/en/api/code-reference/pipelines/get-pipeline-details) -------------------------------------------------------------------------------- # Execute Pipeline You can initiate a Catalyst pipeline run by passing the pipeline ID and the branch name as parameters to the run_pipeline() method. You can also pass environment variables required for the pipeline execution in a JSON object to this method, and it is completely optional. This method returns the execution history details of the pipeline as the response. The pipelines_service reference used below is already defined in this component instance page. execution_details = pipelines_service.run_pipeline("18014000000023048", "main", {"EVENT": "push","URL":"https://www.google.com"}) A sample response is shown below: { "status": "success", "data": { "history_id": "5000000021007", "pipeline_id": "18014000000023048", "event_time": "Mar 20, 2024 02:02 PM", "event_details": { "BRANCH_NAME": "main", "EVENT": "push", "URL": "https://www.google.com" }, "history_status": "Queued" } }