Temporal vs Conductor

Temporal and Conductor both run durable workflows that survive failures, but they ask different things of your developers and operators. This page shows which fits your team, your persistence stack and your licensing terms.

On this page

Temporal vs Conductor: when each one fits

Choose Temporal if your team wants long-running service logic written as code in one of its SDK languages, with the engine replaying a complete event history to resume work after failures. Choose Conductor if you want workflows defined as versioned JSON graphs that are inspectable outside the code, with business logic in workers written in whatever language each team already uses. The decision turns on five drivers: the developer model, the operational footprint, the persistence and visibility stack, the license, and the stewardship history. Teams that want engineers to reason about a workflow as ordinary code, including its branching and waiting, usually lean toward Temporal. Teams that want operators, architects and auditors to read and change the process definition without opening application code usually lean toward Conductor.

On operations, a self-hosted Temporal Service runs Frontend, History, Matching and Worker services plus a persistence store, and its tested options are Cassandra, PostgreSQL and MySQL. Conductor's server requires Java 21 or later and lists PostgreSQL and Redis among its supported persistence backends, with Elasticsearch or OpenSearch for indexing. Ask each vendor or community channel to confirm which combination of persistence, indexing and message broker your team would run in production, and cost that stack in your own environment. Authentication also differs: if no Authorizer is configured, self-hosted Temporal uses the default noopAuthorizer, which allows every API request, so plan mTLS, a ClaimMapper and an Authorizer before exposing the frontend. Confirm the equivalent access controls for Conductor in its documentation before you decide.

On licensing and stewardship, Temporal Server is MIT licensed and Temporal Technologies sells Temporal Cloud alongside it. Conductor OSS is Apache-2.0 licensed, but Netflix discontinued maintenance of Conductor OSS on GitHub effective December 13, 2023 and archived its repository in favor of an internal fork, so the open-source line is now maintained by Orkes and the community. Orkes Conductor is the enterprise platform built on Conductor OSS. Ask whether your compliance team needs a vendor-backed roadmap, a support contract, or only the open-source code, and check the current maintainer activity in the conductor-oss repository before committing. A pilot on your own infrastructure will show more about fit than either description.

Which scenarios favor Temporal and which favor Conductor

This table maps common team situations to the platform that usually fits better, and states the condition that makes each choice hold. Read each row as a starting point, then check the condition against your own team, languages and review process before deciding.

ScenarioBetter fitCondition that makes it hold
Payments saga across several services that must compensate on failureTemporalCompensation logic is coded as ordinary functions with retries and a replayable event history, and engineers need to step through failure paths in a debugger.
Java and TypeScript developers writing long business processesTemporalThe team wants workflow logic in its own languages, tested with ordinary unit tests, and accepts that workflow code must stay deterministic.
Platform team wants visual definitions reviewed by non-developersConductorReviewers such as operations or compliance staff read workflow graphs directly, and definitions are versioned as JSON for change review.
AI agent pipeline spanning several languages with human-readable step graphsConductorThe pipeline is mostly orchestration of tasks handled by workers in different languages, and reviewers need to inspect the graph between steps.
Complex branching logic with heavy loops and dynamic state written by developersTemporalBranching depends on runtime data that is easier to express in code, and the team prefers code review over graph editing.
Team wants to keep workflow logic in one code repository with application codeTemporalWorkflow definitions ship with the service code, so release and rollback follow the same pipeline as the rest of the application.
Workers in many languages with the orchestration definition kept separate from codeConductorBusiness logic lives in workers written in any supported language, and the workflow definition is maintained as a separate versioned artifact.
Team already operates Cassandra, PostgreSQL or MySQL and needs a supported persistence choiceTemporalThe team plans to confirm which persistence versions Temporal tests against, and needs a Visibility store for listing workflows at scale.
Team must run a service that needs a Java 21 runtime and a PostgreSQL-backed storeConductorThe platform already runs Java 21 and PostgreSQL, and the team will confirm the persistence and indexing setup for its own environment.

How each engine is built and what that means for operations

