Mechanic für Shopify: Der ultimative Guide zur Enterprise-Automatisierung

Sie haben fünf Automatisierungs-Apps installiert, drei Zapier-Zaps eingerichtet und Shopify Flow bis an die Grenzen ausgereizt — und trotzdem gibt es Prozesse, die einfach nicht automatisiert werden können. Bestelldaten, die manuell in einen zweiten Store übertragen werden. Preise, die per Excel von Brutto auf Netto umgerechnet werden. Lagerbestände, die in zwei Systemen parallel gepflegt werden müssen.

Wenn Ihnen das bekannt vorkommt, dann ist dieser Artikel für Sie.

Mechanic ist die App, die alles verändert hat — für meine Kunden und für meine Arbeitsweise als Shopify-Entwickler. In diesem Guide zeige ich Ihnen detailliert, was Mechanic kann, warum es in einer eigenen Liga spielt, und wie ich damit für einen Kunden eine vollautomatische Multi-Store-Synchronisierung gebaut habe, die D2C- und B2B-Verkauf über einen einzigen Store steuert.

Transparenz-Hinweis: Ich bin kein Affiliate von Mechanic. Ich empfehle die App, weil ich sie täglich einsetze und sie funktioniert. Alle Beispiele stammen aus echten Kundenprojekten.

Was ist Mechanic?

Mechanic ist eine Enterprise-grade Automatisierungsplattform für Shopify, entwickelt von Lightward (Chicago, IL). Mit über 360 vorgefertigten Automatisierungen und einer vollständigen Entwicklungsumgebung ist Mechanic keine gewöhnliche Shopify-App — es ist eine Plattform, auf der Sie praktisch jede Automatisierung bauen können, die technisch möglich ist.

Das Mechanic-Dashboard: Übersichtlich, aufgeräumt, alle Tasks auf einen Blick.

Die Zahlen sprechen für sich

Metrik	Wert
Verfügbare Tasks	360+ (und wachsend)
Bewertung	4.9 / 5.0 Sterne
Reviews	142+ verifizierte Bewertungen
Seit	Mai 2018 (über 7 Jahre bewährt)
Sprache	Liquid (die Sprache, die Shopify-Entwickler bereits kennen)
API-Zugang	Vollständiger Shopify Admin API Zugang (GraphQL & REST)
Integrationen	Shopify Flow, Google Sheets, Airtable, Slack, E-Mail, FTP, Webhooks

Was unterscheidet Mechanic von anderen Automatisierungs-Apps?

Die meisten Shopify-Automatisierungs-Apps funktionieren nach dem Prinzip "Wähle aus dem Menü": Sie klicken sich zusammen, was die App kann, und wenn die App es nicht kann — Pech gehabt.

Mechanic funktioniert fundamental anders:

Andere Apps:    Trigger → Vordefinierte Aktion → Fertig
Shopify Flow:   Trigger → Condition → Begrenzte Actions → Fertig
Mechanic:       Event → Ihr eigener Code → Unbegrenzte Möglichkeiten

Mechanic gibt Ihnen eine vollständige Entwicklungsumgebung. Sie schreiben Tasks in Liquid — der Template-Sprache, die jeder Shopify-Entwickler kennt — mit erweiterten Filtern für JSON-Parsing, CSV-Generierung, HMAC-Berechnungen und komplexen Datenstrukturen. Dazu haben Sie direkten Zugang zur kompletten Shopify GraphQL Admin API.

Das bedeutet: Alles, was Shopify's API kann, kann Mechanic automatisieren.

Mechanic vs. Shopify Flow vs. Custom Apps

Bevor wir tiefer einsteigen: Wo genau positioniert sich Mechanic im Vergleich zu den Alternativen?

Feature	Shopify Flow	Mechanic	Custom App
Kosten	Kostenlos (in allen Plänen)	Ab $16/Monat	$5.000-50.000+ Entwicklung
Einrichtung	Visueller Editor, Minuten	Library oder Code, Stunden-Tage	Wochen-Monate
Komplexität	Einfache Wenn-Dann-Logik	Beliebig komplexe Logik	Unbegrenzt
API-Zugang	Begrenzt auf Flow-Actions	Vollständige Admin API	Vollständig
Externe APIs	Nur über Connectors	HTTP-Action für jede API	Vollständig
Multi-Store	Nein	Ja (via HTTP)	Ja
Scheduled Tasks	Begrenzt	Stündlich, täglich, wöchentlich	Beliebig
Error Handling	Minimal	Eingebaut + anpassbar	Selbst bauen
Wartung	Keine	Minimal (Mechanic hostet)	Server, Updates, Monitoring
Lernkurve	Niedrig	Mittel (Liquid-Kenntnisse)	Hoch

Die goldene Mitte

Mechanic besetzt eine Nische, die vorher leer war: zu komplex für Flow, zu klein für eine Custom App.

Wenn Sie als Shopify-Händler Workflows haben, die:

Mehrere API-Calls erfordern
Daten transformieren müssen (Preisberechnung, Format-Konvertierung)
Auf externe Systeme zugreifen
Zeitgesteuert laufen sollen
Fehlerbehandlung brauchen

...dann ist Mechanic fast immer die richtige Wahl — und um ein Vielfaches günstiger als eine Custom-App-Entwicklung.

Mehr zu den Grenzen von Shopify Flow finden Sie in meinem Artikel: Shopify Flow vs. Custom Automatisierung: Wann reicht Flow nicht mehr?

Die Architektur: Events, Tasks und Actions

Um Mechanic wirklich zu verstehen, müssen Sie drei Konzepte kennen:

1. Events (Auslöser)

Ein Event ist alles, was in Ihrem Shop passiert — oder passieren sollte:

shopify/orders/create          → Neue Bestellung
shopify/products/update        → Produkt geändert
shopify/inventory_levels/update → Lagerbestand geändert
shopify/customers/create       → Neuer Kunde
mechanic/scheduler/daily       → Täglich um Mitternacht
mechanic/scheduler/hourly      → Jede Stunde
mechanic/user/trigger          → Manuell ausgelöst

