Patterns

What is a pattern?

A pattern is a self-contained automation workflow in DRAGOPS. You build it visually in the editor as a graph of connected nodes, and when you deploy it, the execution engine runs it as an isolated process.

Every pattern has:

• A trigger — the event that starts execution (webhook, schedule, or pattern call)
• A graph — the nodes and wires that define the logic
• Variables — local state that persists across nodes within a single execution
• Metadata — a name, optional description, and tags for organization

Pattern lifecycle

Patterns move through a clear lifecycle from creation to live execution.

Draft → Deploy → Active → (Edit → Redeploy) → Undeploy

1. Draft — You build and test in the editor. Nothing runs yet. You can execute test runs manually to verify behavior.
2. Deploy — Select Deploy to push the pattern to the execution engine. DRAGOPS compiles the graph, assigns a version number, and registers any triggers.
3. Active — The pattern is live. Webhooks accept requests, schedules fire on time, and other patterns can call it.
4. Edit and redeploy — Make changes in the editor and deploy again. The new version replaces the previous one seamlessly. Webhook URLs remain stable across redeploys.
5. Undeploy — Remove the pattern from the execution engine. The graph is preserved in the editor for future redeployment.

Pattern metadata

Each pattern carries metadata that helps you organize your workspace:

• Name — a human-readable label displayed in the dashboard and editor
• Description — optional context about what the pattern does
• Tags — free-form labels for filtering and grouping patterns in the dashboard

Pattern composition

Patterns can call other patterns using the Call Pattern node. This makes patterns composable — you build small, focused automations and wire them together into larger workflows.

The called pattern must have an On Pattern Call trigger, which defines its input and output interface. This works like a function signature: callers must provide the correct inputs and receive typed outputs. The caller blocks until the called pattern completes.

Versioning

Every deployment creates a new version. DRAGOPS tracks version numbers so you can see the deployment history for any pattern. When you redeploy, the new version replaces the active one. The previous version is recorded in the execution history for auditing.

Import and export

You can export a pattern as a JSON file and import it into another workspace. This is useful for sharing automations, creating backups, or moving patterns between environments.

Execution model

When a pattern triggers, the execution engine:

1. Runs nodes in dependency order — data flows forward through pins
2. Handles errors with retry logic and dead-letter reporting
3. Records a timestamped execution log for every run
4. Reports results back to the dashboard

Each execution is isolated. One pattern failing never affects another pattern.

Related concepts

• Nodes and pins — the building blocks inside a pattern
• Wires — how nodes connect to each other
• Triggers — what starts a pattern
• Deployments — pushing patterns to the execution engine
• Executions — viewing run history and logs