Temporal advanced visibility with Elasticsearch or OpenSearch

Advanced visibility lets self-hosted Temporal answer workflow search and custom attribute queries from a separate search store. This page covers the supported versions, configuration sequence, security and the planning needed for schema changes and a move between stores.

On this page

Temporal advanced visibility with Elasticsearch or OpenSearch: what the integration does

If your self-hosted Temporal deployment needs to search workflows by status, workflow ID or custom search attributes, advanced visibility on Elasticsearch or OpenSearch is the search store Temporal supports for that need. Basic listing covers simple lookups, but it does not hold up once a production namespace accumulates many executions and operators need to filter across several fields at once. Temporal's documentation recommends Elasticsearch or OpenSearch for anything beyond a few workflow executions, so for most production teams this is the expected path rather than an optional add-on. The decision to adopt it should be made during planning, with an owner, a version and an operating model agreed before the first namespace depends on search.

Temporal Server keeps two separate storage concerns. Persistence holds workflow state and history, and it runs on Cassandra, PostgreSQL, MySQL or SQLite (the last only for development and testing). The visibility store holds the searchable workflow metadata, and it is configured separately from persistence, so you can pair, for example, PostgreSQL persistence with an OpenSearch visibility store. Choosing the visibility store is a planned decision because it fixes the query model your teams will use, the index schema your operators maintain and the version matrix you must track through every server upgrade. Temporal's visibility documentation lists the Elasticsearch and OpenSearch versions supported by each server line, and you should confirm that range against your target server version before you select a store version. Cassandra visibility was removed in version 1.24, so a Cassandra-based deployment needs its own visibility plan.

The integration is configured on the Temporal Server side, in the server's persistence and visibility settings. Workers and client applications keep calling the same Temporal APIs, and they gain richer search results once the server points at the new store. Ownership therefore sits with the team that runs the Temporal Server, and changes to the visibility configuration should go through the same review, change control and environment promotion used for other server settings. The deployment method also shapes where those settings live. Docker Compose, Go binaries and Helm charts each carry the configuration differently, and the Helm chart version must match the server image line, so confirm that pairing in the deployment documentation before you write the configuration.

Before work starts, make four decisions in writing. First, choose the visibility store and version, and record the Temporal Server minor line it must support. Second, name who operates the search cluster, including patching and capacity, because it becomes a production dependency for workflow search. Third, list the custom search attributes you need and confirm how they are registered before workflows start using them. Fourth, restrict access to the search cluster and to the Temporal Services. Temporal's deployment guidance says its services should run on hosts not reachable from the public internet. If no Authorizer is configured, the server uses a default that allows every API request, so set access control before you expose search to operators.

What you need before connecting Temporal to Elasticsearch or OpenSearch

These six prerequisites set the boundaries for the rest of the setup. The Temporal Server version decides which search stores you can use, the persistence store and search cluster must both be reachable from Temporal, and certificates and network rules control how those components talk to each other.

Supported Temporal Server version

Advanced visibility on OpenSearch 2 or later needs Temporal Server 1.30.1 or later. Elasticsearch 7 and 8 are also supported, so check the Temporal Server minor line you run against the store version before you choose one. Plan 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 two successive minor versions. Read the release notes for the target version before you start.

Running persistence store

Temporal keeps its main workflow data in a persistence store, and that store must already be running before you add visibility. Advanced visibility is a separate store, so the search cluster does not replace the persistence store. Confirm that your persistence engine is on a tested version: Cassandra 3.11, 4.0 or 5.0.4 or later, PostgreSQL 13 to 16, or MySQL 5.7 or 8.0.19 or later. SQLite is meant only for development and testing.

Helm chart version for Kubernetes

If you deploy Temporal on Kubernetes with the Helm chart, use chart version 0.73.1 or later when you run server images 1.30 and later. Earlier chart versions do not work with those images, so pin the chart and image versions together in your deployment repository. This requirement applies only to the Helm route, since Docker Compose, Go binaries and custom Go builds are also documented deployment options. Confirm the chart version against the Temporal deployment docs before every upgrade.

Search cluster sized and installed

Install OpenSearch 2 or later, or Elasticsearch 7 or 8, with a method its project documents, such as Docker, Helm, the OpenSearch Kubernetes Operator, packages or Ansible. Size the cluster for the number of workflow executions and custom search attributes you expect, then test that sizing under realistic load before go-live. Confirm the store's own version support and licensing with its vendor or project, because those details are outside the sources behind this page. OpenSearch is released under the Apache License 2.0.