Mechanic lauscht auf Shopify Webhooks und fügt eigene Event-Typen hinzu (Scheduler, User-Trigger, E-Mail-Empfang). Das Besondere: Events können Kind-Events erzeugen — ein Task kann also nach seiner Ausführung weitere Events triggern, die wiederum andere Tasks starten.

2. Tasks (Automatisierungen)

Ein Task ist Liquid-Code, der auf Events reagiert. Hier ein einfaches Beispiel — automatisches Taggen von High-Value-Bestellungen:

{% comment %}
  Subscription: shopify/orders/create
  Dieses Task taggt Bestellungen über 500€ automatisch als "VIP-Order"
{% endcomment %}

{% assign order_total = order.total_price | times: 1.0 %}

{% if order_total >= 500.0 %}
  {% action "shopify" %}
    mutation {
      tagsAdd(
        id: {{ order.admin_graphql_api_id | json }}
        tags: ["VIP-Order", "High-Value"]
      ) {
        userErrors {
          field
          message
        }
      }
    }
  {% endaction %}
{% endif %}

Das ist nur die Spitze des Eisbergs. Tasks können:

Schleifen über Tausende von Produkten laufen
GraphQL-Queries direkt an Shopify senden
HTTP-Requests an externe APIs machen
E-Mails senden (mit HTML-Templates)
Dateien generieren (CSV, PDF, ZIP)
FTP-Uploads durchführen
Andere Tasks triggern

3. Actions (Ausführungen)

Actions sind die konkreten Operationen, die ein Task auslöst:

Action-Typ	Was es tut	Beispiel
Shopify	GraphQL Mutation an Shopify	Produkt erstellen, Preis ändern, Tag setzen
HTTP	Beliebiger HTTP-Request	API-Call an ERP, Webhook an Slack
Email	E-Mail senden	Benachrichtigung an Team, Bericht an Chef
FTP	Datei auf FTP-Server hochladen	CSV-Export an Fulfillment-Partner
Files	Dateien generieren	PDF-Rechnung, CSV-Report, ZIP-Archiv
Event	Neues Event erzeugen	Ketten-Automatisierung starten

Der Mechanic Code-Editor: Fullscreen-Editing mit Syntax-Highlighting und direktem Zugang zu Task-Settings.

360+ vorgefertigte Tasks: Die Bibliothek

Einer der größten Vorteile von Mechanic: Sie müssen nicht bei Null anfangen. Die Task-Bibliothek enthält über 360 getestete, sofort einsetzbare Automatisierungen.

Die Mechanic Task-Bibliothek: 360+ Automatisierungen, durchsuchbar nach Kategorie.

Die beliebtesten Kategorien

Kategorie	Anzahl Tasks	Beispiele
Bestellungen	125+	Auto-Tagging, Fulfillment, Stornierung
Auto-Tagging	102+	Kunden, Produkte, Bestellungen nach Regeln taggen
Produkte	97+	Sortierung, Veröffentlichung, Preis-Updates
Kunden	73+	Segmentierung, E-Mails, Einladungen
E-Mail	64+	Benachrichtigungen, Reports, Kunden-E-Mails
Inventar	28+	Bestandsüberwachung, Sync, Alerts
Sync	13+	SKU-Sync, Inventar-Sync, Daten-Sync
Integration	8+	Google Sheets, Slack, Airtable, externe APIs

Meine Top 10 Tasks für den sofortigen Einsatz

Basierend auf meiner Erfahrung mit Mechanic bei verschiedenen Kundenprojekten — hier sind die Tasks, die ich am häufigsten installiere:

1. Auto-Tag Orders by Discount Code Jede Bestellung wird automatisch mit dem verwendeten Rabattcode getaggt. Unverzichtbar für Marketing-Auswertungen.

2. Hide Out-of-Stock Products Ausverkaufte Produkte werden automatisch aus dem Shop entfernt und wieder veröffentlicht, sobald Bestand da ist.

3. Sync Inventory for Shared SKUs Varianten mit gleicher SKU werden automatisch synchronisiert — ändert sich der Bestand einer Variante, ändern sich alle.

4. Flag Orders That Aren't Fulfilled After X Days Überfällige Bestellungen werden automatisch getaggt und Team-Mitglieder benachrichtigt.

5. Auto-Invite Customers After an Order Gastbesteller bekommen automatisch eine Einladung zur Account-Erstellung. Perfekt für Kundenbindung.

6. Maintain Inventory for Product Bundles Bundle-Bestände werden automatisch berechnet basierend auf den Einzelkomponenten.

7. Email a CSV Export of Orders Täglicher/wöchentlicher Order-Export per E-Mail — ideal für Buchhaltung und Reporting.

8. Nightly Out-of-Stock Report Jeden Morgen eine E-Mail mit allen ausverkauften Produkten im Postfach.

9. Auto-Tag Customers by Total Spend Kunden werden automatisch in Stufen getaggt (Bronze, Silber, Gold, VIP) basierend auf Gesamtumsatz.

10. Cancel Unpaid Orders After X Days Unbezahlte Bestellungen werden automatisch storniert — hält Ihre Bestellliste sauber.

Das Beste: Alle Tasks sind Open Source und können angepasst werden. Wenn ein Task zu 90% passt, ändern Sie die restlichen 10% einfach im Code-Editor.

Praxisbeispiel: Multi-Store-Sync von D2C zu B2B

Jetzt wird es konkret. Ich zeige Ihnen eine der komplexesten Mechanic-Automatisierungen, die ich bisher gebaut habe — und warum sie mit keiner anderen Lösung in diesem Preisrahmen möglich gewesen wäre.

Die Ausgangssituation

