Import and export patterns

Patterns are portable. You can export any pattern as a JSON file and import it into another account, a different workspace, or the same account as a copy. This is useful for sharing automations with teammates, backing up your work, keeping patterns in version control, and distributing templates.

What the export includes

A pattern export is a single JSON file that contains everything needed to recreate the pattern:

• Nodes — every node on the canvas, including its type, position, and configuration
• Wires — all data wires and execution wires between nodes
• Variables — variable definitions with names, types, and default values
• Triggers — the trigger configuration (webhook, schedule, or pattern call)
• Metadata — the pattern name, description, and creation timestamp

The export does not include:

• Connection credentials — connections are account-specific and encrypted. After importing, you must reassign connections in the new account.
• Deployment state — the imported pattern arrives as a draft. You deploy it separately.
• Execution history — past runs belong to the original deployment and are not included.
• Webhook URLs — webhook URLs are assigned per-pattern per-account. The imported pattern receives a new URL when deployed.

Export a pattern

1. Open the DRAGOPS dashboard.
2. Find the pattern you want to export in the pattern list.
3. Select the menu icon on the pattern card.
4. Select Export.
5. DRAGOPS downloads a .json file to your computer. The filename matches the pattern name.

You can also export from the visual editor:

1. Open the pattern in the editor.
2. Open the pattern menu in the toolbar.
3. Select Export.

The exported file is a standard JSON document. You can open it in any text editor to inspect its contents.

Import a pattern

1. Open the DRAGOPS dashboard.
2. Select Import Pattern.
3. Choose the .json file from your computer, or drag and drop it onto the import area.
4. DRAGOPS validates the file and shows a preview of the pattern name and node count.
5. Select Import.

The pattern appears in your pattern list as a draft. Open it in the editor to review and configure before deploying.

After importing

A few things to check after importing a pattern:

• Connections — If the pattern uses HTTP Request nodes with connections, select each node and reassign the connection from your account. The original connection references do not carry over.
• Variables — Review the variable defaults. The importing account may need different initial values.
• Trigger configuration — Verify the trigger settings. For scheduled patterns, confirm the cron expression is correct for your use case. For webhook-triggered patterns, the new webhook URL is assigned when you deploy.
• Test before deploying — Select Run in the toolbar to verify the pattern works with your data and connections before taking it live.

Use cases

Share with teammates

Export a working pattern and send the JSON file to a colleague. They import it into their account and adapt it to their needs. This is faster than rebuilding from scratch and ensures consistent implementation.

Version control

Store pattern exports in a Git repository alongside your infrastructure code. When you update a pattern, export the new version and commit the change. This gives you a history of every version, the ability to diff changes, and the option to roll back to a previous version.

Backups

Before making significant changes to a pattern, export it as a backup. If the changes do not work out, import the backup to restore the original version.

Templates

Build a library of common automation patterns — webhook-to-Slack notifications, scheduled health checks, data sync jobs — and share them as importable templates. New team members can import a template and customize it instead of starting from an empty canvas.

Export format structure

The exported JSON follows this general structure:

{
  "name": "Health Check",
  "description": "Monitors an API endpoint every 5 minutes",
  "nodes": [
    {
      "id": "node-1",
      "type": "OnSchedule",
      "position": { "x": 100, "y": 200 },
      "data": {
        "cronExpression": "*/5 * * * *"
      }
    },
    {
      "id": "node-2",
      "type": "HttpRequest",
      "position": { "x": 400, "y": 200 },
      "data": {
        "method": "GET",
        "url": "https://api.example.com/health"
      }
    }
  ],
  "wires": [
    {
      "source": "node-1",
      "target": "node-2",
      "sourcePin": "exec-out",
      "targetPin": "exec-in"
    }
  ],
  "variables": [],
  "metadata": {
    "exportedAt": "2026-03-05T10:00:00Z",
    "version": "1.0"
  }
}

The exact schema may include additional fields depending on the nodes and configuration. DRAGOPS validates the file during import and reports any structural issues.

Tips

• Export before major edits. Keep a snapshot of the working version in case you need to revert.
• Rename after importing. If you import a pattern that has the same name as an existing one, DRAGOPS creates it as a separate pattern. Rename it to avoid confusion.
• Review connections carefully. The most common issue after importing is missing connection assignments. Check every HTTP Request node that references a connection.
• Strip sensitive data. If a pattern contains hardcoded URLs or values specific to your environment, update them before sharing the export file.

What is next?