How does Kestra compare to VMware Aria Automation (vRA/vRO)?

VMware Aria Automation focuses on catalog-driven VM and service provisioning tightly coupled to vSphere infrastructure. Workflows in vRO are JavaScript-based with proprietary APIs, difficult to version, and prone to ambiguous error messages. Kestra replaces vRA/vRO with declarative YAML workflows that work across VMware, AWS, Azure, GCP, and Kubernetes—with proper Git integration, clear logs, and self-service Apps that don't require a proprietary portal. Organizations like BHP and Capgemini have replaced vRA/vRO with Kestra specifically for better developer experience, cleaner logs, and Git-native governance.

Does Kestra support VMware vSphere integrations?

Yes. Kestra has native vSphere plugin support for VM lifecycle management—provisioning, snapshotting, resizing, and decommissioning. Combined with Terraform, Ansible, and PowerShell tasks in the same workflow, Kestra can replicate and extend everything vRA/vRO does for vSphere environments. You keep deep vSphere integration while gaining multi-cloud flexibility and a modern developer experience.

How does Kestra handle self-service provisioning forms?

Kestra Apps provide dynamic, data-backed forms for self-service provisioning. Forms can be populated from APIs, CMDBs, or vCenter data—giving users dropdowns with live infrastructure data (available datastores, network segments, resource pools) rather than static values. Approval gates are inline YAML tasks that pause the workflow for human review before resources are created. This replaces the vRA service catalog with a single, flexible mechanism that works across any cloud.

What happens to existing vRO workflows when migrating to Kestra?

Kestra's AI Copilot can help translate vRO JavaScript workflows into YAML. For complex vRO workflows, Kestra's professional services team has a proven migration playbook—typically converting vRO workflows to Kestra YAML while preserving business logic. Many organizations (including BHP) have migrated their entire vRA/vRO catalog to Kestra in phased migrations, running both systems in parallel during the transition period.

How does Kestra address the Broadcom/VMware pricing concern?

Since Broadcom's acquisition of VMware, many organizations have seen significant licensing cost increases. Kestra's pricing is based on compute infrastructure (instances and workers), not per-VM or per-user counts—which typically results in substantial savings as vSphere environments grow. Kestra also has no vendor lock-in: workflows are YAML files in Git that can run on any infrastructure.

Is Kestra suitable for air-gapped and regulated environments?

Yes. Kestra was designed for compliance-first deployments. It runs fully on-prem with no external dependencies, supports internal Postgres and S3-compatible storage, integrates with AD/OIDC for SSO, and works with enterprise secrets managers like CyberArk and HashiCorp Vault. Government customers like ITZBund and the Austrian Ministry of Defense chose Kestra specifically for its air-gap readiness and audit capabilities.

Kestra vs. VMware Aria Automation: Beyond the vSphere Portal

VMware Aria Automation (formerly vRA/vRO) is the go-to portal for catalog-driven VM provisioning in vSphere environments. But as infrastructure expands to AWS, Azure, GCP, and Kubernetes—and as teams demand Git-native workflows, clear error messages, and modern developer experience—the proprietary JavaScript vRO model breaks down. Kestra replaces vRA/vRO with declarative YAML workflows that work across every cloud, on-prem, and air-gapped environments.

Get Started Book a Demo

Cloud-Agnostic Orchestration vs. vSphere-First Portal

Multi-Cloud Infrastructure Orchestration

Define every provisioning workflow in YAML. Orchestrate Terraform, Ansible, vSphere, AWS, Azure, and GCP in one flow. Self-service Apps with dynamic forms and approval gates replace the vRA catalog. Every workflow is Git-native, reviewable, and deployable through CI/CD—no JavaScript, no proprietary APIs, no hidden state.

"How do I provision infrastructure across VMware, AWS, and Azure with one declarative workflow and a clear audit trail?"

VMware-Centric Catalog Portal

VMware Aria Automation provides a polished portal for catalog-driven VM provisioning tightly integrated with vSphere. But orchestration logic lives in vRO—JavaScript with proprietary APIs, ambiguous error messages, and no native Git integration. Expanding beyond VMware infrastructure adds friction.

"Why does debugging a failed vRO workflow take hours? And why can't I version-control these JavaScript workflows properly?"

Replace vRA/vRO
with Modern Infrastructure Automation

Unified Infrastructure Automation