TLS certificates for both sides

Plan certificates for Temporal's internode and frontend traffic, and separately for the search cluster's node and client traffic. Self-hosted Temporal supports mTLS with separate settings for each traffic type, so decide which certificate authority issues each set and how rotation will work. Every certificate must cover the host names that Temporal and the search client use to connect. Confirm the exact settings in the Temporal security docs and the OpenSearch security docs before you configure either side.

Private network paths and access

Temporal services should run on hosts that are not reachable from the public internet, with network access limited to trusted internal networks. Open only the paths that Temporal services need to reach the persistence store and the search cluster. If no Authorizer is configured, Temporal falls back to a default that allows every API request, so restrict the network and set up authorization before any user or client can reach the frontend. Record each allowed path in a firewall review.

How the visibility store serves workflow search

Temporal keeps workflow history and execution state in the persistence store, and it keeps a separate set of visibility records that describe each workflow execution so operators and clients can list and filter them. When a workflow starts, changes state or closes, the server writes a visibility record to the configured visibility store. List and count requests from the Temporal CLI, the Web UI and SDK clients then read from that store, not from workflow history. Search attributes, including the custom ones you register, are indexed as part of these records, so the filter fields available to operators depend on what is registered for each namespace and on the index schema. Confirm the write and read path for your server version in the visibility documentation before you design dashboards or runbooks around it.

Moving search off the primary persistence store gives you richer filtering over large workflow populations and custom search attributes, and it keeps heavy list queries from competing with history reads and writes on the database. The cost is a second stateful system. You take on its sizing, backups, upgrades, access control and retention, and you must coordinate deletion across both stores so that search results do not point at history that no longer exists. Visibility records are also updated after the persistence write, so a workflow may take a short, variable time to appear in list results. Ask Temporal to describe the expected lag for your version, then measure it under your own load during testing.

Search latency and index health now affect the Temporal service directly. When an operator or a client lists workflows, the request depends on the search cluster's response time, so slow queries or an overloaded cluster degrade those calls. If the cluster falls behind on writes, visibility data goes stale and workflows can appear missing or in the wrong state, which is an operational problem even when history is healthy. Plan to watch cluster health signals such as disk pressure, shard allocation, index growth and indexing backlog, and to alert on them alongside Temporal service metrics. The sibling monitoring page covers the metrics side, and you should confirm which visibility metrics your server version emits before you set thresholds.

Choose the visibility store against your query volume and retention needs, not against what the platform team already runs. Cassandra visibility was removed in Temporal Server 1.24, so Cassandra can no longer serve as the visibility store on current releases. MySQL, PostgreSQL and SQLite were documented visibility options from server version 1.20, and the documentation recommends Elasticsearch or OpenSearch for anything beyond a few workflow executions. Elasticsearch 7 and 8 are supported, and OpenSearch 2 or later is supported from Temporal Server 1.30.1. Estimate how many list and filter calls your operators and services make, how long records must stay searchable, and whether your team can operate a search cluster. Then request the supported version matrix for your target server release in writing.

Connecting Temporal advanced visibility to Elasticsearch or OpenSearch