Both engines ask a platform team to run a server, a database and, for search, an indexing layer. The difference is how many separate services and stores sit behind the workflow API, and how much of the design lives in workflow code versus JSON definitions. Count the components, backups and upgrade paths before you compare features.

Temporal Service components

A self-hosted Temporal Service runs Frontend, History, Matching and Worker services, plus a persistence store and a visibility store. Each service can be scaled and monitored on its own, so a platform team owns more moving parts than a single process. Check who on your team will own the cluster, its upgrades and its on-call rotation before choosing it.

Temporal persistence choices

Temporal persistence is tested on Cassandra, PostgreSQL and MySQL, and SQLite is meant only for development and testing. Cassandra deployments also need a separate visibility store, so the choice of database changes the number of stores to back up. Confirm the database versions you plan to run against the tested list before you commit to a layout.

Temporal deployment routes

Temporal can be deployed with Docker Compose, Go binaries, Helm charts that run each service in its own Kubernetes pod, or a custom Go build that imports the server package. Helm chart versions below 0.73.1 do not work with server images 1.30 and later, so chart pinning is part of the upgrade plan. Choose the route your platform team already operates well, and test upgrades in a non-production namespace first.

Conductor server requirements

A Conductor server needs Java 21 or later, and the official Docker image bundles the server and the UI in one deployable unit. That keeps the runtime footprint simple for a team that already runs JVM services. Confirm your base images, JDK patching and container scanning process cover the Java runtime, since it becomes part of your supply chain.

Conductor persistence and brokers

Conductor documents five persistence backends, including PostgreSQL and Redis, and six message brokers. Your choice of backend and broker determines which stores need backups, failover testing and capacity planning. Ask which combination the vendor and community test together, because the number of valid pairings is what drives your operating effort.

Search indexing for both

Conductor relies on Elasticsearch or OpenSearch for indexing, and Temporal uses Elasticsearch or OpenSearch for advanced visibility at scale. Either way, a search cluster becomes a store your team must size, back up and upgrade alongside the workflow engine. Ask for index retention and reindexing procedures before you treat search as an optional add-on.

Capability comparison from supplied facts

This table sets Temporal's code-first durable execution model against Conductor's JSON-defined workflow graphs across the capabilities that matter for a regulated deployment. Read each row as a checklist: where a cell says to confirm, verify that capability with the project or Orkes documentation before you rely on it.

CapabilityTemporal (self-hosted)Conductor OSS
Workflow definition modelWorkflows written as code in general-purpose languages such as Go, Java, TypeScript and PythonWorkflows defined in JSON as versioned, inspectable graphs; workers in any language run the business logic
SDK languagesOfficial SDKs for Go, Java, TypeScript and Python in the supplied facts; confirm the full list in Temporal docsOfficial SDKs for Java, Python, JavaScript, Go and C#; Ruby SDK incubating
Determinism and replayComplete ordered event history used to replay and resume workflows after failures; workflow code must be deterministicDurable graph state tracked by the server; confirm replay and determinism rules with the Conductor documentation
Persistence backendsTested on Cassandra, PostgreSQL and MySQL; SQLite for development onlyFive persistence backends including PostgreSQL and Redis; confirm the full list in the Conductor documentation
Visibility or indexingAdvanced visibility on Elasticsearch or OpenSearch recommended beyond a few workflow executions; SQL options also supportedElasticsearch or OpenSearch used for indexing; confirm the supported search options for your version
Authorization by defaultDefault noopAuthorizer allows every API request until an Authorizer is configuredConfirm default access control and RBAC behavior with the project or Orkes documentation
mTLSSupported, with separate settings for internode and frontend trafficConfirm mTLS options with the Conductor project or Orkes documentation
OIDC single sign-on for Web UISupported for the Web UI in self-hosted deploymentsConfirm SSO options for the Conductor UI with the project or Orkes documentation
Payload encryptionThrough custom codecs and a codec serverConfirm payload encryption options with the Conductor documentation
LicenseMIT (Temporal Server)Apache-2.0 (conductor-oss/conductor); Netflix's original repository is archived
Managed optionTemporal Cloud, a managed service from Temporal TechnologiesOrkes Conductor, a hosted enterprise platform built on Conductor OSS across major clouds