Provision VMs, run Terraform, and configure with Ansible in one YAML workflow
Self-service Apps with dynamic forms, approvals, and RBAC per namespace
Full audit trail and evidence logging for compliance
Git-native—every workflow is code, reviewed, and versioned
Multi-cloud: vSphere, AWS, Azure, GCP, Kubernetes from one platform

Legacy VMware Portal

vRO workflows in JavaScript with proprietary APIs—poor DX, hard to debug
Ambiguous error messages make troubleshooting time-consuming
No native Git integration—workflows live in the UI
Deep vSphere coupling creates friction when expanding to multi-cloud
High licensing costs tied to VMs and users; migration risk with Broadcom acquisition

Organizations like BHP and Capgemini replaced VMware Aria Automation (vRA/vRO) citing poor developer experience, ambiguous logs, and high licensing costs as the main drivers. Kestra provides the same vSphere-native VM lifecycle management—with Terraform, Ansible, and multi-cloud support added—in a Git-native platform that works in air-gapped, hybrid, and multi-cloud environments.

Time to First Infrastructure Automation Workflow

Kestra starts in minutes with Docker Compose. VMware Aria Automation requires an existing vSphere environment, enterprise licensing, and a multi-step installation wizard that typically takes days and professional services.

~5

Minutes

curl -o docker-compose.yml \
https://raw.githubusercontent.com/kestra-io/kestra/develop/docker-compose.yml
docker compose up

# Open localhost:8080
# Pick an Infrastructure Automation Blueprint, run it. Done.

Download the Docker Compose file, run it, open the UI, and pick an infrastructure automation Blueprint. Your first provisioning workflow includes a dynamic approval form, Terraform apply, and Ansible configuration—all in readable YAML ready for Git.

Days

to weeks

# VMware Aria Automation
# Prerequisites:
# - Existing vSphere/vCenter infrastructure
# - Broadcom enterprise license
# - Aria Automation appliance deployment
# - vRO configuration and endpoint registration
# - Service catalog setup
# Typical time: 2-5 days + professional services

VMware Aria Automation requires an existing vSphere environment, enterprise licensing, and a multi-step installation wizard. A typical deployment takes days of infrastructure preparation and often requires Broadcom professional services before the first workflow runs.

Declarative YAML vs. JavaScript + Proprietary vRO APIs

Kestra: Readable, reviewable, deployable

id: vm_provision_with_approval
namespace: infra.ops

inputs:
  - id: vm_name
    type: STRING
  - id: environment
    type: SELECT
    values: [dev, staging, prod]

tasks:
  - id: request_approval
    type: io.kestra.plugin.core.flow.Pause
    onResume:
      form:
        fields:
          - id: approved
            type: SELECT
            values: [yes, no]

  - id: provision
    type: io.kestra.plugin.terraform.cli.TerraformCLI
    commands:
      - terraform apply -auto-approve
    env:
      TF_VAR_vm_name: "{{ inputs.vm_name }}"

  - id: configure
    type: io.kestra.plugin.ansible.cli.AnsibleCLI
    commands:
      - ansible-playbook configure.yml

  - id: close_ticket
    type: io.kestra.plugin.servicenow.table.Update
    table: incident
    id: "{{ trigger.body.sys_id }}"
    data:
      state: resolved

YAML workflows read like documentation. The AI Copilot writes them for you. Every workflow goes through Git and CI/CD—no hidden state in a UI. Approvals, secrets, retries, and ITSM integration are first-class YAML constructs.

vRO: JavaScript, proprietary APIs, poor DX

// VMware vRO workflow (JavaScript + proprietary APIs)
// No native Git, hard to test, ambiguous errors
System.log("Starting VM provisioning...");
var vcPlugin = Server.findForType("VC:SdkConnection")[0];
var datacenter = vcPlugin.getAllDatacenters()[0];
var folder = VcPlugin.getAllVirtualMachineFolder(datacenter)[0];
var resPool = VcPlugin.getAllResourcePool(datacenter)[0];
var spec = new VcVirtualMachineConfigSpec();
spec.name = System.getContext().getParameter("vmName");
// ... dozens more lines of proprietary JS ...
// Error messages: "Cannot complete login due to an
// incorrect user name or password" (even when it's
// a network timeout, not an auth issue)

VMware vRO workflows are written in JavaScript with proprietary vRO APIs that wrap vSphere objects. They're difficult to version, test, or debug. Error messages are often ambiguous and require vCenter-level access to diagnose. There is no native Git integration—workflows live in the vRO server.