This sequence connects Temporal advanced visibility to an Elasticsearch or OpenSearch cluster, from version checks through a filtered query on a custom search attribute. Each step ends with a check you can run in your own environment. Exact configuration keys and commands change between releases, so take them from the current Temporal visibility and self-hosted security docs for your server version.

  1. Confirm server and search store versions

    The platform engineer checks the Temporal Server version and the Elasticsearch or OpenSearch version against the visibility support matrix in the current Temporal visibility docs. Advanced visibility on OpenSearch 2 or later requires Temporal Server 1.30.1 or later, and Elasticsearch 7 and 8 are also listed as supported. Confirm the Helm chart version too, because chart versions below 0.73.1 do not work with server images 1.30 and later. Done when you have a recorded server version, search store version and matrix entry that covers both.

  2. Provision the search cluster with TLS and access control

    The security engineer and platform team deploy the search cluster inside the same trusted network as the Temporal services, with no public endpoint. Enable TLS for node and client traffic, then create a dedicated service account for Temporal with only the index permissions visibility needs. OpenSearch provides role-based access control and TLS through its Security plugin, and Elasticsearch offers its own security features, so confirm the exact settings in each vendor's documentation. Done when an unauthenticated request is rejected and the Temporal service account authenticates over TLS.

  3. Create the visibility index from the documented schema

    The platform engineer creates the visibility index using the schema and index settings listed in the Temporal visibility docs for the server version chosen in the first step. Use the tooling and index name that version documents, and avoid hand-built mappings, because search attribute types must match what the server expects. Keep any alias or naming convention the docs specify so the server can locate the index. Done when the index exists and a request for its mapping returns the base visibility fields without errors.

  4. Set the advanced visibility section in server configuration

    The platform engineer adds the advanced visibility section to the Temporal Server configuration, pointing it at the search cluster endpoint, the TLS trust material and the service credentials created in the second step. Take the exact configuration keys from the current self-hosted guide and visibility docs for your server version, since key names change between releases. Store credentials in your secret store and reference them from the configuration so they stay out of container images. Done when the configuration validates in a test environment and startup logs show a successful connection to the visibility store.

  5. Register custom search attributes in each namespace

    The Temporal administrator registers each custom search attribute with a name and type that match the index mapping. Confirm in the current docs whether registration is needed separately in each namespace, and register every attribute in each namespace that will query it. Use the registration command documented for your CLI version. Done when the attribute list for each namespace shows every planned attribute with its type.

  6. Start the server and list a test workflow

    The platform team starts the Temporal Server with the new configuration and runs a test workflow in a non-production namespace. They then list workflows through the CLI or the Web UI and confirm the test workflow appears in list results, which shows the server is writing visibility records to the search store. If the workflow is missing, check the server logs and the index document count before changing the mapping. Done when the test workflow appears in list results with its status and start time.

  7. Run a filtered query on a custom attribute

    The platform team sets a custom search attribute on two test workflows with different values and runs a list query that filters on that attribute, using the query syntax in the current visibility docs. The query should return only the matching execution, which confirms the attribute is indexed with the right type and can be queried from clients. Run a second query with a value that no workflow has, and confirm it returns no results. Done when the matching query returns the expected execution and the unmatched query returns none.

Mapping custom search attributes to index fields

This table maps each search attribute to its data type, the index field it lands in, its namespace and the queries or dashboards that depend on it. Read the system fields first, then the custom examples, which are illustrative and show how the columns fit together. Plan each namespace's attributes before any workflow writes them, and keep names stable because later changes touch the index and every query that uses them.

AttributeData type and index fieldNamespaceQueries and dashboards
Workflow status (system)System-defined; the server maintains it, so your team does not register itProvided in every namespaceFilter running, completed and failed executions in list queries and the Web UI
Workflow type (system)System-defined; reflects the workflow type used when the execution startedProvided in every namespaceGroup executions by workflow definition in list queries and dashboards
Illustrative: customer tierKeyword type for exact matches; confirm the index field name against the schemapayments-prod (illustrative)Support lookups for open cases in a given tier
Illustrative: order amountNumeric type chosen so range queries work on the index fieldpayments-prod (illustrative)High-value workflow alerts and daily volume reports
Illustrative: case opened timeDatetime type for time-window queriesonboarding-prod (illustrative)Operations dashboard of workflows opened in the last day
RegistrationRegister each custom attribute before any workflow writes itPlan and register separately in each namespaceConfirm how writes for unregistered attributes are handled in your version
Supported typesConfirm the supported attribute types against the current visibility docs before choosingApplies per namespaceCheck before the first registration and before any upgrade
Name and type stabilityRenaming or retyping later requires index and query changesApplies per namespaceEvery saved query, alert and dashboard that references the attribute

Securing the search store and the Temporal access path

Advanced visibility adds a second data store that holds workflow metadata, so it inherits the same exposure risks as the Temporal frontend. The cards below cover the order of work: close the open API, secure transport and network paths, then control who can search the store and what the results reveal.

Configure an Authorizer before exposing the API

If no Authorizer is configured, self-hosted Temporal uses the default noopAuthorizer, which allows every API request with no authentication or access control. Configure an Authorizer and a ClaimMapper before the frontend or the search API is reachable by any client, and test that an unauthenticated or wrong-namespace call is rejected. Confirm the chosen Authorizer behavior against the Temporal security documentation for your server version.

Map identity claims to namespace roles

The ClaimMapper turns JWT or certificate claims into namespace roles that the Authorizer evaluates. Decide which groups or certificate subjects map to read, write and admin roles for each namespace that uses advanced visibility. Document the mapping, because a wrong claim mapping can grant search access to workflows in other teams' namespaces.

Separate mTLS for internode and frontend traffic

