> For the complete documentation index, see [llms.txt](https://developer.harness.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://developer.harness.io/release-orchestration/use-release-orchestration/release-orchestration-processes/process-modeling.md).

# Process Modeling

Process modeling in Release Orchestration allows you to define your release workflows using phases, activities, dependencies, and variables. You can create processes using AI-based generation or manual configuration to match your team's specific requirements.

### Create a process with AI <a href="#ai-based-process-creation" id="ai-based-process-creation"></a>

Harness supports creation of processes using Harness AI. Most of the time, release processes are available in a textual fashion, documented in different sources. Release Orchestration enables users to provide that process documentation and create the process as an entity in Harness Release Orchestration.

To create a process with Harness AI, navigate to **Processes**, then click **Create Process**.

<figure><img src="/files/dGZybAwrgvCZ9TmtzBzW" alt=""><figcaption><p>Click to view full size image</p></figcaption></figure>

Enter instructions that define your release process. Use the following example:

**Example prompt:**

```
Create a multi-service release process starting from release planning and coordination up until monitoring in production. The process includes the following phases:
- Release planning and coordination (Owner: Release Manager)
- Build and artifact creation
- Testing and validation
- Feature flag enablement
- Production deployment
- Monitoring and rollback
```

After you submit the prompt, Harness AI performs the following actions:

* **Creates phases:** Identifies logical groups of activities as phases.
* **Assigns owners:** Assigns owners from the prompt or asks you to provide them.
* **Creates activities:** Generates activities within each phase.
* **Infers dependencies:** Determines execution order and dependencies.

<figure><img src="/files/x2IyFQNYeK84ed1B8ZCP" alt=""><figcaption><p>Click to view full size image</p></figcaption></figure>

Harness AI asks you to provide owners for each phase. After you select owners, Harness AI creates YAML for the release process. The YAML appears as a step-by-step release process.

<figure><img src="/files/67kglydi6jbHJikKYEQq" alt=""><figcaption><p>Click to view full size image</p></figcaption></figure>

You can define phases, activities, and dependencies manually to match your release process. Use Harness AI when you want to generate a starting process.

### Process structure <a href="#process-structure" id="process-structure"></a>

#### Basic structure <a href="#basic-structure" id="basic-structure"></a>

A process has the following elements:

1. **Metadata**: Name and description
2. **Inputs**: Required parameters (captured using an Input Store when executing)
3. **Variables**: Process-wide variables
4. **Phases**: Major stages
5. **Activities**: Tasks within phases
6. **Dependencies**: Execution order rules

#### YAML example <a href="#example-yaml" id="example-yaml"></a>

The following example uses the same YAML shape as a real process created in Release Orchestration (nested `phase` and `activity` blocks, `depends-on`, `owners`, and optional `if` and `data` fields).

```yaml
process:
  name: Comprehensive Release Process
  description: A structured release process covering build, test, and deployment phases
  id: comprehensive_release_process
  phases:
    - phase:
        id: build_phase
        name: Build Phase
        description: Build and validate artifacts before testing.
        owners:
          - Development Team
        depends-on: []
        activities:
          - activity: AutoPipe
            id: AutoPipe
            name: AutoPipe90
            description: ""
            depends-on: []
          - activity: AutoPipe
            id: AutoPipe12
            name: AutoPipe12
            description: ""
            depends-on:
              - AutoPipe
          - activity: AutoPipe
            id: TestActivity00
            name: TestActivity00
            description: ""
            depends-on:
              - AutoPipe12
            if: <+90>
          - activity: ManualTest
            id: AutoIioo
            name: Auto_deploy
            description: doc
            depends-on:
              - AutoPipe12
    - phase:
        id: test_phase
        name: Test Phase
        description: Execute tests and quality gates before deployment.
        owners:
          - QA Team
        depends-on:
          - build_phase
        activities:
          - activity: TestActivity
            id: TestActivity
            name: TestActivity
            depends-on: []
    - phase:
        id: deploy_phase
        name: Deploy to Staging1 Phase
        owners:
          - DevOps Team
        depends-on:
          - test_phase
        activities:
          - activity: WaitingActivity
            id: WaitingActivity
            name: WaitingActivity
            depends-on: []
            data:
              pipeline:
                pipeline: default/MyProject/MyPipeline
                inputSet: {}
```

### Model complex release processes <a href="#modeling-complex-release-processes" id="modeling-complex-release-processes"></a>

You can model complex release processes with different sequences of execution in terms of parallel and sequential execution.

#### Common execution patterns <a href="#common-execution-patterns" id="common-execution-patterns"></a>

**Sequential Execution**

Activities execute one after another:

```
Activity A → Activity B → Activity C
```

**Parallel Execution**

Activities execute simultaneously:

```
Activity A ─┐
            ├→ Activity D
Activity B ─┤
            └→ Activity E
Activity C ─┘
```

**Conditional Execution**

Activities execute based on conditions:

```
Activity A → [Condition] → Activity B (if true)
                      └→ Activity C (if false)
```

#### Phase Dependencies <a href="#phase-dependencies" id="phase-dependencies"></a>

Phases can have dependencies preconfigured. For example:

* The **test phase** has dependencies on the **build phase**
* The **validation phase** has dependencies on the **build phase**
* Phases execute in the order defined by their dependencies

#### Activity Dependencies <a href="#activity-dependencies" id="activity-dependencies"></a>

Activities within each phase can also have dependencies. For example:

* **Activity 3** (a manual pipeline or automated activity) and **Activity 3.1** (a manual activity) are dependent on **Activity 2** (an automated pipeline activity)
* Activities execute in the order defined by their dependencies
* Dependencies can be configured to support both parallel and sequential execution

#### Complex process structure example <a href="#example-complex-process-structure" id="example-complex-process-structure"></a>

A pre-built, preconfigured process might have:

* **Build Phase**: Contains build activities
* **Test Phase**: Depends on Build Phase, contains test activities
* **Validation Phase**: Depends on Build Phase, contains validation activities
* **Activities with dependencies**: Activities within phases that depend on other activities

With this structure, it is possible to model complex release processes and execute them using a release.

### Process blueprints <a href="#process-blueprints" id="process-blueprints"></a>

Start with blueprints for common scenarios:

* Standard production release
* Hotfix release
* Multi-service release
* Scheduled release

Customize a blueprint to fit your needs.

### Related topics <a href="#related-topics" id="related-topics"></a>

* [Phases](/release-orchestration/use-release-orchestration/release-orchestration-phases/phases-overview.md)
* [Activities](/release-orchestration/use-release-orchestration/release-orchestration-activities/activities-overview.md)
* [Activity Dependencies](/release-orchestration/3.0/activities/activity-dependencies.md)
* [Modeling complex processes](#modeling-complex-release-processes)
