Shuffle Detection Manager for Sigma rules

How to plan central management of Sigma and other detection rules with the Shuffle Detection Manager beta, the Orborus runtime it depends on, and the log pipeline that feeds it.

On this page

What the Shuffle Detection Manager does for Sigma rules and when to use it

The Shuffle Detection Manager is a beta feature for managing Sigma and other detection rules from one central place, and it is one part of a larger setup that includes Orborus runtimes and Tenzir pipelines. Consider it when a security team keeps Sigma rules spread across several Git repositories, shared drives and SIEM consoles, with no single owner and no clear record of which version is live. Those teams want one place to review, organize and reference rules, and they want Shuffle playbooks to act on the same detections that the rule set describes.

Evaluate the Manager when the main problem is rule sprawl rather than missing detections. The first decision is where the source of truth lives. If rules stay in Git and the Manager only reads from them, the team keeps its existing review process. If the Manager becomes the place where rules are edited, the team must decide how changes are reviewed, approved and exported back to the SIEM. Also check where Orborus will run. Shuffle's architecture docs describe a hybrid model in which a local Orborus needs no inbound firewall ports, which matters when detection content and network topology are sensitive.

The Manager complements the SIEM and does not replace it. Your SIEM keeps running searches, storing events and generating alerts, while Shuffle coordinates what happens after an alert. Tenzir pipelines sit between log sources and the tools that consume them, so they shape the data that rules depend on. Before scoping, ask the vendor or the current docs which SIEM and log formats the Manager can read or deploy to. Also confirm how rule syncs count toward licensing. Shuffle prices its paid tiers on app runs, meaning executed actions, so any scheduled sync or rule validation workflow should be estimated against that metric.

Treat the beta status as a hard constraint. Before any production decision, confirm against current Shuffle documentation and release notes which rule formats are supported, how rules are versioned and exported, what happens during upgrades, and whether any feature is limited in your edition. Run a pilot in a nonproduction environment using a copy of your rules and a known set of alerts. Check that rule changes are traceable, that rollback works and that the Orborus nodes stay healthy under load. A written scope with DeployOpen should name which of these checks are included and which remain your team's responsibility.

Shuffle deployment options and where the Detection Manager fits

This table lists the four Shuffle deployment architectures in the first column and explains in the second which one suits a team that wants detection rules and log pipelines on infrastructure it controls. Read each row against your hosting, availability and staffing constraints, then confirm the Detection Manager and Tenzir requirements with Shuffle before choosing.

ArchitectureFit for detection rules and log pipelines on your infrastructure
Single server with Docker ComposeSuits a pilot or a small team that wants one host to run the backend, frontend and OpenSearch. It has no built-in redundancy, so plan a second path before workflows become critical.
Distributed Docker SwarmSuits teams that want several servers for the backend, frontend and Orborus nodes. Shuffle's high availability guidance also expects an OpenSearch cluster and shared storage, so plan those components in advance.
Hybrid: Shuffle Cloud with a local OrborusKeeps workflow execution on your network, and Orborus needs no inbound firewall ports. Confirm exactly which alert, rule and log data reaches Shuffle Cloud before sending detection content through this model.
Kubernetes with Helm chartsSuits teams that already operate clusters and want Shuffle managed like other workloads. Confirm the chart version, storage classes and Orborus placement with Shuffle before the design is fixed.
Detection Manager and Tenzir supportConfirm with Shuffle which architectures the Detection Manager beta supports, and which Tenzir pipeline deployment options apply to each one, before committing to a design.

Orborus requirements to confirm before the Detection Manager runs

The Detection Manager runs as a workflow, so its execution depends on Orborus and the container runtime beneath it. Each card below is a decision or check that determines whether Sigma rule workflows start reliably, where they run and what happens when a node fails.

How Orborus starts workflow runs

Orborus polls the Shuffle backend for queued jobs and starts a worker for each workflow execution. The worker then starts the app containers that the workflow's actions need. Before the Detection Manager runs, confirm that the Orborus host can reach the backend it polls, and that the worker and app containers have the access they need to complete a run.

