Skip to main content

Getting started

Last updated on

Release Orchestration provides a unified framework for modeling, scheduling, automating, and tracking complex software releases across teams, tools, and environments. It orchestrates every step from planning (using Harness AI) through production deployment, feature flag enablement, and monitoring — giving you end-to-end visibility across the entire release lifecycle.

The Release Orchestration landing page showing the four core areas: Model Releases, Release Calendar, Processes, and Activity Store.

How the entities fit together​

The following diagram shows how the core entities in Release Orchestration relate to each other:

  • A Process is a reusable release blueprint made up of Phases and Activities.
  • Activities come from the Activity Store and can be automated, manual, or subprocess-based.
  • A Release Group defines a cadence and contains individual Releases, each of which executes a Process.
  • The Release Calendar visualizes all scheduled and in-flight releases.
  • The Input Store provides named input sets so the same Process can run with different configurations.

Why Release Orchestration​

Without orchestration, releases that span multiple services, teams, and tools become fragmented. Status lives in spreadsheets, coordination happens over email, and there is no single source of truth for what was deployed, when, or by whom.

Release Orchestration solves this by providing:

  • Structured process modeling: Define reusable release blueprints (Processes) composed of Phases and Activities instead of ad-hoc checklists.
  • Automated and manual execution: Automate pipeline-backed steps while retaining manual sign-offs and approvals where governance requires them.
  • End-to-end visibility: Track activity-level status, phase-level progress, and overall release health in real time.
  • Built-in governance and auditability: Enforce approvals, capture sign-offs, and maintain a full audit trail linking code to deployment.
  • Scheduled releases: Use Release Groups and the Release Calendar to run releases on a cadence (daily, weekly, monthly, or custom).
A release execution graph showing phases (Build, Test, Deploy to Staging, UAT) connected by dependency arrows, with activity counts and owner assignments visible on each phase card.

Prerequisites​

Before you begin, ensure the following:

  • Feature flags enabled: The following feature flags must be enabled for your Harness account. Contact Harness Support to enable them.

    • RMG_RELEASE_MANAGEMENT_ENABLED — Enables the Release Management module.
    • RMG_PROCESS_ENABLED — Enables Process functionality for creating release blueprints.

  • Module access: Confirm you have access to the Release Orchestration module in Harness.

  • Permissions: Ensure your user role has permissions to create processes, releases, and activities. Go to Account Settings > Access Control to verify.

    The Access Control settings page where you can verify your user role has the required permissions for Release Orchestration.

  • Pipelines (for automated activities): If you plan to use Automated Activities, have at least one Harness pipeline configured. Automated activities encapsulate pipelines, so the pipeline must exist before you can reference it.

  • Phase owners identified: Identify the owners responsible for each phase of your release (for example, Development, QA, DevOps). Owners are assigned per phase and receive notifications when their input is needed.

Key concepts​

Before walking through the steps, familiarize yourself with the core entities. Each term links to its detailed reference page.

EntityDescription
ProcessA reusable release blueprint containing phases, activities, dependencies, and variables.
PhaseA logical group of work within a process (e.g., Build, Testing, Deployment). Phases can depend on other phases.
ActivityA single unit of work within a phase. Can be Automated (pipeline-backed), Manual (sign-offs/approvals), or a Subprocess (nested process).
Activity StoreA library of reusable activities with pre-configured inputs and outputs. Activities from the store can be added to any process.
Input StoreA collection of named input sets for a process. Each input set provides concrete values for process-level, phase-level, and activity-level inputs, allowing you to run the same process with different configurations.
Release GroupA collection of releases executed on a defined cadence. Linked to a process so each release follows the same blueprint.
Release CalendarA visual calendar of all planned and scheduled releases, helping teams coordinate timing and avoid conflicts.

For a full glossary, see Key Concepts.

Step 1: Create a process​

A Process is the blueprint for your release. You can create one from scratch or use Harness AI to generate a starting point.

  1. In the Release Orchestration module, open Processes.

  2. Select + New Process and choose Create with Harness AI.

  3. Provide a prompt describing your release flow. For example:

    Create a process for a multi-service release.
    Include phases for planning and coordination, build, testing/validation,
    feature flag enablement, deployment, monitoring, and rollback/documentation.
    Assign phase owners for Development, QA, and DevOps.

  4. Review the generated process. Harness AI creates Phases (logical groups of work) with Activities and assigns owners based on your prompt.

  5. Save the process.

For more details on manual process creation, see Process Modeling.

Step 2: Add activities from the Activity Store​

The Activity Store is a library of reusable, pre-configured activities. It contains three types of activities:

  • Automated Activities: Encapsulate a Harness pipeline that runs automatically during execution. Use these for builds, deployments, tests, and any pipeline-driven work.
  • Manual Activities: Require human input during execution — approvals, sign-offs, manual verification steps, or documentation tasks.
  • Subprocess Activities: Reference another process within your process, enabling composition and reuse.

To add activities:

  1. Open the process you created.
  2. Select a phase and choose Add Activity.
  3. Browse the Activity Store and select the activity you need.
  4. For automated activities, select the pipeline to encapsulate and configure its inputs.

Step 3: Model dependencies​

Define the execution order across your process using dependencies:

  • Phase dependencies: Control which phases must complete before others start (e.g., Testing depends on Build).
  • Activity dependencies: Control ordering within or across phases (e.g., a manual approval must complete before a deployment pipeline runs).

Dependencies can model both sequential and parallel execution. For details, see Parallel vs Sequential Execution.

Step 4: Connect the process to releases​

  1. Open the Release Calendar.
  2. Create or open a Release Group with your desired cadence (e.g., recurring every Thursday, running for two days).
  3. Link the release group to the process you created, so each release executes using that blueprint.
The Release Calendar showing a monthly view of scheduled releases across multiple release groups, with each release color-coded by type.

Step 5: Provide inputs and execute​

  1. From the Release Calendar, open a specific release.
  2. Review the linked process and select Pre-execute (or let it run at the scheduled time).
  3. Select an input set from the Input Store. An input set is a named collection of values for all the inputs your process requires (process-level, phase-level, and activity-level). You can create multiple input sets for the same process to run it with different configurations — for example, one input set for staging and another for production.

For more on variables and input configuration, see Inputs and Variables.

Step 6: Monitor and remediate​

During execution, track progress at every level:

  • Activity-level: Running, succeeded, failed, or on hold.
  • Phase-level: Overall progress of each phase.
  • Process-level: End-to-end release status.

If an automated activity fails, you can remediate by choosing Retry or Ignore to continue execution. For details, see Error Handling.

If execution is waiting for a sign-off, complete the Manual Activity by providing the required inputs and approval.

Next steps​