Self-hosted Temporal supports mTLS with separate settings for internode traffic between Temporal services and frontend traffic from clients and workers. Plan the certificate authority, issuance and rotation for both paths, and confirm that the search store connection uses TLS as well. Test certificate expiry handling before go-live, since a lapsed certificate on one path can stop workflow processing.

Restrict network access to trusted networks

The Temporal deployment documentation says Temporal services should run on hosts not reachable from the public internet, with network access restricted to trusted internal networks. Apply the same rule to the Elasticsearch or OpenSearch cluster, allowing traffic only from Temporal services, approved workers and administrators. Review firewall rules, load balancer exposure and Kubernetes network policies together, because a single permissive path defeats the rest.

Enforce OpenSearch Security access controls

The OpenSearch Security plugin provides role-based access control, document-level and field-level security, field masking, user impersonation, audit logs and TLS for node and client traffic. Define roles so the Temporal service account can write and query visibility indices, while human users and reporting tools get only the documents and fields they need. Enable audit logging and confirm that the plugin settings match your access model before the index is shared.

Choose an authentication backend for search users

The OpenSearch Security plugin supports SAML, OpenID Connect, Active Directory and LDAP, Kerberos and JSON Web Token authentication backends. Pick the backend that matches your identity provider and confirm how group membership maps to OpenSearch roles. Test a deprovisioned account to confirm that its search access ends when the directory entry is disabled.

Classify what search results expose

Search results may contain workflow identifiers and custom search attribute values, and those values can reveal customer, account or case details. Classify each search attribute before indexing, remove or hash values that do not need to be searchable, and decide who may see each field. Codecs encrypt workflow payloads, but confirm separately whether that protection reaches the search store, since attribute values are indexed as plain values.

Planning index schema changes and server upgrades

Plan index schema changes and Temporal Server upgrades together, because a visibility change that looks safe on its own can fail during the next server step. Temporal's upgrade path moves one minor version at a time, and it moves to the latest patch of the current minor first, since backward compatibility is guaranteed only between two successive minor versions. When the release notes call for a schema upgrade, run it before the server upgrade. Write the sequence down with the server version, the visibility store version and the Helm chart version. Confirm the chart as well, because Helm chart versions below 0.73.1 do not work with server images 1.30 and later.

A new custom search attribute adds a field to the visibility index that existing workflows do not populate. Queries on that attribute will miss older executions unless you backfill them, so confirm how your Temporal version handles historical executions before you rely on it. A retyped attribute is the more disruptive change. Elasticsearch and OpenSearch generally do not let you change an existing field's type in place, so you may need a new attribute name or a rebuilt index. A change to the index mapping can affect the same way. Dashboards, saved searches and alerts that filter on the old name or type can return wrong results without raising an error, so inventory every consumer of each search attribute before the change.

Test each change on a non-production namespace before it reaches production. Use workflow executions that resemble production in volume and shape, and run the same list and count queries your dashboards and operators use. Confirm that new attributes appear on executions started after the change, that the queries return the results you expect, and that the schema and server steps run in the planned order. Keep the test namespace on the same server and visibility versions as production so the result carries over. Record what you tested and what changed, so the production change can be repeated exactly if it has to be rolled back or run again.

The search store needs its own upgrade track. OpenSearch sends maintenance releases that carry bug fixes and security patches but no new features, so you will apply patch updates on a regular basis. OpenSearch also targets a new minor version about every eight weeks, with 3.9.0 released on September 29, 2026. Before you move the search cluster to a new major version, check Temporal's compatibility documentation for that OpenSearch version, because Temporal supports OpenSearch 2 or later from server 1.30.1. OpenSearch versions also reach end of life. Version 1 reached end of life on May 6, 2025, so keep an OpenSearch calendar next to your Temporal calendar and review both at the same time.

Common visibility failures and their fixes

This table pairs common failures on Temporal advanced visibility with Elasticsearch or OpenSearch with their likely causes and the configuration checks that resolve them. Read each row by matching the symptom you see, then checking the cause in the order listed. The main takeaway is that most visibility failures trace back to store versions, index setup, search attribute registration or access settings, and each can be verified against the documented requirement before you change anything.