Local or cloud Orborus placement

Decide where Orborus runs relative to the log sources and tools that Sigma rule workflows query. In a hybrid setup, a local Orborus alongside Shuffle Cloud needs no inbound firewall ports, because it initiates outbound connections to the backend. Confirm that outbound paths to the backend and to any required internal systems are allowed by your network policy.

Docker host and runtime readiness

Orborus starts workers and app containers, so the host must run a container runtime that Shuffle supports for your chosen deployment architecture. Check the Docker version and daemon configuration against the Shuffle configuration documentation for the release you plan to run, and confirm that the host's access to the container registry meets your policy. Ask Shuffle which host sizing applies, since this page does not state CPU or memory figures.

Container image tag and version pinning

Shuffle recommends the latest Docker tag for stable releases and the nightly tag for experimental changes. Pin the Orborus image to the same release line as your backend and frontend, and record the tag in your change records. A nightly tag on a production Orborus can change behavior between restarts, so decide per environment which tag is allowed.

Redundant Orborus nodes for availability

Shuffle's high availability guidance recommends more than one Orborus node so workflows keep running if one fails. Plan at least two Orborus nodes for the Detection Manager's scheduled runs, place them on separate hosts where your infrastructure allows, and test a node failure before relying on the Detection Manager for production detection coverage.

Encryption secret for stored app credentials

Shuffle encrypts saved app credentials and API keys in OpenSearch using the SHUFFLE_ENCRYPTION_MODIFIER secret. The Detection Manager needs credentials for the log and rule sources it reads, so store this secret in your secrets manager before the first run. Losing or changing it breaks every saved app authentication, so document the value's custody and rotation process.

How log forwarding into Tenzir pipelines feeds detection rules

Log forwarding into Tenzir pipelines decides what a Sigma rule can see, so map the full data path before writing any rule. Events leave each log source, pass through a Tenzir pipeline that receives, parses and reshapes them, and reach the point where the Detection Manager evaluates rules and Shuffle runs the matching workflow. On one page, record the sending agent or collector, the transport between it and the pipeline, each pipeline output, and the Shuffle workflow that consumes it. Confirm in the beta how events enter Shuffle, whether by webhook or by a workflow that pulls from a store, because the answer determines which components must be reachable and where failures appear. Shuffle's backend listens on port 5001 and Orborus starts a worker for each workflow execution, so an execution can fail on the runtime side even when the pipeline delivered the event.

Four questions should be answered before the first pipeline is written. First, which log sources are in scope, since each source adds field names, volume and an owner who can change them. Second, what normalization happens before matching: Sigma rules refer to fields by name, so the pipeline must map source fields to the names the rules expect. Decide whether that mapping lives in the pipeline, in the rule or in a shared field map. Third, where events are stored after forwarding: in Tenzir outputs, in the OpenSearch document store that Shuffle uses, in the SIEM, or in several places, each with its own retention and access controls. Fourth, who owns each pipeline, meaning who approves changes, reviews failed deliveries and signs off on schema updates. Write the answers down, because each one changes the test plan.

Three failure modes matter most. Dropped events happen when a pipeline, network path or workflow trigger rejects or times out on a payload and nothing records the loss. Schema drift happens when a source renames or adds a field, so a rule that matched last week stops matching while every component still reports healthy. Duplicate forwarding happens when a retry or a second route sends one event twice, producing repeat alerts. Shuffle's pricing article meters app runs, which are actions that actually execute, so duplicates that start actions also raise cost on paid tiers. In a test environment, confirm four things: how Tenzir behaves when the receiving endpoint is unavailable (retry, buffer or discard), whether each event carries an identifier that Shuffle can use to deduplicate, how a missing field appears to a rule, and how Shuffle handles a malformed payload. Record what you observe before relying on any of it.