What each license allows and what is paid for

Temporal Server is licensed under the MIT license, so your team can run, modify and embed it in its own infrastructure without a license fee for the server software. The recurring costs of self-hosting are the infrastructure and the people who operate the Frontend, History, Matching and Worker services, plus the persistence and visibility stores. Temporal Technologies also sells Temporal Cloud as a managed service, and its published pay-as-you-go pricing is the reference point for that path.

  • Server license: Temporal Server is MIT licensed, so the server software itself carries no license fee.
  • Action pricing: Pay-as-you-go pricing starts at 50 US dollars per million actions, according to the Temporal pricing page.
  • Storage pricing: Active storage is listed at 0.042 US dollars per GB-hour and retained storage at 0.00105 US dollars per GB-hour.
  • Availability terms: The listed SLA is 99.9%, or 99.99% with high availability.
  • Identity features: SAML SSO is listed as part of the cloud offering.

Before you compare totals, ask Temporal how actions are counted for your workflow shape, how retained storage is measured over your retention period, and which tier includes the availability terms you need.

How determinism changes what developers write

Temporal's model shapes day-to-day code. A Temporal workflow is ordinary Go, Java, TypeScript or Python code, but it must be deterministic, because the service rebuilds state by replaying the complete ordered event history after a worker crash or deploy. That means workflow code cannot call the clock, random number generators, network APIs, databases or file systems directly. Developers move those calls into activities, which Temporal records and retries, and they use the SDK's workflow-side equivalents for time and randomness. The practical check is a replay test in CI against recorded histories, so a reviewer catches a changed call order before it reaches production. Versioning is the other recurring discipline: when a running workflow's code path changes, teams must use the SDK's patching or versioning mechanisms so in-flight executions still replay correctly. Confirm the exact APIs for your chosen SDK in the Temporal Workflows documentation before you set review rules.

Conductor takes the opposite approach to where logic lives. A workflow definition is JSON describing a graph of tasks, and each definition is versioned and inspectable, so a reviewer can read the sequence, branches and retry settings without reading application code. The business logic runs in workers written in any supported language, which the Conductor SDKs cover for Java, Python, JavaScript, Go and C#. This matters most for mixed teams where analysts, operations staff or compliance reviewers approve flow changes, and for organizations that want one visible definition per process. The trade-off is that the graph is only as expressive as its task types and expressions, and complex logic may end up split across workers in ways that are harder to test as a unit. Large engineering teams with strong code review and integration testing often find Temporal's code-level tests more natural, while a reviewer-heavy organization may prefer the graph. Decide which group signs off on changes, then test that review path on a real workflow before choosing.

What drives the running cost of each engine

Running Temporal or Conductor costs more in people and operating time than in software licenses, since both are Apache-2.0 or MIT licensed. The cards below separate the components that recur, the work that is one-time, and the questions to put to each vendor or partner before you compare quotes.

Infrastructure footprint

A self-hosted Temporal Service runs Frontend, History, Matching and Worker services, plus a persistence store and a separate visibility store. Conductor needs its server, one of its five supported persistence backends, a message broker and an Elasticsearch or OpenSearch index for search. Count every stateful component you must back up, monitor and size, because each one adds hosting and on-call load. Ask for a quote that lists each component, its high-availability layout and its backup approach.

Engineering skills and SDK work

Temporal workflows are written in Go, Java, TypeScript or Python, and teams must learn its determinism rules before they ship changes safely. Conductor workflows are JSON definitions, but every business task still runs in a worker written in your chosen language, and the server requires Java 21 or later. Price the skills you already have against the skills you must hire. Ask the partner which languages and SDK versions their estimate covers.

Upgrade and version discipline