SymptomLikely causeFix
Workflows missing from list results after the changeVisibility write path not configured, or the visibility index was not created in the search storeConfirm the server configuration points advanced visibility at the search store, then check that the visibility index exists and matches the schema for your server version
Custom attribute queries return nothingThe attribute is not registered in the namespace, or its field type in the index mapping differs from the type registered in TemporalList the search attributes registered for the namespace, then compare each name and type with the index mapping and correct whichever side is wrong
List queries slow down as workflow count growsIndex sizing or shard layout that does not fit the volume of visibility recordsReview shard count, replica settings and index lifecycle against the search store's sizing guidance, and track query latency as volume rises
Temporal server fails to start with the visibility sectionServer version below the supported minimum for the chosen store, or a store version outside the supported rangeCheck the server version against the visibility documentation, confirm the store is Elasticsearch 7 or 8 or OpenSearch 2 or later, and align both before retrying
Authentication errors from the search storeThe Temporal service user lacks index permissions in the store's security role, or TLS settings do not match the store's certificate chainConfirm the role grants the visibility index the access the server needs, then verify the CA certificate, server name and TLS flags in the server visibility configuration
Helm chart mismatch with server images 1.30 and laterHelm chart version below 0.73.1 deployed alongside server images 1.30 or laterPin the chart to version 0.73.1 or later when running 1.30 or later images, and read the chart release notes before each upgrade

Running dual visibility during a change of store

Run two visibility stores during a move only when operators and automation must keep searching workflow history while the new store fills in. The usual cases are moving from another supported visibility store to Elasticsearch or OpenSearch, or moving between Elasticsearch and OpenSearch. The overlap protects search continuity and gives you a path back if the new store misbehaves. It also costs more: both stores must be provisioned, secured, backed up and monitored, and writes must reach both. Before you start, ask whether a shorter planned cutover with a documented search gap would be acceptable to operations and compliance teams. If it would, the overlap may not be worth its cost.

During the overlap, verify the same behavior in both stores. First, list results: sample workflow executions from each namespace and check that workflow ID, run ID, workflow type, status, and start and close times match between stores. Second, custom search attribute queries: confirm that each attribute your workers write is defined in both stores, has the same data type, and returns the same results for the same query strings. Third, retention behavior: confirm how long closed workflows stay searchable in each store and whether the new store's retention settings match the old store's policy. A workflow that is still searchable in one store but already gone from the other is a gap that must be recorded and explained. Use test workflows with known attributes (illustrative) to make these checks repeatable.

Write down, for every stage, which namespaces and workflow types are readable from which store. A simple matrix works: one row per namespace and workflow type, and columns for the stage, the read store, the write stores and the named owner. Stages usually include initial dual writes with reads from the old store, dual writes with reads moved to the new store after validation, and final single-store operation. Confirm the exact dual visibility configuration and its supported combinations in the current Temporal visibility documentation before you plan the stages, because supported store versions depend on your Temporal Server version. Also check the upgrade rules: move the server one minor version at a time and run any schema upgrades the release notes call for before the server upgrade.

Cut over only when the evidence in the matrix supports it: list and attribute query results agree across an agreed test window, retention behavior matches the policy your compliance owners approved, and the new store has been stable under real query load. Keep the old store readable and writable long enough to roll back, and take backups or snapshots of it before retiring it. Retire it only after the agreed read-only period ends, the data you must keep is migrated or exported, and access to the old store is removed from service accounts, dashboards and automation. Record the final retirement date, the owner who approved it, and the evidence used, so auditors can trace how search history was preserved.

Questions buyers ask before hiring help with Temporal visibility

What drives the cost and effort of Temporal visibility on OpenSearch?

The main drivers are search cluster sizing, the number of custom search attributes, the number of namespaces, the security integration, and the upgrade work, including any period when two visibility stores run side by side. Sizing depends on how many workflow executions you index and how long they stay searchable, so your expected volume and retention set the starting point. Each custom search attribute adds a field to the index schema that must be created and kept consistent across environments. Namespace count changes how much data is indexed and queried. Security integration covers TLS, cluster authentication and access roles for people and services. Ask who runs the cluster after handover. Patching, snapshots, capacity reviews and monitoring recur for as long as the cluster serves workflows, so that cost continues after the project ends.

How long does Temporal visibility on OpenSearch take to set up?

The duration depends on the scope agreed in writing, so no fixed figure applies. A scope with one namespace, a small set of search attributes and a single identity integration takes less time than one covering several namespaces, many custom attributes, a store migration and a planned Temporal Server upgrade. Ask for a schedule that lists each deliverable: cluster build, schema changes, Temporal configuration, test runs, cutover and handover. Change windows and approval cycles for production access also set the pace, as does how quickly your team reviews test results. Confirm compatibility first. Temporal documents OpenSearch 2 or later from Temporal Server 1.30.1, so your server and search versions must line up before the schedule is fixed.