Forwarding into Tenzir does not replace the SIEM. Keep the SIEM as the system of record for alerts that analysts already work, and treat Tenzir copies as the input to Sigma matching and Shuffle workflows unless your team decides otherwise. That split creates two retention policies, two access models and two places where a missing event must be explained. Decide which store answers an auditor's question about a given day of logs, and test that answer end to end. On the Shuffle side, confirm that the OpenSearch cluster holding workflow data is sized, backed up and monitored on the same schedule as your other security data, since the configuration docs recommend an OpenSearch cluster for high availability. Finally, agree on a change process so that a source change, a field map update and a rule update are reviewed together.

How the Detection Manager works alongside your SIEM

Most organizations that run a SIEM rely on it for functions that took years to mature, and a detection rule manager does not set out to rebuild them. The SIEM usually holds the long-term log archive that retention and audit requirements depend on, runs correlation across large event volumes, gives analysts a search interface over historical data, and feeds the dashboards that leadership and compliance reviews already use. These roles often sit with the security operations team and the SIEM owner, and they carry their own retention settings, access rules and licensing.

Plan to keep these functions in the SIEM:

  • Long-term storage: retention periods, archive tiers and legal holds stay with the SIEM.
  • Correlation at scale: the SIEM's correlation engine continues to process the broad event stream.
  • Analyst search: historical hunting and ad hoc investigation stay in the SIEM's search workspace.
  • Existing dashboards: reports that auditors and managers already read keep their current data source.

Before you change anything, confirm with your SIEM vendor which of these your license covers, how long your regulator or policy requires logs to be kept, and which team answers for each function.

Setting up the Shuffle Detection Manager in a test environment first

This sequence builds a contained Shuffle test stack, connects one log source through Tenzir, and loads a small set of Sigma rules. It ends with proof that matches arrive as expected and that saved credentials survive a restore.

  1. Confirm the current Shuffle release and beta status

    Open the Shuffle GitHub releases page and record the newest stable release. The docs recommend the latest Docker tag for stable use and the nightly tag only for experimental changes. Shuffle v2.3.0 was published on September 28, 2026, so confirm whether a later stable release exists before you pin a version. Check the release notes and current docs to confirm whether the Detection Manager is still labeled beta and which menus or feature flags apply. Done when your test plan names one image tag, its publication date and the beta status, all in writing.

  2. Deploy Shuffle using the chosen architecture

    Build the test stack with the same architecture as the planned production design: a single server with Docker Compose, Docker Swarm, a hybrid with Shuffle Cloud and a local Orborus, or Kubernetes with Helm charts. The backend API listens on port 5001 and uses OpenSearch as its document database, so confirm both are healthy after startup. Before anyone saves an app credential, set the SHUFFLE_ENCRYPTION_MODIFIER secret in the test secret store and confirm the exact configuration key name in the configuration docs. Done when the frontend loads, the backend responds on port 5001 and OpenSearch reports healthy.

  3. Install and register Orborus nodes

    Install at least two Orborus nodes in the test environment, since the HA guidance recommends more than one so workflows keep running if a node fails. Orborus polls the backend for jobs and starts a worker for each workflow execution, and that worker starts app containers, so each node needs container runtime access and a route to the backend. In a hybrid design, Orborus needs no inbound firewall ports. Confirm the registration steps and the admin menu path in the current docs. Done when both nodes appear as registered and a test workflow runs successfully on each node.

  4. Set up the Tenzir pipeline for one source

    Choose one log source with a well-understood event format, for example Windows security events or Linux authentication logs (illustrative choices). Configure a Tenzir pipeline to read that source, normalize the fields and forward events to a Shuffle webhook trigger in the test workflow. Confirm the pipeline syntax, forwarding options and webhook URL format against the current Tenzir and Shuffle documentation before you copy any example. Done when a sample event reaches the trigger and the field names and timestamps match what your Sigma rules expect.

  5. Import a small set of Sigma rules

    Select a handful of Sigma rules whose logsource matches the single source from the previous step, and record each rule ID before import. Import them through the Detection Manager, and confirm the menu path and import method in the current docs. Keep the set small so every match can be traced by hand. Check that the number of rules shown in the manager equals the number of files imported, and that any parse errors are either fixed or logged with the rule ID. Done when every rule shows as loaded or has a logged reason it did not load.

  6. Verify that test events produce expected matches

    Send a set of known test events through the Tenzir pipeline: at least one event that should trigger each imported rule, plus one control event that should trigger none. Watch the Shuffle execution history for the expected matches and check that the event fields appear in the workflow data. Record which rules fired, which did not and why, then correct field mappings in the pipeline or logsource mismatches in the rules before moving on. Done when every positive event produces its expected match and the control event produces no alert.

  7. Test restore of the encryption secret

    Back up the OpenSearch data and the SHUFFLE_ENCRYPTION_MODIFIER value to separate storage, then restore both into a second test stack or a rebuilt one. The configuration docs warn that losing or changing this secret breaks all saved app authentications, so this test shows whether your backup is usable. Confirm the backup and restore commands in the docs first. After restore, verify that a saved app credential still authenticates and that a test action runs on a registered Orborus node. Done when the restored stack uses an existing credential and the test action completes. If either check fails, stop and do not promote this design.