Temporal guidance is to upgrade one minor version at a time, moving to the latest patch of the current minor first, because backward compatibility is guaranteed only between successive minor versions. Schema upgrades must run before server upgrades when release notes call for it. Helm chart versions below 0.73.1 do not work with server images 1.30 and later. Ask for upgrade runbooks, test environments and a count of upgrade windows per year in the scope.

Support and hosting options

Temporal Cloud is a managed option with published pay-as-you-go pricing that starts at 50 US dollars per million actions, plus storage charges, and it carries SLA tiers. Orkes offers hosted Conductor deployments across major clouds, and self-support means your team carries the pager. These options change who is paid for uptime and who operates the cluster. Request written SLA terms, support hours and escalation paths from each option before you assume any of them.

One-time versus recurring spend

One-time work includes architecture, cluster build, identity and TLS setup, workflow migration and the first production runbooks. Recurring work covers hosting, persistence and search capacity, patching, upgrades, on-call rotations and worker fleet operations. Fixed-scope engagements separate these phases in writing, while retainers cover ongoing upgrades and support. Ask every bidder to split the quote into one-time and recurring lines so you can compare the five-year picture.

Where implementation projects usually run long

Temporal projects tend to run long on the security and storage decisions made before the first workflow is deployed. The self-hosted Temporal Service runs Frontend, History, Matching and Worker services on top of a persistence store and, for search, a visibility store. Persistence is tested on Cassandra, PostgreSQL and MySQL, with SQLite meant only for development and testing, so the database choice is the first decision to lock down in writing. Cassandra deployments also need a separate visibility store, and Cassandra visibility was removed in Temporal Server 1.24. Elasticsearch or OpenSearch is the recommended visibility store once a deployment has more than a few workflow executions, so scope the search tier, its sizing and its upgrade path before any load testing begins. Confirm the supported version pairs against the Temporal persistence documentation for your target server release.

The second source of delay is access control. If no Authorizer is configured, the default noopAuthorizer allows every API request with no authentication or access control, so the ClaimMapper, the Authorizer plugin, mTLS for internode and frontend traffic, and OIDC single sign-on for the Web UI need to be designed and tested before any API is exposed. Keep the services on hosts that are not reachable from the public internet, and agree in the scope who owns certificate issuance and rotation. Payload encryption is a separate workstream: custom codecs and a codec server determine what Temporal stores as ciphertext, and codec design touches application teams, not only the platform team. Written scope should name the codec owner, the key management approach and the test plan for replay with encrypted payloads.

Conductor projects tend to run long on the server, the index and the governance of JSON definitions. Conductor OSS needs Java 21 or later, and its persistence choice spans five backends, including PostgreSQL and Redis, with six message brokers and Elasticsearch or OpenSearch for indexing. Each combination changes the operational runbook, so the scope should fix one persistence backend, one broker and one search engine rather than leaving them open. Workers are written in the chosen language with the official Java, Python, JavaScript, Go or C# SDK, and the team should agree how worker deployments are versioned against the workflow definitions they serve. Finally, workflow definitions are JSON graphs, so a written process for versioning, reviewing and promoting them across environments is part of the work, not an afterthought. Ask for that process, and the list of brokers and backends in scope, in the written statement of work before work starts.

Moving a workflow estate from one engine to the other