Ein Kunde betreibt einen erfolgreichen D2C-Shopify-Store (Direct-to-Consumer) mit mehreren hundert Produkten. Das Geschäft wächst, und B2B-Anfragen kommen rein — Einzelhändler, Reseller, Firmenkunden, die größere Mengen zu Nettopreisen bestellen wollen.

Das Problem: Shopify's native B2B-Funktionen (Shopify Plus B2B) sind gut, aber der Kunde brauchte einen komplett separaten B2B-Store mit eigener Identität, eigenem Branding und eigenen Konditionen. Ein "To-Be"-Store (B2B-Variante) als zweiter Shopify-Store.

Die Herausforderung: Zwei Stores manuell synchron zu halten ist ein Albtraum:

                    ┌─────────────────────┐
                    │   D2C-Store (Quelle) │
                    │                     │
                    │  • 500+ Produkte    │
                    │  • Brutto-Preise    │
                    │  • D2C-Lagerbestand │
                    │  • Tägliche Updates │
                    └──────────┬──────────┘
                               │
                    Was muss synchronisiert werden?
                               │
              ┌────────────────┼────────────────┐
              │                │                │
     ┌────────▼──────┐ ┌──────▼───────┐ ┌──────▼──────┐
     │  Produktdaten  │ │    Preise    │ │  Bestände   │
     │               │ │              │ │             │
     │ • Titel       │ │ • Brutto→    │ │ • Gleicher  │
     │ • Beschreibung│ │   Netto      │ │   Pool oder │
     │ • Bilder      │ │ • 19% MwSt   │ │   separater │
     │ • Varianten   │ │   abziehen   │ │   B2B-Pool  │
     │ • Metafields  │ │ • B2B-Rabatt │ │ • Mindest-  │
     │ • Tags        │ │   aufschlagen│ │   bestände  │
     │ • SKUs        │ │ • Staffel-   │ │ • Reserv.   │
     └───────────────┘ │   preise     │ └─────────────┘
                       └──────────────┘
                               │
                    ┌──────────▼──────────┐
                    │  B2B-Store (Ziel)   │
                    │                     │
                    │  • Netto-Preise     │
                    │  • B2B-Sortiment    │
                    │  • Eigenes Branding │
                    │  • Eigene Kunden    │
                    └─────────────────────┘

Ohne Automatisierung: Das Team müsste bei jeder Produktänderung, jedem neuen Produkt, jeder Preisänderung und jeder Bestandsbewegung manuell den zweiten Store aktualisieren. Bei 500+ Produkten und täglichen Änderungen: unmöglich.

Warum andere Lösungen hier scheitern

Bevor ich zu Mechanic gegriffen habe, haben wir die Alternativen evaluiert:

Lösung	Problem
Shopify Flow	Kein Store-übergreifender API-Zugang. Flow kann nur innerhalb eines Stores agieren.
Sync-Apps (Syncio, Stock Sync etc.)	Können Produkte kopieren, aber keine Preistransformation (Brutto→Netto). Keine Custom-Logik für Filterung.
Zapier/Make	Zu langsam für Echtzeit-Sync. API-Rate-Limits. Wird bei 500+ Produkten teuer ($100+/Monat). Keine komplexe Logik.
Custom App	Funktioniert, aber: eigener Server, Hosting, Monitoring, Wartung. Kosten: $15.000-25.000 Entwicklung + laufende Kosten.
Mechanic	✅ Kann HTTP-Requests an anderen Store senden. ✅ Liquid für Preisberechnung. ✅ Event-basiert für Echtzeit. ✅ Gehostet. $29-99/Monat.

Die Mechanic-Lösung im Detail

Hier ist der Aufbau der Automatisierung, die ich implementiert habe:

D2C-Store (Quell-Store)                          B2B-Store (Ziel-Store)
┌──────────────────────────────┐                  ┌──────────────────────────┐
│                              │                  │                          │
│  Produkt wird erstellt oder  │    Mechanic      │  Produkt wird erstellt   │
│  aktualisiert                │──── Task ────▶   │  oder aktualisiert       │
│                              │   (HTTP API)     │                          │
│  Event: shopify/products/    │                  │  Mit:                    │
│         update               │                  │  • Netto-Preisen         │
│                              │                  │  • B2B-Tags              │
│  ┌─────────────────────────┐ │                  │  • Synced Metafields     │
│  │ Mechanic verarbeitet:   │ │                  │  • Angepasstem Bestand   │
│  │                         │ │                  │                          │
│  │ 1. Produkt-Daten lesen  │ │                  └──────────────────────────┘
│  │ 2. Brutto → Netto       │ │
│  │ 3. Filter-Logik         │ │
│  │ 4. Daten transformieren │ │
│  │ 5. HTTP → B2B-Store API │ │
│  └─────────────────────────┘ │
│                              │
└──────────────────────────────┘

Schritt 1: Event-Subscription

Der Task lauscht auf Produktänderungen im D2C-Store:

{% comment %}
  Subscriptions:
    shopify/products/create
    shopify/products/update
    mechanic/scheduler/daily
{% endcomment %}

Drei Trigger:

products/create: Neues Produkt → sofort in B2B-Store anlegen
products/update: Änderung → sofort synchronisieren
scheduler/daily: Täglicher Komplett-Abgleich als Sicherheitsnetz

Schritt 2: Produkt-Daten lesen und filtern

Nicht jedes Produkt soll im B2B-Store landen. Manche sind D2C-exklusiv:

{% comment %} Produkt-Daten über GraphQL abrufen {% endcomment %}
{% capture query %}
  query {
    product(id: {{ product.admin_graphql_api_id | json }}) {
      id
      title
      descriptionHtml
      vendor
      productType
      tags
      status
      variants(first: 100) {
        nodes {
          id
          title
          sku
          price
          compareAtPrice
          inventoryQuantity
          inventoryItem {
            id
          }
          selectedOptions {
            name
            value
          }
        }
      }
      images(first: 20) {
        nodes {
          url
          altText
        }
      }
      metafields(first: 50) {
        nodes {
          namespace
          key
          value
          type
        }
      }
    }
  }
{% endcapture %}