Operating detection rules after go-live

Once Sigma rules are live in the Shuffle Detection Manager, the recurring work falls into five tasks: tracking Shuffle releases, testing rule changes, reviewing false positives, backing up the encryption secret and monitoring runtime health. Each task needs a named owner before go-live, because none of them is finished by a one-time configuration. Write the owners into a runbook that also records who approves a rule change, who may schedule a Shuffle upgrade and who responds when a workflow stops running outside business hours. The split described below is a starting point your team can adjust.

Release tracking comes first because it decides when the platform changes at all. The Shuffle docs recommend the latest Docker tag for stable releases and reserve the nightly tag for experimental changes, so production should run pinned stable tags, and nightly builds belong only in a non-production instance. The most recent release cited for this topic is v2.3.0, published on GitHub on September 28, 2026, but confirm the current tag on the Shuffle releases page when you read this. Assign tracking to the platform owner, who reviews release notes on a schedule your change process sets. Security engineering should approve each upgrade, and the platform owner should note that Shuffle stopped supporting versions older than v2.1.1 after January 31, 2026.

Every rule change should be tested in a non-production Shuffle instance before it reaches the detection workflow. The test should replay sample events that the rule is expected to match and events it should ignore, and detection engineers should attach that replay evidence to the change record. False positive review is a separate, continuing task. Assign it to the SOC analysts who close alerts, with a defined path for sending a noisy rule back to engineering along with example events, the field values that triggered it and the benign source behind them. Ask your implementer whether the Detection Manager beta exposes per-rule alert counts and records suppression changes, because that determines how much of this review can happen inside the interface.

The SHUFFLE_ENCRYPTION_MODIFIER secret needs the most careful ownership. Shuffle uses it to encrypt saved app credentials and API keys in OpenSearch with AES-256, and the docs warn that losing or changing it breaks all saved app authentications. Store a copy in your approved secrets store, restrict access to the platform owner and one named backup holder, and test restoration on the non-production instance to confirm the copy works. Monitoring covers Orborus, which polls the backend for jobs and starts a worker for each workflow execution. Watch whether Orborus nodes stay connected, whether jobs queue without starting, and whether a second Orborus node is available if your design follows the high-availability guidance in the docs. Confirm with your Tenzir pipeline vendor or implementer which pipeline health signals they expose.

Decide how coverage works before the first incident. An internal rota suits teams that already run on-call for their SIEM and can absorb a few hours of pipeline checks each week, provided the runbook names the people and the escalation path. A retainer suits teams that want upgrade testing, Orborus and backend monitoring, secret restoration tests and rule change support handled by a partner under a written scope. Either way, ask any provider to state in writing which tasks they perform, which they only advise on, how alerts about stalled workflows reach them and how an in-flight rule change is handled during an upgrade. DeployOpen offers ongoing support and upgrades as retainers, and the terms follow from the written scope agreed before work starts.