Modern Orchestration vs. Legacy vSphere Portal

One platform for VM provisioning, Terraform IaC, Ansible configuration, incident response, and ITSM integration. Self-service Apps with dynamic forms, approvals, and full audit trails. Works on-prem, in Kubernetes, and in air-gapped environments.

VMware Aria Automation provides a polished portal for catalog-driven VM and service provisioning with deep vSphere integration. Orchestration logic lives in vRO—JavaScript with proprietary APIs, difficult debugging, and no native Git integration. Expanding beyond VMware infrastructure adds significant friction.

Kestra vs. VMware Aria Automation at a Glance


Primary use case	Full infrastructure lifecycle (provision, configure, remediate, decommission)	Catalog-driven VM provisioning tightly coupled to vSphere
Workflow definition	Declarative YAML (code-first, Git-native)	JavaScript + proprietary vRO APIs (GUI-first, no native Git)
Multi-cloud support	Cloud-agnostic: AWS, Azure, GCP, vSphere, Kubernetes	vSphere-first; multi-cloud requires Aria Multi-Cloud add-ons
Developer experience	YAML workflows, clear error messages, full execution logs	Ambiguous error messages, proprietary APIs, difficult debugging
IaC integration	Native Terraform, Ansible, PowerShell, Python, Pulumi support	vRO plugins (limited); Terraform requires extra configuration
Self-service Apps	Built-in dynamic forms, approvals, and RBAC per namespace	vRA service catalog (VMware-centric, limited extensibility)
Air-gapped deployment	Fully supported (on-prem, Kubernetes)	Requires vSphere infrastructure; limited true air-gap support
Version control	Native (Git, CI/CD, Terraform provider)	No native Git—workflows live in vRO server
Observability	Full execution logs, artifact storage, clear error messages	Ambiguous vRO logs; requires vCenter access to diagnose failures
Event-driven triggers	Webhooks, schedules, file detection, message queues, flow triggers	Catalog requests and basic event subscriptions
Licensing model	Flat instance + worker-based pricing	Per-user + per-VM (Broadcom); costs increasing post-acquisition

We replaced VMware Aria Automation because debugging vRO workflows was a nightmare—ambiguous errors, JavaScript everywhere, and no way to version-control our provisioning logic. Kestra gave us declarative YAML workflows in Git, clear logs, and multi-cloud support we couldn't get from vRA.

Platform Engineering Lead @ BHP

60%Reduction in provisioning time

1Platform instead of vRA + vRO + separate tools

100%Audit coverage across all environments

Kestra Is Built for the Full Infrastructure Lifecycle

Replace vRA/vRO With Better DX

Kestra handles catalog-driven VM provisioning with dynamic Apps, approval gates, and vSphere integration—everything vRA does, plus Terraform, Ansible, and multi-cloud support. One tool, one contract, one set of logs. No JavaScript, no proprietary APIs.

Git-Native from Day One

Every workflow is YAML you can commit, review in a pull request, and deploy through CI/CD. BHP's team manages all their infrastructure provisioning logic as code—versioned, testable, and auditable. No hidden state in a portal, no manual change tracking.

Works Anywhere: Cloud, On-Prem, Air-Gapped

Deploy Kestra on Kubernetes, Docker, or bare metal. Run remote workers close to vSphere targets for hybrid environments. Air-gap deployments supported for regulated industries—no external connectivity required. ITZBund and the Austrian Ministry of Defense run Kestra fully disconnected.

When to Choose Kestra vs. VMware Aria Automation

Choose Kestra When

You need to replace vRA/vRO or extend your VMware automation to multi-cloud.
Your workflows span Terraform, Ansible, PowerShell, and cloud APIs in a single flow.
Audit trails, compliance logging, and air-gapped deployment are requirements.
You want Git-native workflows instead of JavaScript in a proprietary vRO server.
Broadcom's post-acquisition pricing changes make vRA/vRO increasingly expensive.

Consider VMware Aria When

Your infrastructure is exclusively VMware vSphere with no plans to expand.
You need deep vSphere NSX/ALB policy guardrails that vRA provides out of the box.
Your team has significant existing investment in vRO workflows and migration isn't feasible now.
You require specific Aria suite integrations (Aria Operations, Aria Log Insight) in one vendor bundle.

Getting Started with Modern Infrastructure Orchestration

See how Kestra replaces VMware Aria Automation with declarative YAML workflows across any cloud.

Book a Demo