FortiSOAR cost vs self-hosted Shuffle

FortiSOAR is a licensed platform with infrastructure and vendor-tied costs. Self-hosted Shuffle is free to license but shifts cost into your servers, implementation and the people who maintain workflows. Model both with your own numbers.

On this page

Where FortiSOAR costs more than self-hosted Shuffle, and where it does not

Shuffle's software costs nothing under its open-source edition, which includes all features, so the comparison with FortiSOAR comes down mostly to infrastructure, migration and staff time. Your answer depends on what is driving the decision: a renewal date, a change in the number of users or nodes, or a residency requirement that makes a hosted service harder to accept. Start by recording your current user count, node count and whether you run high availability, because those figures determine every line of the comparison. This section gives no FortiSOAR price. Use your written quote, with scope and node counts stated, as the FortiSOAR figure.

On the FortiSOAR side, the license is sized by users and nodes, and high availability and scale-out add nodes. FortiSOAR's recommended sizing of 12 vCPU and 48 GB per server means each node draws on capacity you pay for in your cloud account or data center, before licensing is counted. On the Shuffle side, the software is free, but the install guide sets only a 4 GB RAM minimum, which covers small installs. The architecture documentation recommends an OpenSearch cluster, optional Memcached, NFS for shared files when running several backends, and more than one Orborus node for high availability. Each of those components is compute, storage and monitoring you run yourself, and the cost grows with your workload.

Shuffle is therefore cheaper on licensing and often more expensive on people. Budget for the engineers who install, patch, back up and tune OpenSearch, and for the time to rebuild workflows and apps. Shuffle states that its paid tiers differ in feature limits, scaling and support, and that these limits have been enforced since v2.1.1, so confirm which limits and support terms your scale requires before you compare totals. Ask FortiSOAR for a quote that states node count, HA layout, user count and support level, and ask Shuffle for the same sizing so both totals cover identical capacity. If your team cannot staff that operation, FortiSOAR's subscription may be the lower total cost, even though its software is not free.

Which cost components change between FortiSOAR and self-hosted Shuffle

This table lists the cost components that differ between a FortiSOAR deployment and a self-hosted Shuffle deployment, with the commercial side, the self-hosted side and whether each cost is one-time or recurring. Shuffle's open-source edition carries no licence fee, but its paid tiers add feature limits and scaling, and app runs are the licensing metric for that edition. Read each row as a question to put to a FortiSOAR quote, because most of its figures depend on the scope you agree.

Cost componentFortiSOAR (commercial)Self-hosted ShuffleOne-time or recurring
Licence or subscriptionSubscription or licence sized by users and nodes. Confirm what FortiGuard entitlements and add-ons are included.Open-source edition has no licence fee. Paid tiers add feature limits and scaling, and meter on app runs.Recurring for FortiSOAR. Recurring only if you buy a Shuffle paid tier.
Servers and storageRecommended servers of 12 vCPU and 48 GB each. Confirm storage sizing for records and attachments.Minimum of 4 GB RAM in the install guide. Size up for OpenSearch, workers and log volume.Recurring cloud or hardware cost for both
High availabilityAdditional licensed nodes and servers for HA and scale-out. Confirm the node count in the quote.You run an OpenSearch cluster, shared NFS, extra backends and more than one Orborus node.Recurring infrastructure and operations
ImplementationVendor or partner setup. Ask whether installation, tuning and integration are quoted separately.Install with Docker, Swarm or Kubernetes Helm. Hardening, SSO and backups are your work or a scoped engagement.One-time
MigrationExport playbooks, modules and connector settings, then rebuild them. Effort follows the inventory.Rebuild playbooks as workflows and replace connectors with Shuffle apps. Effort follows the playbook count.One-time
SupportVendor support is usually part of the subscription. Confirm response terms in writing.Paid tiers differ in support. Ongoing operational help can be bought as a DeployOpen retainer.Recurring
UpgradesFollows the vendor release cycle. Confirm the testing and cutover effort your team carries.Use a stable Docker tag or nightly for experimental builds. Your team tests and rolls out each upgrade.Recurring
Staff skillsAdmins need FortiSOAR training. Ask whether training is included or priced separately.Staff need Docker, OpenSearch and Orborus operations skills alongside workflow design.One-time training, recurring hiring and cover
Workflow maintenancePlaybook and connector upkeep by your team or the vendor. Confirm who owns connector changes.Your team maintains workflows and apps. The App Creator builds apps from OpenAPI specifications.Recurring