{% assign result = query | shopify %}
{% assign src_product = result.data.product %}

{% comment %} Filter: Nur Produkte mit Tag "b2b-sync" synchronisieren {% endcomment %}
{% unless src_product.tags contains "b2b-sync" %}
  {% comment %} Kein B2B-Produkt → nichts tun {% endcomment %}
  {% break %}
{% endunless %}

{% comment %} Inaktive Produkte ignorieren {% endcomment %}
{% if src_product.status == "DRAFT" or src_product.status == "ARCHIVED" %}
  {% break %}
{% endif %}

Schritt 3: Brutto → Netto Preisberechnung

Der Kern der Automatisierung — die Preistransformation. D2C-Preise sind Brutto (inkl. 19% MwSt.), B2B-Preise müssen Netto sein:

{% comment %} 
  Brutto-Netto-Umrechnung
  Formel: Netto = Brutto / 1.19
  Zusätzlich: B2B-Rabatt von 15% auf den Nettopreis
{% endcomment %}

{% assign mwst_faktor = 1.19 %}
{% assign b2b_rabatt = 0.85 %}  {% comment %} 15% Rabatt = Faktor 0.85 {% endcomment %}

{% assign variants_data = "" | split: "" %}

{% for variant in src_product.variants.nodes %}
  {% comment %} Brutto-Preis in Cent umrechnen für Präzision {% endcomment %}
  {% assign brutto_price = variant.price | times: 100 | round %}
  
  {% comment %} Netto berechnen: Brutto / 1.19 {% endcomment %}
  {% assign netto_price = brutto_price | divided_by: mwst_faktor | round %}
  
  {% comment %} B2B-Rabatt anwenden {% endcomment %}
  {% assign b2b_price = netto_price | times: b2b_rabatt | round %}
  
  {% comment %} Zurück in Euro umrechnen {% endcomment %}
  {% assign final_price = b2b_price | divided_by: 100.0 %}
  
  {% comment %} Compare-at-Price (Streichpreis) ebenfalls umrechnen {% endcomment %}
  {% if variant.compareAtPrice %}
    {% assign brutto_compare = variant.compareAtPrice | times: 100 | round %}
    {% assign netto_compare = brutto_compare | divided_by: mwst_faktor | round %}
    {% assign final_compare = netto_compare | divided_by: 100.0 %}
  {% else %}
    {% assign final_compare = nil %}
  {% endif %}
  
  {% comment %} Varianten-Daten für den B2B-Store zusammenstellen {% endcomment %}
  {% assign variant_obj = hash %}
  {% assign variant_obj["sku"] = variant.sku %}
  {% assign variant_obj["price"] = final_price %}
  {% assign variant_obj["compare_at_price"] = final_compare %}
  {% assign variant_obj["title"] = variant.title %}
  {% assign variant_obj["inventory_quantity"] = variant.inventoryQuantity %}
  {% assign variants_data = variants_data | push: variant_obj %}
{% endfor %}

Warum das so wichtig ist: Keine einzige Sync-App auf dem Markt kann diese Logik abbilden. Die rechnen nicht um. Die kopieren 1:1. Mechanic kann es, weil es vollständigen Code-Zugang bietet.

Schritt 4: Lagerbestand-Logik

Bei der Bestandssynchronisierung gibt es mehrere Strategien. Für diesen Kunden galt:

{% comment %}
  Bestandslogik:
  - B2B-Bestand = D2C-Bestand minus Sicherheitsreserve
  - Mindestbestand für B2B: 10 Stück (unter 10 → nicht im B2B verfügbar)
  - Wenn D2C-Bestand < 20: B2B-Bestand = 0 (D2C hat Priorität)
{% endcomment %}

{% assign sicherheitsreserve = 10 %}
{% assign mindestbestand_b2b = 10 %}
{% assign d2c_prioritaet_schwelle = 20 %}

{% for variant in variants_data %}
  {% assign d2c_bestand = variant.inventory_quantity | times: 1 %}
  
  {% if d2c_bestand < d2c_prioritaet_schwelle %}
    {% comment %} Wenig Bestand → D2C hat Priorität → B2B bekommt nichts {% endcomment %}
    {% assign variant["b2b_inventory"] = 0 %}
  {% else %}
    {% assign b2b_bestand = d2c_bestand | minus: sicherheitsreserve %}
    {% if b2b_bestand < mindestbestand_b2b %}
      {% assign variant["b2b_inventory"] = 0 %}
    {% else %}
      {% assign variant["b2b_inventory"] = b2b_bestand %}
    {% endif %}
  {% endif %}
{% endfor %}

Die Logik in einem Diagramm:

Bestandsberechnung für B2B-Store:

D2C-Bestand = 100 Stück
          │
          ▼
┌─────────────────────────┐
│ D2C-Bestand >= 20?      │──── Nein ──▶ B2B-Bestand = 0
│ (D2C-Prioritätsschwelle)│              (D2C wird geschützt)
└────────────┬────────────┘
             │ Ja
             ▼
┌─────────────────────────┐
│ B2B = D2C - Reserve(10) │
│ B2B = 100 - 10 = 90     │
└────────────┬────────────┘
             │
             ▼
┌─────────────────────────┐
│ B2B >= Mindestbestand?  │──── Nein ──▶ B2B-Bestand = 0
│ (Minimum: 10 Stück)     │
└────────────┬────────────┘
             │ Ja
             ▼
    B2B-Bestand = 90 ✓

Schritt 5: Daten an den B2B-Store senden

Jetzt kommt der entscheidende Teil — der HTTP-Request an den zweiten Store:

{% comment %}
  HTTP-Action: Produkt im B2B-Store erstellen oder aktualisieren
  Verwendet die Shopify Admin API des Ziel-Stores
{% endcomment %}