Security considerations for detection rules and log data

Detection rules and the log data behind them both show how your organization sees threats, so the Shuffle Detection Manager needs the same access and secrets discipline as the rest of your security stack. The cards cover who can change rules and workflows, how credentials are stored, how sign-in is enforced, and what to confirm before the platform handles production data.

Access control for rules and workflows

Rule libraries and Shuffle workflows can both change what gets detected and which automated actions run, so each needs its own review of who can edit, publish and execute it. Check which Shuffle roles can edit Sigma rules, who can run or modify the workflows that push rules to Tenzir, and whether changes need a second reviewer. Confirm the role model in the beta version you deploy before you rely on it for production.

Credentials for Tenzir and log sources

The Detection Manager needs credentials to reach Tenzir pipelines and the log sources that feed them. Keep these in Shuffle's saved app authentication, out of workflow bodies and shared notes. Scope each account to the pipeline or source it serves, rotate credentials on a schedule your team can run, and record a named owner for every credential. Confirm with the Tenzir documentation which authentication methods its pipelines accept.

Encryption secret for saved app credentials

Shuffle encrypts saved app credentials and API keys in OpenSearch with AES-256, using the SHUFFLE_ENCRYPTION_MODIFIER secret. Store that secret in your secrets manager, back it up alongside your deployment configuration, and treat it as a key you cannot easily recreate. Losing or changing it breaks every saved app authentication, so each credential would need to be re-entered before workflows run again. Plan any rotation as a scheduled change with a re-entry step.

SSO with SAML and OpenID Connect

Shuffle added SAML single sign-on in version 0.9.16 and OpenID Connect in version 1.0.0, both available on-premises and in the cloud. Per-tenant SSO enforcement can require that a tenant's users sign in through the identity provider. SAML is being deprecated on Shuffle Cloud in favor of OpenID Connect, so a cloud deployment should plan on OpenID Connect. Test that enforcement blocks local logins for each tenant before go-live.

Audit trail for rule changes

Knowing who changed a detection rule, when, and what changed supports incident review and proves that detection content was approved. Before adoption, ask the Detection Manager team what change history the beta records, whether it keeps prior versions, and whether that history can be exported to your SIEM or log platform. If the beta cannot record authorship, add an approval step in your Git or ticketing workflow.

Classifying rule content and sample logs

Detection rules reveal which attacks you can see and which gaps remain, so a rule library is sensitive even when it holds no customer data. Classify the library at the level your threat model requires, limit read access to the security team, and keep exports out of shared drives. Test log samples may contain personal or regulated data, so apply the same handling rules you use for production logs.

Questions teams ask before scoping a Shuffle Detection Manager project

What drives the cost of a Shuffle Detection Manager project?

The main cost drivers are the number of log sources, pipeline complexity, the Orborus topology, SIEM integration depth, rule volume and tuning, and how much beta risk your organization accepts. Log sources each need parsing, field mapping and test cases, so the count sets much of the effort. Pipeline complexity grows with enrichment, filtering and routing through Tenzir pipelines. Orborus topology determines how many runtime nodes you operate and where they sit. SIEM integration depth ranges from forwarding events to one destination up to correlating with SIEM alerts and returning results. Rule volume and tuning depend on how many Sigma rules you deploy and how much false-positive work each one needs. Beta risk affects how much fallback planning you need. Ask for each factor to be priced separately in the written scope.

Can our team run a Shuffle detection rule project without a partner?

Yes, for a small pilot, if your engineers can work from Shuffle's documentation and you have a test environment that is close enough to production to validate rules. A pilot is typically limited to a few log sources, one Orborus node and a small rule set. It gets harder when you need multi-site high availability, because Shuffle's configuration documentation recommends an OpenSearch cluster, a shared cache, NFS for shared files across several backends and more than one Orborus node. It gets harder again when rule outputs feed regulated evidence, since change records, access controls and evidence trails must match what an auditor will ask to see. Independent auditors and certification bodies make those determinations, while DeployOpen prepares the systems, controls and evidence for them. Confirm the beta status and support terms with Shuffle before you commit internal capacity.