How each licence model prices the same automation work

FortiSOAR is licensed by the capacity you deploy rather than by the work it performs. Buyers should expect the quote to be sized by the number of users who log in and by the number of nodes, including the additional nodes that a high availability or scale-out design requires. Confirm with Fortinet how each node role is counted, whether a standby node is billed, and how entitlements are tied to FortiGuard. Ask whether the licence renews annually and what happens to automation if a subscription lapses.

  • Named users: Analysts, engineers and administrators who log in usually count, so adding read-only stakeholders or MSSP operators can change the total.
  • Nodes for HA and scale-out: Every additional node for resilience or throughput is a sizing input, so ask whether standby nodes are priced the same as active ones.
  • Server baseline: Fortinet's recommended sizing of 12 vCPU and 48 GB per server is a hardware cost you carry alongside the licence.
  • Renewal terms: Ask for the renewal price cap, the notice period and the true-up rules if usage grows mid-term.
  • Tenants and modules: Ask whether multi-tenant use or additional modules are separate line items.

Request a written quote that states the user count, node count, HA design and renewal terms, so you can compare it line by line with an open-source estimate.

What moves the FortiSOAR versus Shuffle cost gap

The gap between a FortiSOAR subscription and a self-hosted Shuffle deployment is set less by the software and more by a few drivers: how many people and nodes you license, how much automation volume you run, how you build for availability, and what it takes to rebuild your existing content. Each card below is a figure to pull from your own environment before you ask for a quote.

User and node counts

FortiSOAR licensing is sized by the users who log in and the nodes that make up the deployment, including extra nodes for high availability and scale-out. Count named analysts, engineers and any MSSP tenant administrators, then count the servers you would run in each role. Ask the vendor to state in writing how users and nodes are defined in your quote, and whether a reduced standby node is priced differently from an active one.

Scale-out and HA architecture

Shuffle's high availability guidance calls for an OpenSearch cluster, optional Memcached for a shared cache, NFS for shared files when several backends run, and more than one Orborus node so workflows keep running if one fails. Each of these is infrastructure you size, patch and back up, so it shows up as cloud or hardware spend and staff time rather than as a license line. Price the HA design you need, not the single-server demo.

App runs on the paid tier

Shuffle's licensing for paid editions is based on app runs, meaning actions that actually execute in a workflow. Triggers and skipped actions are not counted, and users, apps and workflows are unlimited. Estimate your monthly executions from alert volume and playbook branching, because enforcement of edition limits is active, and confirm with Shuffle how runs are metered on your chosen tier before you size the subscription.

Data retention and storage

Both platforms keep records, case history and execution logs, and the storage they consume grows with retention length. In a self-hosted Shuffle build, OpenSearch holds the workflow and execution data, so retention settings translate directly into disk, index replicas and backup size. Agree the retention period for alerts, cases and workflow logs with your compliance lead first, then size storage and backups to that number.

Playbooks and connectors to rebuild

Every FortiSOAR playbook, module and connector setting that you move becomes work for an engineer. Shuffle apps are built from OpenAPI specifications in its App Creator or written with its Python SDK, so a connector with no existing Shuffle app needs new integration work. Inventory playbooks and connectors first, mark which ones are unused, and estimate rebuild effort per item, since this is usually the largest one-time cost.

Existing team skills

Running Shuffle well depends on skills in Docker, Kubernetes and OpenSearch, and the install guide itself warns that the default Docker Compose setup is not a scalable build without changes. A team that already operates these tools carries a lower ongoing cost than one that hires or trains for them. Map each person's current skills against the deployment you chose, and price training or a support retainer for the gaps.

How to build the FortiSOAR and Shuffle model with your own numbers