{% assign b2b_store_domain = "mein-kunde-b2b.myshopify.com" %}
{% assign b2b_api_version = "2025-04" %}

{% comment %} Prüfen ob Produkt bereits im B2B-Store existiert (via SKU-Lookup) {% endcomment %}
{% assign lookup_sku = src_product.variants.nodes.first.sku %}

{% comment %} GraphQL Mutation für den B2B-Store {% endcomment %}
{% capture mutation %}
  mutation ProductSync($input: ProductInput!) {
    productCreate(input: $input) {
      product {
        id
        title
      }
      userErrors {
        field
        message
      }
    }
  }
{% endcapture %}

{% comment %} Produkt-Input zusammenstellen {% endcomment %}
{% assign product_input = hash %}
{% assign product_input["title"] = src_product.title | append: " (B2B)" %}
{% assign product_input["descriptionHtml"] = src_product.descriptionHtml %}
{% assign product_input["vendor"] = src_product.vendor %}
{% assign product_input["productType"] = src_product.productType %}
{% assign product_input["tags"] = "b2b,synced-from-d2c" %}

{% comment %} HTTP Request an B2B-Store API {% endcomment %}
{% action "http" %}
  {
    "method": "POST",
    "url": "https://{{ b2b_store_domain }}/admin/api/{{ b2b_api_version }}/graphql.json",
    "headers": {
      "Content-Type": "application/json",
      "X-Shopify-Access-Token": {{ options.b2b_store_api_token__required | json }}
    },
    "body": {
      "query": {{ mutation | json }},
      "variables": {
        "input": {{ product_input | json }}
      }
    }
  }
{% endaction %}

Der Event-Viewer: Jede Ausführung wird protokolliert — perfekt für Debugging und Monitoring.

Das Ergebnis

Nach der Implementierung:

Vorher (manuell)	Nachher (Mechanic)
~4 Stunden/Tag für manuelle Synchronisierung	0 Minuten — vollautomatisch
Fehlerquote bei Preisen: ~5-10%	0% — mathematisch korrekt
Neue Produkte im B2B-Store: nach 1-2 Tagen	Unter 60 Sekunden nach Erstellung
Bestand stimmt "meistens"	Echtzeit-Sync mit intelligenter Reserve
Team frustriert, Fokus geht verloren	Team fokussiert auf Verkauf und Kunden
Kosten: ~€2.000/Monat (Personalzeit)	$29-99/Monat für Mechanic

ROI-Rechnung: €2.000 Personalkosten/Monat vs. ~€90 für Mechanic = €1.910 Ersparnis pro Monat = €22.920 pro Jahr.

Weitere Mechanic-Automatisierungen aus der Praxis

Die Multi-Store-Synchronisierung ist nur ein Beispiel. Hier sind weitere Automatisierungen, die ich bei Kundenprojekten mit Mechanic umgesetzt habe:

Automatische B2B-Preisstufen nach Kundengruppe

{% comment %}
  Wenn ein B2B-Kunde bestellt, automatisch den Rabatt
  basierend auf seinem Kunden-Tag anwenden:
  - "b2b-bronze": 10% Rabatt
  - "b2b-silber": 15% Rabatt  
  - "b2b-gold":   20% Rabatt
  - "b2b-platin": 25% Rabatt
{% endcomment %}

{% assign customer_tags = order.customer.tags | split: ", " %}

{% assign discount_percent = 0 %}
{% for tag in customer_tags %}
  {% case tag %}
    {% when "b2b-platin" %}
      {% assign discount_percent = 25 %}
    {% when "b2b-gold" %}
      {% assign discount_percent = 20 %}
    {% when "b2b-silber" %}
      {% assign discount_percent = 15 %}
    {% when "b2b-bronze" %}
      {% assign discount_percent = 10 %}
  {% endcase %}
{% endfor %}

Automatischer Restock-Alert mit Bestellvorschlag

{% comment %}
  Subscription: mechanic/scheduler/daily
  Prüft jeden Morgen alle Bestände und sendet einen
  Restock-Report mit konkreten Nachbestellmengen
{% endcomment %}

{% assign low_stock_products = "" | split: "" %}
{% assign restock_threshold = 15 %}
{% assign target_stock = 100 %}

{% comment %} Alle Produktvarianten mit niedrigem Bestand finden {% endcomment %}
{% assign cursor = nil %}
{% for n in (1..50) %}
  {% capture query %}
    query {
      productVariants(
        first: 100
        after: {{ cursor | json }}
        query: "inventory_total:<={{ restock_threshold }}"
      ) {
        pageInfo { hasNextPage endCursor }
        nodes {
          id sku displayName
          inventoryQuantity
          product { title vendor }
        }
      }
    }
  {% endcapture %}
  
  {% assign result = query | shopify %}
  {% assign variants = result.data.productVariants.nodes %}
  
  {% for variant in variants %}
    {% assign reorder_qty = target_stock | minus: variant.inventoryQuantity %}
    {% assign item = hash %}
    {% assign item["product"] = variant.product.title %}
    {% assign item["variant"] = variant.displayName %}
    {% assign item["sku"] = variant.sku %}
    {% assign item["current_stock"] = variant.inventoryQuantity %}
    {% assign item["reorder_quantity"] = reorder_qty %}
    {% assign item["vendor"] = variant.product.vendor %}
    {% assign low_stock_products = low_stock_products | push: item %}
  {% endfor %}
  
  {% unless result.data.productVariants.pageInfo.hasNextPage %}
    {% break %}
  {% endunless %}
  {% assign cursor = result.data.productVariants.pageInfo.endCursor %}
{% endfor %}

{% if low_stock_products.size > 0 %}
  {% action "email" %}
    {
      "to": "einkauf@mein-kunde.de",
      "subject": "⚠️ Restock-Alert: {{ low_stock_products.size }} Produkte nachbestellen",
      "body": "Folgende Produkte müssen nachbestellt werden: ..."
    }
  {% endaction %}
{% endif %}

