playbooks

home / skills / gracebotly / flowetic-app / make

make skill

/workspace/skills/make

This skill helps orchestrate and automate Make workflows with templates, enabling efficient scenario design and repeatable automation patterns.

npx playbooks add skill gracebotly/flowetic-app --skill make

Review the files below or copy the command above to add this skill to your agents.

Files (2)
SKILL.md
2.8 KB
---
name: make
version: 2.0.0
platformType: make
description: Mapping guidance for Make.com (Integromat) scenario events. Covers execution metrics, scenario performance, operation counts, and module analytics.
tags:
  - platform
  - make
  - automation
  - analytics
metadata:
  author: getflowetic
  phase-scope: all
lastUpdated: 2026-02-25
---

# Make Platform Skill

## Overview
Make.com (formerly Integromat) is a visual automation platform for connecting apps and automating workflows via scenarios. Users connect Make scenarios to Getflowetic to monitor execution performance, track operation usage, and analyze error patterns.

## Vocabulary
- **scenario**: A Make automation workflow composed of modules connected in a flow
- **execution**: A single run of a scenario, triggered by schedule, webhook, or manual
- **module**: A single step/action within a scenario (e.g., HTTP request, Google Sheets row)
- **operation**: A billable action counted by Make — modules consume operations per execution
- **blueprint**: The JSON definition of a scenario's structure (modules + connections)
- **team**: Make organizational unit that owns scenarios and connections

## Key Metrics for Dashboards
- **Execution Volume**: Total runs over time — trend chart on started_at
- **Success Rate**: Percentage of executions with status=success — hero stat
- **Avg Duration**: Average execution time in ms — supporting metric card
- **Scenario Breakdown**: Runs per scenario — pie chart on scenario_name/workflow_name
- **Error Rate**: Failed executions as percentage — hero stat (inverted success)

## Event Field Mapping
The Make import route normalizes execution data into the standard event schema. These are the fields that appear in `event.state`:

| Event Field | Semantic Type | Dashboard Use |
|-------------|--------------|--------------|
| workflow_id | identifier | Maps to scenario_id — count only |
| workflow_name | dimension | Maps to scenario name — breakdown charts |
| execution_id | surrogate_key | Maps to execution ID — "Total Runs" KPI |
| status | dimension | Success rate percentage — hero stat |
| duration_ms | measure (avg) | "Avg Duration" metric card |
| started_at | time_dimension | Timeseries trend axis |
| ended_at | time_dimension | Detail only |
| platform | constant | Always "make" — skip |

These fields also appear in `event.labels`:
- scenario_id, scenario_name, execution_id, status, platformType

## Dashboard Templates
- **ops-monitoring**: Execution volume trend, success rate, avg duration, scenario breakdown
- **scenario-performance**: Per-scenario comparison with execution counts and durations
- **error-tracker**: Error trends, failure reasons, scenario-level error rates

## Mapping Heuristics (Legacy Aliases)
- scenario_id → workflow_id
- scenario_name → workflow_name

Overview

This skill provides scenario orchestration and automation patterns tailored for Make (formerly Integromat). It packages reusable templates and TypeScript-based integrations to accelerate building reliable automations and analytics workflows. Use it to standardize scenarios, handle errors, and scale integrations across teams.

How this skill works

The skill supplies ready-to-use scenario templates and pattern implementations that map common automation needs to Make modules and data flows. It includes TypeScript helpers and conventions for transforming data, retrying failures, and composing multi-step scenarios. Developers import patterns, adapt templates, and deploy scenarios into Make to run orchestrated processes.

When to use it

  • When you need repeatable, standardized automation patterns for Make scenarios
  • When building cross-system data pipelines that require retries, logging, or transformations
  • When onboarding new team members to a consistent scenario design approach
  • When converting ad-hoc automations into production-ready workflows
  • When you want TypeScript-driven helpers to reduce manual configuration in Make

Best practices

  • Start from a template that closely matches your workflow and iterate, don’t rebuild from scratch
  • Keep error handling and retry logic explicit in each scenario to avoid silent failures
  • Use TypeScript helpers for transformations to ensure predictable data shapes
  • Modularize scenarios into small, testable steps for easier debugging and reuse
  • Document trigger conditions and side effects clearly to avoid unexpected data changes

Example use cases

  • General analytics pipeline: collect events, enrich data, and push to analytics storage
  • Cross-app orchestration: sync records between CRM, billing, and support systems
  • Automated alerting: detect anomalies and trigger multi-channel notifications
  • Data enrichment: fetch external metadata, normalize fields, and update databases
  • Scheduled maintenance tasks: run cleanup, archive, and reporting workflows on a cadence

FAQ

Does this skill require a Make account?

Yes. You deploy and run scenarios within Make, so an active account and appropriate module access are required.

Can I customize templates?

Absolutely. Templates are designed to be adapted; use the included TypeScript helpers and modular patterns to tailor logic and transforms.