This sequence turns a FortiSOAR quote and a Shuffle sizing plan into one cost model, with each figure traced to your own environment or a written quote.

  1. Collect the FortiSOAR quote in writing

    Ask your Fortinet reseller or account team for a written quote that states the license basis, user and node counts, the high availability and scale-out topology it assumes, and the term and renewal terms. Record the vendor's recommended server sizing for each node, including the stated 12 vCPU and 48 GB guidance, and whether support and FortiGuard-linked entitlements are included. Store the quote with its assumptions as the baseline. The step is done when every line item has a stated basis and an owner who can explain it.

  2. Inventory playbooks and connectors from the export

    Run FortiSOAR's configuration export to list playbooks, modules and connector settings, then count how many playbooks are active, how many connectors each one calls and how often each runs. Mark which connectors have a ready Shuffle app and which will need an app built from an OpenAPI specification or written with the Shuffle app SDK. Note what the export does not capture, such as case records, so that data migration is costed separately. The step is done when you have a signed-off inventory with run frequency for every playbook.

  3. Size the Shuffle deployment from its minimums

    Start from Shuffle's documented minimum of 4 GB of RAM for a single host, then decide on the architecture: single server with Docker Compose, Docker Swarm, a hybrid with a local Orborus, or Kubernetes with Helm. For high availability, plan an OpenSearch cluster, a shared cache, shared file storage for multiple backends and more than one Orborus node. Price each server, storage, backup and load balancer item from your own cloud or data center rates. The step is done when you have a bill of materials and a topology diagram that your infrastructure team has reviewed.

  4. Estimate app runs against the paid metric

    Shuffle's paid licensing counts app runs, meaning actions that execute in a workflow, while triggers, skipped actions, users, apps and workflows are not counted. Use your inventory and alert volumes to estimate monthly executed actions for each playbook, then compare that total with the limits of the tier you are considering. If your estimate stays within the open-source edition's enforced limits, record that as the basis. Confirm the current limits and tier terms with Shuffle before deciding, since the pricing article is the source to check. The step is done when a monthly app run estimate is written down with its method.

  5. Cost staff time for building and maintaining workflows

    Estimate the hours your team needs to rebuild playbooks, configure apps, write any custom apps, test, document and monitor them, then add the ongoing hours for app updates, workflow changes and upgrades. Identify who holds this work, whether an internal engineer, a SOC analyst or an external partner under a fixed-scope agreement, and the loaded hourly cost of each. Keep the one-time build effort separate from the recurring maintenance effort. The step is done when each role has an hour estimate and a rate, and the total is reproducible by a colleague.

  6. Separate one-time and recurring costs

    Build two columns for the same period you chose for the FortiSOAR quote, one for one-time costs such as migration, app builds, testing, training and initial hardware, and one for recurring costs such as licenses or subscriptions, infrastructure, backups, staff maintenance and support retainers. Keep the FortiSOAR figures and the Shuffle figures on identical assumptions for users, nodes, retention and availability targets. Flag any cost you cannot yet quantify so it is visible rather than hidden. The step is done when both columns balance to the same period and each line names its source.

  7. Compare totals over the same period and test sensitivity

    Sum the one-time and recurring columns for each option over the same number of years, then vary the largest drivers, such as app run volume, number of playbooks, staff hours and infrastructure size, to see which assumptions change the result. Record which inputs would change the decision and which inputs would need a new quote. Review the model with your finance, security operations and infrastructure owners before using it in a renewal discussion. The step is done when the comparison, its sensitivities and the list of open quote requests are documented and signed off.

What self-hosting Shuffle costs in servers, HA and operations

The first cost decision is topology, because the default Docker Compose setup is not a scalable build without changes, according to Shuffle's install guide. A single server with Docker Compose is the simplest way to start and is fine for evaluation, but any production plan needs a different shape. Shuffle documents distributed Docker Swarm and Kubernetes with Helm charts as alternatives, and a hybrid model in which Shuffle Cloud handles the control plane while a local Orborus node runs executions inside your network without inbound firewall ports. Each option moves cost between server hours, cluster skills and network changes, so ask your team which runtime it already operates and price that, not the lowest-effort path. The published minimum of 4 GB of RAM is a starting point for installation only. It is not a sizing for production volume, which depends on alert rates, the number of concurrent workflow executions and the apps you run. Confirm capacity with a load test in your own environment before you commit to hardware or cloud instances.

High availability is where most of the recurring infrastructure cost sits. Shuffle's configuration documentation recommends an OpenSearch cluster rather than a single node, optional Memcached for a shared cache, NFS for shared files when several backends run, backends and frontends scaled across servers, and more than one Orborus node so workflows keep running if one fails. Each of these is a component you must patch, monitor, back up and staff. Backups of OpenSearch data are the cost most often left unassigned. Decide who owns them: your platform team, a managed service you buy, or DeployOpen under a retainer. Whoever owns them must also protect SHUFFLE_ENCRYPTION_MODIFIER. Shuffle encrypts saved app credentials and API keys in OpenSearch with AES-256 using this secret, and the documentation warns that losing or changing it breaks every saved app authentication. Store it in your secrets manager, include it in the backup runbook as a separate item, and test a restore on a non-production host before go-live.