The sequence below moves a set of workflows from Conductor to Temporal, or the reverse, with in-flight executions finishing safely on the engine that started them. The output is a documented cutover that your operations team can run and roll back.

  1. Inventory running workflows and their state

    Platform engineering lists every workflow definition, its version, its worker code and the systems it calls, then records how many executions are running and how long each typically lasts. Owners of each business process confirm which flows are critical. The output is a register that shows which workflows hold long-lived state and which only run briefly. You know this step is done when every running definition has an owner and a state classification.

  2. Decide which workflows move now

    The team separates workflows that can start fresh on the new engine from those that must finish where they began. Short-lived flows are often good candidates for new starts only, while long-running processes with human waits or external callbacks usually need an explicit drain plan. Security and compliance owners review data handling for each candidate. The output is a signed migration list with a decision per workflow. You know this step is done when every item is labeled new starts only or drain in place.

  3. Map task types to the target model

    Engineers translate each Conductor task type and JSON graph branch into a Temporal workflow function and its activities, or the reverse. Where the models differ, such as Conductor's declarative task outputs versus Temporal's deterministic code paths, the team writes the mapping down and notes any behavior that does not carry over one to one. The output is a mapping document reviewed by the service owners. You know this step is done when each task type has a named target and each gap has a recorded decision.

  4. Rebuild worker and activity code

    Developers port worker logic into the SDK of the target engine, keeping business rules, data access and external API calls in their existing form where possible. Retry policies, timeouts and error classification are rewritten to the new engine's settings rather than copied, and observability hooks are reconnected to the team's logging and metrics stack. The output is a tested build for each migrated workflow. You know this step is done when unit tests and replay or integration tests pass against the target engine.

  5. Run both engines in parallel

    The platform team deploys the new cluster next to the existing one and routes new starts to it in controlled steps, while in-flight executions stay where they are. Operations staff watch error rates, latency, queue backlogs and alert behavior on both sides and keep a documented rollback path to the old routing. The output is a traffic record showing the share of new starts on each engine over time. You know this step is done when the new engine handles all intended new starts without unresolved incidents.

  6. Retire the old cluster after drain

    Once the old engine reports no open executions for the migrated workflows, the team confirms that audit records, run histories and documentation have been archived under the retention rules that apply to them. Access to the old cluster is removed and the decommissioning is recorded in the change log. The output is a closed decommission record that names the owner who approved it. You know this step is done when no running executions remain and the archive check is signed off.

Questions buyers ask before choosing between Temporal and Conductor

How much effort does self-hosting Temporal take compared with self-hosting Conductor?

Both are self-hosted platforms with several moving parts, so the effort is mostly about the components you run and the skills your team already has. A self-hosted Temporal Service runs Frontend, History, Matching and Worker services plus a persistence store and, for advanced visibility, a separate store such as Elasticsearch or OpenSearch. Conductor needs a Java 21 or later server, a persistence backend such as PostgreSQL or Redis, and Elasticsearch or OpenSearch for indexing if you want search. Your team needs Kubernetes or Docker operations experience, database administration, and developers who can write deterministic workflow code (Temporal) or maintain JSON definitions and workers (Conductor). Ask each vendor or Orkes to walk through your target topology before you estimate staffing.

Can our team run Temporal or Conductor without outside help?

Yes, if you have engineers who already operate stateful services on Kubernetes or VMs, can manage upgrades, and can own the security configuration. Temporal's self-hosted security defaults are open: if no Authorizer is configured, the noopAuthorizer allows every API request, so access control, mTLS and SSO must be set deliberately. Conductor has its own hardening, authentication and network decisions to make. Outside help is most useful for the first deployment, for hardening against your policies, and for the upgrade process. DeployOpen plans, implements, hardens, backs up, upgrades and documents self-hosted platforms in your own infrastructure, and most engagements are fixed-scope with the scope agreed in writing before work starts.

How long does a first production deployment take, and what sets that timeline?

No supplied figure gives a typical duration for either engine, so treat any number you hear as a guess until it is tied to a scope. The main drivers are the persistence and visibility stores you choose, whether you need mTLS and SSO on day one, how many workflow types and workers you must migrate or build, your CI and observability integration, and how many environments you need before production. For Temporal, the choice of Cassandra, PostgreSQL or MySQL and the Helm chart version compatibility with your server image add decisions early. For Conductor, the persistence backend, broker choice and worker languages set the early shape. Ask for a written scope that lists deliverables, environments and acceptance criteria before you compare timelines.

What does the work need from our internal staff?

Plan for named owners in three areas: platform operations, application developers and security. Platform operators own the cluster, upgrades, backups and capacity. Developers own workflow code in Temporal, where determinism and versioning rules apply, or workflow JSON and workers in Conductor, where each worker must be kept in step with its task definitions. Security staff own authentication, authorization mapping, network exposure and payload handling. Temporal's documentation says services should run on hosts not reachable from the public internet, so network design needs an owner early. Ask any implementation partner which of these roles they will fill, which they expect your staff to fill, and how knowledge transfer is documented.