How long does a Shuffle Detection Manager project take to complete?

Duration follows scope, and no single timeline fits every environment. The variables that drive cost also drive schedule: the number of log sources, the number of sites and Orborus nodes, how many rules need tuning, and how many systems must integrate with your SIEM. Approval cycles for changes and access add elapsed time that the build itself does not. Ask for the timeline in the written scope, with milestones tied to deliverables. Ask which steps depend on your teams, such as log source owners providing sample data or change approvals being granted on schedule. Most DeployOpen engagements are fixed-scope, with scope, deliverables and timelines agreed in writing before work starts.

What does our team need to provide for a Shuffle project?

Your team needs to name the people and environments the work depends on before it starts. Log source owners provide access, sample logs and change windows for each source the pipeline reads. A test environment should resemble production, with Shuffle, Orborus and representative log sources, so rules can be validated before they reach live alerting. Named rule owners decide which Sigma rules are in scope, approve tuning changes and answer for false positives. Change approval needs a defined path for pipeline, Orborus and rule changes, including who signs off and how rollbacks happen. Add a secrets custodian as well, because the SHUFFLE_ENCRYPTION_MODIFIER value and app credentials must be protected and recoverable.

Does Shuffle Detection Manager replace our SIEM?

Shuffle Detection Manager complements your SIEM and leaves its alerting, search and case workflows in place. It manages Sigma and other detection rules centrally, and Tenzir pipelines move log data toward the places where rules run. Your SIEM usually remains the system of record for alerts your analysts already work in, so the integration design matters as much as the tool choice. Decide which events go to the SIEM, which go to Shuffle, which are duplicated and where each alert is closed. Because the Detection Manager is in beta, confirm with Shuffle and your SIEM vendor which forwarding paths your versions support.

What should a quote for a Shuffle detection rule project include?

Ask for a quote that lists scope in enough detail to compare it with your own estimate. It should include the number and type of log sources, the pipeline stages each one passes through, the Orborus topology and where each node runs, the SIEM integrations and their direction, the number of Sigma rules in scope and the tuning allowance for each, and the test environment. Ask which items are one-time, such as design and build, and which recur, such as support, upgrades and retainers. Ask how beta changes in Shuffle are handled, what is excluded, and what the acceptance criteria and payment milestones are. DeployOpen does not publish a price list, and each quote follows from the written scope.

Which Orborus setup do we need for high availability?

Choose the deployment architecture first, because it determines how jobs reach your runtime. Shuffle documents four options: a single server with Docker Compose, distributed Docker Swarm, a hybrid of Shuffle Cloud with a local Orborus, and Kubernetes with Helm charts. The hybrid model needs no inbound firewall ports for the local Orborus, which matters in segmented networks. For high availability, Shuffle's configuration documentation recommends an OpenSearch cluster, optional Memcached for a shared cache, NFS for shared files when running several backends, backend and frontend scaled across servers and more than one Orborus node so workflows keep running if one fails. Test failover before go-live, because a single Orborus node is a single point of failure for execution.

What breaks when a Shuffle detection pipeline goes live?

The most common failures involve secrets, versions and runtime capacity. Shuffle encrypts saved app credentials and API keys in OpenSearch with AES-256 using SHUFFLE_ENCRYPTION_MODIFIER, and the documentation warns that losing or changing it breaks all saved app authentications, so store it in your secrets system before any upgrade. Version drift causes trouble too. Shuffle recommends the latest Docker tag for stable releases and the nightly tag for experimental changes, so pin tags deliberately and record every change. Shuffle also stopped supporting versions older than v2.1.1 after January 31, 2026, so older installs need an upgrade plan. Check container capacity on each Orborus host, because every workflow execution starts a worker and app containers.