Operations cost is the part that recurs for as long as the platform runs. Budget for on-call coverage for the automation itself, app upgrades (Shuffle apps run as versioned Docker containers), certificate and SSO maintenance, and workflow ownership. Ask any quote to separate one-time work (architecture, installation, migration, hardening and backup setup) from recurring work (upgrades, monitoring, patch windows and workflow changes), and to state which items are included in a fixed scope and which move to a retainer. The Shuffle licensing model counts app runs rather than users or workflows, so the volume of executions is a cost driver you should measure now. Quotes should also name who holds the admin credentials, who restores the cluster after a node failure and how upgrades are tested. Those answers tell you more about the true cost than the software line item.

Costs teams forget on each side of the comparison

Licence quotes rarely show the full cost of either platform. On the FortiSOAR side, growth and vendor-tied terms add cost over time; on the Shuffle side, the cost moves to staff who build, test and maintain workflows. Use the cards below to build a line-by-line comparison before you ask for quotes.

Renewals and true-ups as seats grow

FortiSOAR licences are sized by users and nodes, so a team that adds analysts, tenants or high-availability nodes can face a true-up before the next renewal. Ask the vendor how mid-term growth is priced, whether scale-out nodes are billed separately, and what happens to the term if you reduce capacity. Model your headcount and node count for the next three renewal cycles, not only the current quote.

Premium services and add-on fees

Vendor professional services, premium support tiers and paid content packs are often quoted separately from the core subscription. Ask which integrations, playbook templates and upgrade assistance are included and which are billed as extras. Record each premium item as a recurring line in your model so it is not treated as a one-time purchase.

Vendor-tied licence dependencies

FortiSOAR licensing is linked to FortiGuard entitlements, so changes to that relationship can affect how the platform runs in your environment. Confirm with the vendor which entitlement checks apply, how they behave in restricted networks, and what your exit terms are. Factor the cost of an eventual exit into the comparison, since migrating away later requires exporting playbooks and rebuilding them elsewhere.

Workflow ownership after go-live

Shuffle has no per-user licence, but someone must own each workflow after launch. Playbooks change when alert sources, ticket fields and approval rules change, and those changes need named owners, review and version control. Budget engineer time for this recurring work, and decide who approves a workflow change before it reaches production.

App creation and testing for unsupported tools

Shuffle's App Creator builds integrations from OpenAPI specifications and ships premade apps for many security tools, but internal or niche systems may need a custom app. Each custom app needs development, testing against the live API, and a versioned container build. Ask your team how many tools in your estate lack a premade app and estimate the effort to build and test each one.

OpenSearch and upgrade administration

Shuffle uses OpenSearch as its document database, and the docs recommend an OpenSearch cluster for high availability. Someone must patch, back up and size that cluster, and test each Shuffle release in staging before upgrading production. The Docker and Kubernetes deployments also need ongoing platform work, and these tasks recur for the life of the system.

Credential key management and migration effort

Shuffle encrypts saved app credentials with the SHUFFLE_ENCRYPTION_MODIFIER secret, and losing or changing that value breaks every saved authentication. Store it in your secrets manager, include it in backups and rotation plans, and treat it as a recurring control. Migration itself is a one-time cost: inventory playbooks, rebuild them as workflows, and run both platforms side by side until alert sources move over.

Questions buyers ask before comparing FortiSOAR and Shuffle costs

Is Shuffle free to run in production?

The software is free to use, but running it is not free. Shuffle's open-source edition includes all features, with the backend under AGPL-3.0 and workflows, documentation, apps and app specifications under MIT. Your costs are the servers or cloud accounts that host it, OpenSearch storage and backups, and the staff hours to install, secure, upgrade and maintain it. Shuffle's paid tiers differ in feature limits, scaling and support, and since v2.1.1 those limits are enforced between editions. Its licensing is priced on app runs, meaning actions that actually execute, and users, apps and workflows are unlimited. Confirm with Shuffle which limits apply to the edition you plan to use. The Shuffle pricing article explains how app runs are counted.

What drives the cost of self-hosted Shuffle up or down?

Four components move the total most:

  • Infrastructure: the install needs at least 4 GB of RAM, but the default Docker Compose setup is not built to scale without changes. A highly available layout adds an OpenSearch cluster, shared cache and file storage, several backends and more than one Orborus node.
  • Volume: the number of app runs and the size of your alert stream increase compute, storage and log retention.
  • Integrations: each tool you connect needs an app, and apps built from OpenAPI specifications or written in Python must be versioned and tested.
  • Operations: key management, patching, backups and workflow reviews recur every month.