What does our team need to provide before implementation starts?

The work needs access and decisions from your side before any build begins:

  • Access to the Temporal environment, including the server configuration and the namespaces in scope
  • Access to the search cluster, or a agreed route to create and manage it
  • Identity provider details for the Web UI and cluster access, such as the protocol and claim mappings
  • Change windows for schema updates, server restarts and cutover
  • A named owner for search data who approves attribute changes, retention settings and access requests

Without the named owner, custom attribute decisions tend to stall, and those decisions drive the index schema. Confirm each item in the written scope so that gaps show up during planning rather than during cutover.

Can our own engineers set up Temporal visibility on OpenSearch themselves?

Yes, if your team already runs Temporal and has search cluster operators who can read the Temporal visibility and upgrade documentation, build the index schema changes and test the results. The work is documented, and an experienced internal team can complete it. A partner adds scoping before the build, a structured test plan covering search queries and custom attributes, and a supported handover with runbooks for the people who will operate the cluster. Decide early whether your team has the time and skills for the testing and the handover, since those are the steps most often underestimated when the work is done in-house.

Is OpenSearch free to use, and how does Temporal Cloud pricing compare?

OpenSearch is released under the Apache License, Version 2.0, and the OpenSearch FAQ does not describe any paid edition, so the software itself carries no license fee. Your costs are the infrastructure, storage, staff time and support arrangements you choose. Temporal Server is licensed under the MIT license according to its GitHub repository. Temporal Cloud is a separate managed service, and Temporal's pricing page lists pay-as-you-go rates starting at 50 US dollars per million actions. Those published figures apply only to Temporal Cloud, not to a self-hosted deployment. Confirm current rates on the vendor's pricing page before comparing options.

Which OpenSearch and Elasticsearch versions work with Temporal visibility?

Temporal's visibility documentation lists support for Elasticsearch 7 and 8 and for OpenSearch 2 or later, with OpenSearch support starting from Temporal Server 1.30.1. Older visibility options also exist, including MySQL 8.0.17 and later, PostgreSQL 12 and later, and SQLite from Temporal Server 1.20, while Cassandra visibility was removed in 1.24. Temporal recommends Elasticsearch or OpenSearch for anything beyond a few workflow executions. Confirm the exact pairing of your Temporal Server minor version and search version in the visibility documentation before you choose, because the supported combinations change between releases.

What usually goes wrong during a visibility store change?

The most common problems come from ordering and mismatched expectations. Temporal's upgrade guidance says to move one minor version at a time, to the latest patch of the current minor first, and to run schema upgrades before server upgrades when the release notes call for it. Teams that skip that order can end up with a server that expects fields the index does not have. Custom search attributes are another frequent gap: an attribute that is registered in one environment but missing in another causes queries to return incomplete results. During a change of store, check that workflows are written to both visibility stores and that queries return matching results from each before cutover. Keep the old store available until those checks pass.

How DeployOpen works on this

DeployOpen plans and builds Temporal advanced visibility on Elasticsearch or OpenSearch inside infrastructure you control, starting from the versions your Temporal Server release supports. Engagements are fixed-scope, with the store choice, index schema, search attributes and cutover plan agreed in writing before work starts. Ongoing support, upgrades and testing are available as retainers.

How we scope

  • The written scope names the store, its version and the Temporal Server release it must match.
  • Custom search attributes are listed with their types, owners and the workflows that query them.
  • Scope also states whether a change of store needs dual visibility and how long both stores run.

How we build

  • Index schema updates are applied in the order the Temporal release notes specify, tested on a non-production cluster first.
  • Search attributes are registered and checked with sample workflows before any application team relies on them.
  • Dual visibility, where configured, writes to the old and new stores so search results can be compared before cutover.

How we hand over

  • Handover includes a written runbook for the visibility store, covering version pinning, schema changes and rollback steps.
  • Network access to the store is restricted to trusted internal networks, matching Temporal's guidance for its services.
  • Your team receives documented search attribute definitions and a record of the cutover checks performed.

How we support

  • Retainers can cover upgrades to the store and to Temporal Server, sequenced one minor version at a time.
  • OpenSearch versions receive bug fixes and security patches during maintenance, so the target version should be confirmed.
  • Confirm which Elasticsearch or OpenSearch versions the quote covers and how end-of-life dates will be tracked.

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.