Limits to confirm in your environment before you commit

The Detection Manager depends on several moving parts: a beta feature, rule formats, log pipelines, the Orborus runtime, edition limits and supported versions. Each card poses a question to settle with Shuffle and in your own environment before you commit to production.

Beta status and rule formats

Shuffle describes the Detection Manager as a beta, so confirm what that means for your planned use before you set a production date. Ask Shuffle which rule formats the manager imports today, which format versions are tested, and what sits outside that scope. Get the answer in writing and record each known gap as an accepted risk for your change board.

Sigma and other rule compatibility

Your repository may hold Sigma rules with custom modifiers, field names or conventions, as well as detection rules in other formats. Run a representative sample from your own repository through the import and compare the converted results with the logic your analysts expect. Record which rules fail, which need edits and who owns those edits before you migrate the full set.

Log sources and Tenzir pipeline types

Detection rules only fire on data that reaches them, so confirm which log sources and Tenzir pipeline types the Detection Manager supports in your target release. List each source you rely on, its format and the field names your rules use, then check that a pipeline parses those fields in your environment. Name who maintains each pipeline after handover, because a change in source schema may break detections.

Orborus requirements for the manager

Orborus polls the Shuffle backend for jobs, starts a worker for each workflow execution, and that worker starts app containers. Confirm the host sizing, container runtime and network path Orborus needs, including access to the backend on port 5001. If you use a hybrid setup with Shuffle Cloud, confirm that the local Orborus works without inbound firewall ports, and plan more than one Orborus node if detections must continue through a node failure.

Edition feature and limit differences

Shuffle states that all features are available in the open-source edition, and that since v2.1.1 the limits between editions are actively enforced. Ask which limits apply to your expected volume, scaling and support needs. Shuffle prices enterprise licensing on app runs, which count only actions that execute, so triggers and skipped actions are excluded. Model your expected run volume against the limits of the edition you choose.

Supported versions and upgrade path

Versions older than v2.1.1 stopped being supported after January 31, 2026, so any earlier installation needs an upgrade plan before detection workloads move onto it. Shuffle published v2.3.0 on September 28, 2026. Confirm your target version against the release notes, and decide whether production pins a version tag or follows the latest tag, since the Shuffle docs reserve the nightly tag for experimental changes.

How DeployOpen scopes and delivers Shuffle detection rule projects

DeployOpen treats Shuffle Detection Manager for Sigma rules as a scoped implementation inside your own infrastructure, covering the Shuffle server, the Orborus runtime, rule content and log forwarding. Engagements are fixed-scope, with scope, deliverables and timelines agreed in writing before work starts. Your team then operates and documents the workflow after handover.

How we scope

  • We confirm the Shuffle deployment architecture, Orborus placement and whether Shuffle Cloud or a local server hosts the manager.
  • The written scope lists which Sigma rule sources, log sources and SIEM connections are in and out.
  • Engagements are fixed-scope, and ongoing support can be added as a retainer after handover.

How we build

  • We install the Shuffle server and Orborus nodes in your environment, following the Shuffle architecture options you select.
  • We set up the SHUFFLE_ENCRYPTION_MODIFIER secret under your key handling process before any app credentials are saved.
  • We build log forwarding into Tenzir pipelines and test each rule path against sample events from your SIEM.

How we hand over

  • Documentation covers architecture, Orborus requirements, rule lifecycle steps and the log forwarding design.
  • We walk your SOC and platform engineers through runbooks for failed Orborus nodes and stalled workflows.
  • Handover records which system owns alerting, correlation and retention, so each detection has a single accountable owner.

How we support

  • Support covers Shuffle upgrades, with each release checked against app and rule compatibility before rollout.
  • Retainers can cover upgrades, rule maintenance and continuous security testing, with terms set in writing.
  • Beta status and Tenzir pipeline requirements are confirmed with the vendors before the scope is signed.

Sources and further reading

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.