Design choices in the first month, especially high availability and backup scope, set most of the long-term cost.

How long does a FortiSOAR to Shuffle migration take?

The duration depends on the size and complexity of what you move, not on a fixed formula. The main variables are the number of playbooks and modules to rebuild as Shuffle workflows, the number of connectors that need a Shuffle app, the volume of case data to move, the number of alert sources to switch, and how long both platforms must run side by side. Each of these changes the plan. Neither Shuffle's documentation nor the sources for this page give a standard migration duration, so ask for one in writing after an inventory. Use the inventory from your FortiSOAR export to size the work before you request a timeline.

What skills does the internal team need for a Shuffle migration?

Plan for four skill areas. Container operations cover Docker Compose, Docker Swarm or Kubernetes with Helm, depending on the architecture you choose. Search operations cover running and tuning an OpenSearch cluster, since Shuffle uses it as its document database. Integration skills cover reading OpenAPI specifications and writing Python for custom apps. Security automation skills cover translating playbook logic into workflows and validating outcomes. Operations also need a plan for the SHUFFLE_ENCRYPTION_MODIFIER secret, because losing or changing it breaks every saved app authentication. Name a workflow owner who will maintain playbooks after cutover, since that work recurs.

Can our team migrate from FortiSOAR to Shuffle without outside help?

Yes, if the team already has the skills listed above and time to learn the platform. Shuffle publishes install guidance for Docker and Kubernetes, and its architecture and configuration documentation describe the high availability components. The hard parts are rarely the first install. They are the scaling changes to the default Compose setup, the OpenSearch cluster and shared storage design, single sign-on setup (SAML was added in 0.9.16 and OpenID Connect in 1.0.0), backup and restore testing, and rebuilding playbooks with the same logic and error handling. Keep a side-by-side period and test each workflow against real alert samples before you switch sources. Document every decision so the next maintainer can follow it.

When does outside help with a Shuffle migration pay off?

Outside help usually pays off when the internal team lacks OpenSearch or container operations experience, when the playbook inventory is large, or when auditors will review the platform's controls. DeployOpen plans, implements, customizes, integrates, hardens, backs up, upgrades, documents and supports self-hosted open-source platforms inside your own cloud accounts, data centers or air-gapped networks. It also prepares systems, controls and evidence for compliance assessments, but independent auditors and certification bodies issue any audit reports or certifications. Most engagements are fixed-scope, and ongoing support, upgrades and testing are available as retainers.

What should a fixed-scope quote for a Shuffle migration include?

A written scope should name each deliverable and the evidence that proves it is done. Ask for:

  • The playbook, module and connector inventory, and which items are in or out of scope.
  • The target architecture, including the high availability design, OpenSearch sizing and backup approach.
  • The app plan for each connector, including custom apps and their testing.
  • Case data migration rules and what stays behind in records.
  • The parallel run period, cutover steps and rollback plan.
  • Secret and encryption key handling, SSO setup and access controls.
  • Documentation, knowledge transfer and acceptance criteria.
  • Assumptions, exclusions, change requests and post-cutover support, including any retainer.

DeployOpen does not publish a price list, so the quote follows from this written scope.

What does FortiSOAR cost compared with Shuffle's open-source edition?

No FortiSOAR price is in the sources for this page, so compare the two on components rather than on a list price. FortiSOAR is sold on subscriptions or licenses sized by users and nodes, and its recommended server sizing is 12 vCPU and 48 GB of RAM per server, with additional nodes for high availability and scale-out. Ask Fortinet or your reseller for a written quote that states the license basis, node count, renewal terms and any entitlement or FortiGuard dependency. Shuffle's software cost is zero under its open-source edition, so your comparison will focus on infrastructure, migration, staff time and any paid Shuffle tier you need.

How migration work and parallel running add to the first year

Most of the migration cost is one-time, and it lands mainly in the first year. The work starts with an inventory: the FortiSOAR configuration export gives you the playbooks, modules and connector settings to count, and each item needs an owner who can say whether it is still in use. Rebuilding playbooks as Shuffle workflows is the largest block of effort, because logic written against FortiSOAR modules does not carry over one to one. Plan for analyst time to test each rebuilt workflow against sample alerts, not only to copy it across. Confirm with your Shuffle partner or internal team how many of your playbooks depend on connectors you already use, since that drives how much rebuilding is left.