SKU-basierte Fulfillment-Routing

{% comment %}
  Bestellungen automatisch an den richtigen Fulfillment-Partner
  weiterleiten, basierend auf der SKU-Prefix:
  - "DE-" → Deutsches Lager
  - "EU-" → EU-Zentrallager  
  - "US-" → US-Fulfillment via ShipBob
{% endcomment %}

{% for line_item in order.line_items %}
  {% assign sku = line_item.sku %}
  
  {% if sku contains "DE-" %}
    {% assign fulfillment_location = "Deutsches Lager" %}
    {% assign notify_email = "lager-de@mein-kunde.de" %}
  {% elsif sku contains "EU-" %}
    {% assign fulfillment_location = "EU-Zentrallager" %}
    {% assign notify_email = "lager-eu@mein-kunde.de" %}
  {% elsif sku contains "US-" %}
    {% assign fulfillment_location = "US Fulfillment (ShipBob)" %}
    {% assign notify_email = "fulfillment@shipbob-partner.com" %}
  {% endif %}
  
  {% comment %} Benachrichtigung an das richtige Lager {% endcomment %}
  {% action "email" %}
    {
      "to": {{ notify_email | json }},
      "subject": "Neue Bestellung #{{ order.name }} - {{ fulfillment_location }}",
      "body": "Bitte erfüllen: {{ line_item.title }} ({{ line_item.quantity }}x)"
    }
  {% endaction %}
{% endfor %}

Pricing: Was kostet Mechanic?

Mechanic nutzt das "Pay what feels good"-Modell von Lightward — mit empfohlenen Preisen basierend auf Ihrem Shopify-Plan:

Shopify-Plan	Empfohlener Preis	Jährliche Kosten
Basic Shopify	$16/Monat	$192/Jahr
Grow Shopify	$29/Monat	$348/Jahr
Advanced Shopify	$99/Monat	$1.188/Jahr
Shopify Plus	$199/Monat	$2.388/Jahr

Wichtig:

✅ Keine zusätzlichen Nutzungsgebühren — egal wie viele Tasks, Events oder Actions
✅ 15 Tage kostenloser Test — genug Zeit, um den Wert zu erkennen
✅ Alle Features in jedem Plan — keine Feature-Gating-Tricks
✅ Unbegrenzte Tasks — installieren Sie so viele wie Sie brauchen

Kosten-Vergleich: Mechanic vs. Alternativen

Für einen typischen Mittelstands-Händler mit den Anforderungen Auto-Tagging + Inventory Sync + Order Automation + Reporting + Multi-Store-Sync:

Lösung	Monatliche Kosten	Setup-Kosten	Wartung
5+ einzelne Apps	$300-500/Monat	$0-500	Hoch (5 Dashboards)
Zapier Business	$200-400/Monat	$0	Mittel (fragil)
Custom App	$200-500/Monat (Hosting)	$15.000-50.000	Hoch (eigene Infra)
Mechanic	$29-199/Monat	$0-5.000 (Konfiguration)	Niedrig (gehostet)

Mehr über die Kosten von Plugin-Stacking lesen Sie in meinem Artikel: 10 Prozesse, die kein Plugin automatisieren kann

Installation und erste Schritte

Mechanic installieren

App Store öffnen: Gehen Sie zu apps.shopify.com/mechanic
Installieren: Klicken Sie auf "Install" und autorisieren Sie die App
Dashboard öffnen: Nach der Installation finden Sie Mechanic in Ihrem Shopify-Admin unter "Apps"

Task-Konfiguration: Die meisten Library-Tasks haben benutzerfreundliche Optionsfelder.

Ersten Task aus der Bibliothek installieren

Klicken Sie auf "Library" im Mechanic-Dashboard
Suchen Sie nach dem gewünschten Task (z.B. "auto-tag orders")
Klicken Sie auf "Try this task"
Konfigurieren Sie die Optionen (z.B. welcher Tag gesetzt werden soll)
Aktivieren — fertig!

Die meisten Library-Tasks funktionieren sofort. Sie brauchen keinerlei Coding-Kenntnisse für Standard-Automatisierungen.

Eigenen Task schreiben

Für Custom-Automatisierungen:

Klicken Sie auf "New Task"
Geben Sie einen Namen ein
Tragen Sie die Subscriptions ein (z.B. shopify/orders/create)
Schreiben Sie Ihren Liquid-Code
Nutzen Sie den Preview-Button zum Testen
Aktivieren

Tipp: Starten Sie mit einem Library-Task, der Ihrem Ziel nahekommt, und passen Sie den Code an. Das ist deutlich einfacher als von Null zu starten.

Wann Sie einen Mechanic-Experten brauchen

Mechanic ist mächtig — aber nicht jede Automatisierung ist trivial. Für diese Szenarien empfehle ich professionelle Unterstützung:

Selbst machbar (Library-Tasks):

✅ Auto-Tagging von Bestellungen, Kunden, Produkten
✅ E-Mail-Benachrichtigungen bei bestimmten Events
✅ Einfache Bestandsüberwachung und Alerts
✅ Zeitgesteuerte Reports per E-Mail
✅ Produkte automatisch ein-/ausblenden

Experte empfohlen:

🔧 Multi-Store-Synchronisierung (wie im Praxisbeispiel)
🔧 Komplexe Preisberechnungen und Transformationen
🔧 ERP/WaWi-Integration über HTTP-Actions
🔧 Custom Fulfillment-Workflows mit mehreren Locations
🔧 Datenmigrationen und Bulk-Operationen
🔧 Fehlerbehandlung und Retry-Logik

Custom App nötig:

⚙️ Eigene UI im Shopify-Admin (App Blocks, Admin Extensions)
⚙️ Checkout-Modifikationen (Shopify Functions)
⚙️ Storefront-Integration (Theme-Erweiterungen)
⚙️ Echtzeit-Dashboard mit eigenem Frontend
⚙️ Große Datenmengen aggregieren (Quartalsberichte über tausende Bestellungen)

Ehrliche Grenzen: Wo Mechanic an die Wand fährt — ein Praxisbeispiel

Ich bin ein großer Mechanic-Fan — das haben Sie in diesem Artikel gemerkt. Aber genau deshalb ist es mir wichtig, ehrlich über die Grenzen zu sprechen. Denn ich habe sie selbst erlebt.

Der Auftrag: Quartals-Reporting über alle Bestellungen

Ein Kunde brauchte eine automatisierte Quartalsübersicht — eine detaillierte Auswertung sämtlicher Bestellungen eines Quartals. Keine einfache Summe, sondern eine aufgeschlüsselte Analyse: Umsatz pro Produktkategorie, Retourenquoten, durchschnittlicher Warenkorbwert, Versandkosten-Auswertung, Kundengruppen-Analyse, Rabatt-Effektivität und mehr.

Mein erster Gedanke: "Das mache ich mit Mechanic. Scheduler-Event am Quartalsende, alle Orders durchpaginieren, Daten aggregieren, Report generieren. Kenne ich."

Was passiert ist

Das Problem wurde schnell klar: Der Store hatte mehrere tausend Bestellungen pro Quartal. Mechanic arbeitet Event-basiert mit Run Queues — jeder Task-Run hat ein Zeitlimit und verarbeitet Daten sequenziell über die Shopify API. Die Shopify API liefert maximal 250 Objekte pro Request, und bei jedem Request greift das API Rate Limit.

Quartals-Orders: ~8.000 Bestellungen
API-Requests nötig: ~8.000 / 250 = 32 Seiten (minimum)
Pro Seite: Order-Daten + Line Items + Kunden + Rabatte
Verarbeitungszeit pro Seite: ~2-5 Sekunden
Gesamte Datenmenge: Zu groß für einen einzelnen Mechanic-Run

Ich habe alles versucht, was Mechanic hergibt:

Versuch 1: Alles in einem Task Der Task lief in ein Timeout. Die Run Queue hat die Verarbeitung abgebrochen, bevor alle Daten paginiert werden konnten. Bei ~8.000 Orders und der nötigen Aggregationslogik war der einzelne Run schlicht zu lang.

Versuch 2: Chunking mit Kind-Events Ich habe den Task aufgeteilt: Ein Parent-Task, der die Paginierung steuert und für jede Seite ein Kind-Event erzeugt. Jedes Kind-Event verarbeitet 250 Orders und speichert Zwischenergebnisse in Metafields. Ein finaler Task aggregiert die Teilergebnisse.

┌──────────────────────────────┐
│ Parent-Task (Scheduler)      │
│ "Starte Quartals-Report"     │
│                              │
│  → Kind-Event: Seite 1/32   │
│  → Kind-Event: Seite 2/32   │
│  → ...                      │
│  → Kind-Event: Seite 32/32  │
│  → Finaler Aggregations-Task │
└──────────────────────────────┘
         │
         ▼
┌──────────────────────────────┐
│ Problem:                     │
│ • Kind-Events laufen nicht   │
│   garantiert in Reihenfolge  │
│ • Zwischenergebnisse in      │
│   Metafields: 64KB Limit     │
│ • Race Conditions bei        │
│   parallelen Runs            │
│ • Fehler-Recovery extrem     │
│   komplex                    │
└──────────────────────────────┘

Das Ergebnis: Teildaten gingen verloren, die Reihenfolge stimmte nicht, und wenn ein einzelnes Kind-Event fehlschlug, war der gesamte Report inkonsistent. Die Fehlerbehandlung und Retry-Logik wurde so komplex, dass der Mechanic-Code ungewartbar wurde.

Versuch 3: Selbstaufrufender Task mit Cursor-Pagination Ein Task, der sich selbst triggert und bei jedem Run die nächste Seite verarbeitet — den Cursor in einem Metafield speichert. Klingt clever, funktionierte auch besser, aber:

Bei 32+ selbstaufrufenden Runs häuft sich die Queue-Latenz
Jeder Run braucht einen separaten API-Call für den Cursor-Lookup
Wenn der Store zwischendurch andere Events verarbeitet, verzögert sich der Run
Gesamtdauer: 15-30 Minuten für einen einzigen Report — und selbst dann nicht zuverlässig

Warum es an Mechanic's Architektur liegt

Das ist kein Bug. Es ist ein architekturelles Limit:

Eigenschaft	Mechanic	Was der Report brauchte
Execution Model	Event-basiert, kurze Runs	Lang laufende Aggregation
Datenhaltung	Metafields (64KB Limit)	Mehrere MB Zwischendaten
Concurrency	Sequenzielle Queue	Parallele Verarbeitung
Error Recovery	Pro Run, kein State	Transaktionale Konsistenz
API-Nutzung	Geteilt mit allen Tasks	Dediziertes Rate Limit nötig

Mechanic ist gebaut für reaktive, Event-getriebene Automatisierungen: "Wenn X passiert, tue Y." Es ist nicht gebaut für analytische Batch-Verarbeitung: "Nimm alle Daten der letzten 3 Monate und berechne Z."

Die Lösung: Custom App

Am Ende habe ich eine maßgeschneiderte Node.js-Anwendung gebaut — ein dediziertes Reporting-Tool:

┌─────────────────────────────────────────────┐
│ Custom Reporting App (Node.js)              │
│                                             │
│  1. Shopify Bulk Operations API nutzen      │
│     → Exportiert ALLE Orders in einer       │
│       einzigen JSONL-Datei                  │
│     → Kein Paginierungs-Overhead            │
│     → Kein Rate-Limit-Problem               │
│                                             │
│  2. Daten lokal verarbeiten                 │
│     → Streaming-Parser für große Dateien    │
│     → Parallele Aggregation                 │
│     → Beliebig komplexe Berechnungen        │
│                                             │
│  3. Report generieren                       │
│     → PDF mit Charts und Tabellen           │
│     → CSV für Excel-Import                  │
│     → Per E-Mail an Stakeholder             │
│                                             │
│  Laufzeit: ~2-3 Minuten für 8.000+ Orders   │
│  Zuverlässigkeit: 100% (oder klarer Fehler) │
└─────────────────────────────────────────────┘

Der Schlüssel war die Shopify Bulk Operations API — ein Feature, das Mechanic auf diese Weise nicht nutzen kann. Die Bulk API exportiert tausende Ressourcen in einer einzigen Operation, ohne Paginierung und ohne Rate-Limit-Einschränkungen. Perfekt für genau diesen Anwendungsfall.

Was ich daraus gelernt habe

Mechanic ist ideal für	Custom App ist nötig für
Event → Reaction (1:1)	Batch-Verarbeitung großer Datenmengen
Echtzeit-Automatisierung	Historische Daten-Aggregation
Einzelne Orders/Produkte verarbeiten	Tausende Objekte auf einmal analysieren
Kurze, fokussierte Tasks	Lang laufende Berechnungen
Webhooks und Scheduler	Bulk Operations API

Die ehrliche Empfehlung: Mechanic für 95% Ihrer Automatisierungen. Für die restlichen 5% — wenn es um große Datenmengen, komplexes Reporting oder Bulk-Operationen geht — brauchen Sie eine Custom-Lösung. Und genau dieses Wissen, wann welches Tool das richtige ist, macht den Unterschied zwischen einem guten und einem großartigen Shopify-Entwickler.

Wenn Sie nicht sicher sind, ob Mechanic für Ihren Anwendungsfall reicht oder ob eine Custom App nötig ist — fragen Sie mich. Ich habe beides gebaut und berate ehrlich.

Was Händler über Mechanic sagen

Aus den verifizierten Reviews im Shopify App Store:

"We've replaced several apps with just this one! I've used Mechanic for about a year now. Their huge library of pre-built tasks made it easy to get started — auto-tagging customers or orders, scheduling product publishing, sending notifications for big orders." — E-Cigarette Direct, UK

"Mechanic is our most important app for running our store — it handles all of our workflows on the backend, and helps us automate everything from sales, special events, sending orders to vendors, keeping track of preorder, backorders, inventory, and more." — Frannie's Hair, USA (seit über 2 Jahren)

"We've used it to build and manage systems that go beyond Shopify's native functionality, including pre-ordering, a rewards points program, a referral system, and a raffle system tied to real customer activity." — Veckman Designer Distillates, USA

Die durchgängige Botschaft: Mechanic ersetzt mehrere Apps gleichzeitig, ist zuverlässig im Dauerbetrieb, und die Community auf Slack ist extrem hilfsbereit.

Mechanic-Ressourcen und Community

Ressource	Link	Beschreibung
App Store	apps.shopify.com/mechanic	Installation und Reviews
Task Library	tasks.mechanic.dev	360+ vorgefertigte Tasks
Dokumentation	learn.mechanic.dev	Vollständige Entwickler-Docs
Slack Community	Via learn.mechanic.dev	Hilfe von der Community
GitHub	github.com/lightward/mechanic-tasks	Open-Source Task-Code
Lightward (Entwickler)	lightward.com	Über das Team

Fazit: Für wen ist Mechanic die richtige Wahl?

Mechanic ist für Sie, wenn:

✅ Shopify Flow nicht mehr ausreicht
✅ Sie mehrere Apps durch eine ersetzen wollen
✅ Sie Custom-Logik brauchen (Preisberechnung, Daten-Transformation)
✅ Sie Store-übergreifend arbeiten (Multi-Store, B2B + D2C)
✅ Sie externe Systeme anbinden wollen (ERP, WaWi, Fulfillment)
✅ Sie wollen, dass Automatisierungen zuverlässig 24/7 laufen
✅ Sie keinen eigenen Server betreiben wollen

Mechanic ist nicht für Sie, wenn:

❌ Shopify Flow Ihre Anforderungen abdeckt (dann nehmen Sie Flow — es ist kostenlos)
❌ Sie eine eigene UI im Shopify-Admin brauchen
❌ Sie Checkout-Funktionen modifizieren müssen
❌ Sie keine Shopify-Stores haben (Mechanic ist Shopify-exklusiv)

Mein persönliches Fazit als Shopify-Entwickler

Mechanic hat verändert, wie ich Shopify-Projekte angehe. Früher hätte ich für die Multi-Store-Synchronisierung eine Custom Node.js-App gebaut — mit eigenem Server, Datenbank, Monitoring, Deployment-Pipeline. Kosten für den Kunden: €15.000+ Entwicklung, €200+/Monat Hosting.

Mit Mechanic: 3-5 Tage Entwicklung, $29-99/Monat, keine Infrastruktur-Wartung. Das Ergebnis für den Kunden ist dasselbe — oder besser, weil Mechanic's Event-Queue zuverlässiger ist als die meisten selbstgebauten Systeme.

Wenn Sie komplexe Shopify-Automatisierungen brauchen — sei es Multi-Store-Sync, ERP-Integration oder Prozessautomatisierung — sprechen Sie mich an. Ich helfe Ihnen, die richtige Lösung zu finden, und wenn Mechanic das Tool der Wahl ist, setze ich es für Sie auf.

Tipp: Kombinieren Sie Mechanic mit meinem Wissen über ERP-Integrationen und Custom-Automatisierung für eine End-to-End-Lösung.

Haben Sie Fragen zu Mechanic oder brauchen Sie Hilfe bei einer komplexen Shopify-Automatisierung? Kontaktieren Sie mich — ich berate Sie kostenlos, ob Mechanic für Ihren Fall die richtige Lösung ist.