# Step 1: Pull only NEW orders since last run
- op: http_request
request:
source: "shopify"
url: "https://{{ var('store_name') }}.myshopify.com/admin/api/{{ var('api_version') }}/orders.json"
method: GET
parameters:
status: any
updated_at_min_expression: "{{ last_run_timestamp() or '2024-01-01' }}"
headers:
"Accept": "application/json"
response:
success_status: [200]
tables:
- source: "snowflake"
table: "shopify_orders_incremental"
columns: { ... }
data_expression: response.json()['orders']
# Step 2: Update metrics ONLY for customers with new/changed orders
- op: transform
source: "snowflake"
query: |
MERGE INTO customer_metrics cm
USING (
SELECT
customer_id,
SUM(total_price::FLOAT) as total_spend,
COUNT(*) as order_count
FROM shopify_orders
WHERE customer_id IN (
SELECT DISTINCT customer_id
FROM shopify_orders_incremental
)
GROUP BY customer_id
) new_metrics
ON cm.customer_id = new_metrics.customer_id
WHEN MATCHED THEN
UPDATE SET
total_spend = new_metrics.total_spend,
order_count = new_metrics.order_count,
updated_at = CURRENT_TIMESTAMP()
WHEN NOT MATCHED THEN
INSERT (customer_id, total_spend, order_count, updated_at)
VALUES (new_metrics.customer_id, new_metrics.total_spend, new_metrics.order_count, CURRENT_TIMESTAMP())
# Step 3: Sync only customers whose metrics were just updated
- op: http_request
input:
source: "snowflake"
query: |
SELECT customer_id, email, total_spend, order_count
FROM customer_metrics
WHERE updated_at >= '{{ run_start_timestamp() }}'
request:
source: "mailchimp"
url_expression: |
f"https://us1.api.mailchimp.com/3.0/lists/{var('list_id')}/members/{hashlib.md5(record['email'].encode()).hexdigest()}"
method: PATCH
body_expression: |
{
"merge_fields": {
"TOTALSPEND": record['total_spend'],
"ORDERCOUNT": record['order_count']
}
}
This scales much better: if you have 100K customers but only 50 new orders, you're recalculating metrics for ~50 customers instead of all 100K. Same simple workflow pattern, just production-ready efficiency.
Target audience:
1) Enterprise IT teams who already know SQL/YAML - they can build complex integrations after ~1 hour of training using our examples, no prior Python needed
2) Modern data teams using dbt - Sequor complements it perfectly for data ingestion and activation
What they gain:
Full flexibility with structure. Enterprise IT folks go from zero to building end-to-end solutions in an hour without needing developer support. Think "dbt but for API integrations."
Competitors & differentiation:
1) Zapier/n8n: GUI looks easy but gets complex fast, poor database integration, can't handle bulk data
2) Fivetran/Airbyte: Pre-built connectors only, zero customization, ingestion-only
3) Us: Only code-first solution using open tech stack (SQL+YAML+Python) - gives you flexibility with Fivetran reliability
Business model:
1) Core engine: Open source, free forever
2) Revenue: On-premise server with enterprise features (RBAC, observability and execution monitoring with notifications, audit logs) - flat fee per installation, no per-row costs like competitors
3) Services: Custom connector development and app-to-app integration flows (we love this work!)
4) Cloud version maybe later - everyone wants on-premise now
The key difference:
we're the only tool that's both easy to learn AND highly customizable for all major API integration patterns: data ingestion, reverse ETL, and multi-step iPaaS workflows - all in one platform.