Connectors are the second block. Shuffle builds integrations from OpenAPI specifications in its App Creator or ships premade apps for common security tools, so a FortiSOAR connector that wraps a documented REST API is usually replaced by a Shuffle app rather than by new code. Vendor APIs that are poorly documented or that rely on FortiSOAR-specific wrappers take longer, and each replacement app needs its credentials re-entered and tested. Ask for a per-connector list that marks which ones map to a premade app, which need a custom app, and which need a vendor API review before work starts.

Running both platforms side by side is the cost most often underestimated. Until each alert source is pointed at Shuffle and its output is checked, you pay for two sets of infrastructure, two sets of access controls and analysts who work in both consoles. Set a switchover order by alert source, define the acceptance test for each switch, and keep FortiSOAR in read-only mode for the records you must retain. Confirm the length of the overlap period with your own change board, because it is set by your alert volumes and risk tolerance, not by the platform. The sibling migration page covers the step-by-step process, so use this section to budget for it.

Keeping the comparison honest over the contract term

Put both options on the same term, using the same year-by-year model, so a multi-year FortiSOAR subscription is never set against a one-time Shuffle setup. Build one spreadsheet with a row for each cost component: the FortiSOAR subscription and each renewal, the servers it runs on, the Shuffle infrastructure, migration work, and the staff time spent building and maintaining workflows. Price staff time at your own loaded hourly rate, which your finance team sets, and log hours monthly so the figure reflects actual effort. Also count what FortiSOAR's price already includes. Its enterprise and multi-tenant features are part of the subscription, so if an MSSP model depends on tenant separation, confirm which tenancy features Shuffle provides in the edition you would run before you treat that gap as free.

Growth usually changes the comparison more than the starting price. Ask Fortinet for FortiSOAR pricing at your current user and node counts, then at the counts you expect in years two and three, including the nodes needed for high availability and scale-out. Shuffle prices on app runs, meaning actions that actually execute in a workflow, and its pricing article says users, apps and workflows are unlimited, so model app runs from your alert volume and the number of enrichment steps each playbook calls. Confirm which limits apply to the edition you choose, because Shuffle enforces the differences between its open-source and enterprise editions. Infrastructure grows as well. The Shuffle configuration docs recommend an OpenSearch cluster, shared Memcached, NFS and more than one Orborus node for high availability, and those servers recur every year.

Finally, record what the subscription includes that a self-hosted Shuffle deployment does not provide by default. Typically this means vendor support and escalation, FortiGuard-linked content and entitlement updates, and vendor-maintained connectors. For each item, name the replacement and its owner: a support agreement with Shuffle or a partner, an internal role that maintains apps built with the App Creator, or your own patching schedule. Mark which items recur and which are one-time, and set a review date for the comparison at each renewal so updated FortiSOAR pricing can be checked against the same assumptions. Request every quote in writing with the scope stated, so the FortiSOAR figures and your Shuffle figures describe the same workload.

How DeployOpen scopes a fixed-price Shuffle implementation

DeployOpen, a Chainscore Labs company, plans and implements self-hosted open-source platforms inside your own cloud accounts, data centers or air-gapped networks. For a FortiSOAR to Shuffle cost comparison, we turn your licensing, sizing and workflow inventory into a written scope before any work starts.

How we scope

  • Inventory current FortiSOAR licensing, node count, user count and server sizing before modeling Shuffle costs.
  • Agree a written scope covering Shuffle deployment architecture, OpenSearch sizing and high availability design.
  • Define which workflows, alert sources and app integrations are in scope, and which are excluded from the first phase.

How we build

  • Deploy Shuffle with Docker, Swarm or Kubernetes in your own infrastructure, following the architecture you approve.
  • Configure OpenSearch, multiple Orborus nodes and encrypted credential storage with the SHUFFLE_ENCRYPTION_MODIFIER secret managed under your control.
  • Build or adapt apps with the App Creator or the Python SDK, and test workflows against representative alert data.

How we hand over

  • Document the architecture, the cost model, backup steps and the procedure for rotating and protecting the encryption secret.
  • Provide a workflow register listing each migrated playbook, its owner, its app dependencies and its test evidence.
  • Walk your security and platform teams through operating Shuffle, including app run metering and upgrade steps.

How we support

  • Offer ongoing support, upgrades and continuous testing as a retainer after handover, scoped in writing.
  • Prepare configuration, access control and logging evidence for your compliance assessments, while independent auditors issue any reports.
  • Confirm with your team which Shuffle edition and feature limits apply to your planned app run volume before go-live.

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.