Does Temporal Cloud or Orkes remove the operations burden?

Yes, they remove part of it, but not the application work or your security decisions. Temporal Cloud is a managed service with pay-as-you-go pricing that starts at 50 US dollars per million actions, with storage charged per GB-hour, and advertised SLAs of 99.9% or 99.99% with high availability, per Temporal's pricing page. Orkes offers hosted deployments across major cloud providers and an enterprise platform built on Conductor OSS. A managed service still needs your workflow design, worker deployment, identity mapping and data classification. Before deciding, confirm where data resides, how payload encryption is handled, which features are enterprise-only, and what the contract guarantees in writing.

How does the Netflix to Orkes change affect long-term support for Conductor?

Conductor OSS is no longer maintained by Netflix. Netflix discontinued maintenance of Conductor OSS on GitHub effective December 13, 2023 and archived its repository in favor of an internal fork. The conductor-oss/conductor repository is Apache-2.0 licensed and is actively maintained by Orkes and the community, with Conductor v3.32.5 published on September 25, 2026. Long-term support therefore depends on the community project and on whether you buy Orkes Conductor, which is built on the OSS base with full compatibility. Ask Orkes about its support terms, the release cadence of the community project, and what happens to your version pinning if you move between the open and enterprise builds. Temporal's MIT-licensed server is maintained by Temporal Technologies, so the stewardship question is different there.

Can we migrate from one engine to the other later?

Migration is possible in principle but never a simple export, because the two engines model work differently. Temporal workflows are code with an ordered event history that is replayed, while Conductor workflows are versioned JSON graphs executed by workers in any language. Moving means redesigning definitions, re-implementing task logic in the target SDK, and deciding what to do with in-flight executions. Plan a cutover that drains running workflows, keeps both systems available during the transition, and tests replay or retry behavior explicitly. Reduce lock-in early by isolating business logic from orchestration code, documenting your workflow contracts, and keeping persistence and identity choices standard. A scoped assessment of the existing workflows is the practical first step.

How DeployOpen helps choose, implement or migrate

DeployOpen is a Chainscore Labs company that plans, implements, integrates, hardens, documents and supports self-hosted open-source platforms inside the client's own infrastructure. For a Temporal or Conductor decision, the work starts with a written scope that fits the platform you choose to your workflows, identity model and operating constraints.

How we scope

  • Map which workflows need code-defined logic, which need JSON graphs, and which teams will write and maintain them
  • Confirm the persistence store, visibility store and hosting target your infrastructure can support
  • Agree deliverables, timelines and exclusions in writing before any work starts, since most engagements are fixed-scope

How we build

  • Deploy the chosen engine in your cloud account, data center or air-gapped network with the persistence and visibility stores you approved
  • Wire identity, mTLS, network restrictions and workflow payload handling to your existing standards and review them with your security team
  • Test failure recovery, retries, upgrades and worker scaling against the scenarios your scope defines

How we hand over

  • Document the architecture, configuration, upgrade sequence and runbooks so your staff can operate the platform
  • Deliver the test results, configuration evidence and control mappings your assessors may ask for, without issuing any audit or certification
  • Walk your engineers through workflow authoring, versioning and deployment conventions for the chosen engine

How we support

  • Offer ongoing support, upgrades and continuous testing as a retainer if your team wants DeployOpen to keep operating with them
  • Plan minor-version upgrades, schema changes and patch cycles against the vendor release notes for your deployed versions
  • Revisit the scope and documentation when you add workflows, change persistence, or move between engines

Talk to our team.

Tell us what you're working on, whether it's a deployment, an audit, a security test or a cyber range. You'll speak with an engineer who can help you scope it.

  • 30-minute call: free, with no obligation.
  • NDA on request: we can sign before you share details.
  • Clear next steps: a scope and plan after the call.