Blog

Vom Angebot zur Einkaufsliste: Prozesse im Gastgewerbe mit Zoho intelligent automatisieren

Stell Dir vor, Du hast mehrere Angebote erfolgreich in Aufträge umgewandelt – super! Aber jetzt beginnt oft erst die eigentliche Arbeit: Was genau muss für die kommende Woche produziert oder eingekauft werden? Gerade in Branchen wie Catering, Eventmanagement oder kleiner Produktion, wo individuelle Aufträge mit spezifischen Rezepturen zusammenkommen, wird die Bedarfsplanung schnell komplex. Wie konsolidierst Du effizient die benötigten Zutaten oder Rohmaterialien aus Dutzenden von Bestellungen, ohne Stunden in Tabellen zu verbringen oder Fehler zu riskieren? Genau hier setzt dieser Artikel an.

Wir zeigen Dir, wie Du mit Bordmitteln von Zoho – insbesondere durch die geschickte Kombination verschiedener Apps wie Zoho CRM, Zoho Products und benutzerdefinierten Funktionen (Deluge) – sowie durch die Anbindung externer Systeme über APIs und Webhooks, eine automatisierte und sogar digital anpassbare Einkaufs- oder Produktionsliste erstellen kannst. Wir verzichten bewusst auf Marketing-Blabla und konzentrieren uns auf einen konkreten, nachvollziehbaren Lösungsweg, den Du für Dein Unternehmen adaptieren kannst.

Praxisbeispiel: Die Herausforderung der konsolidierten Einkaufsliste

Nehmen wir ein Catering-Unternehmen als Beispiel. Über Zoho CRM werden Angebote erstellt – vielleicht sogar KI-gestützt mit Hilfe von Diensten wie ChatGPT zur Mengen- und Speisenauswahl – und nach Annahme durch den Kunden in Aufträge (Sales Orders) umgewandelt. Jeder Auftrag enthält verschiedene Gerichte für ein bestimmtes Event-Datum.

Die Herausforderung: Für die Planung der nächsten Woche muss das Küchenteam wissen, wie viele Kilogramm Reis, wie viele Liter Sojasauce oder wie viele Stück Hähnchenbrust insgesamt über alle Aufträge in diesem Zeitraum benötigt werden. Manuell bedeutet das: Alle Aufträge durchgehen, die bestellten Gerichte notieren, die Rezepturen für jedes Gericht nachschlagen, die Zutatenmengen pro Auftrag hochrechnen und dann alles zu einer Gesamtliste addieren. Dieser Prozess ist nicht nur zeitaufwendig, sondern auch extrem fehleranfällig.

Das Ziel ist eine automatisierte Lösung, die:

• Alle relevanten Aufträge für einen definierten Zeitraum (z.B. nächste Kalenderwoche) berücksichtigt.
• Die bestellten Gerichte (Produkte) erkennt.
• Auf hinterlegte Rezepturen (Zutatenlisten pro Gericht) zugreift.
• Die benötigten Gesamtmengen aller Zutaten berechnet.
• Diese Mengen in einer übersichtlichen Liste darstellt, idealerweise gruppiert nach bevorzugtem Lieferanten.
• Bonus: Die Liste soll digital einsehbar und anpassbar sein, um z.B. vorhandenen Lagerbestand zu berücksichtigen, bevor bestellt wird.

Schritt-für-Schritt Anleitung zur automatisierten Einkaufsliste in Zoho

Hier zeigen wir Dir einen Weg, wie Du diese Herausforderung mit Zoho-Mitteln lösen kannst. Wir nutzen dabei Zoho CRM (oder Zoho Books) für die Aufträge, Zoho Products für die Rezepturen und eine Custom Function (Deluge) für die Logik, sowie optional ein Custom Module oder Zoho Creator für die Darstellung und Anpassung.

Schritt 1: Rezepturen in Zoho Products hinterlegen

Die Basis für jede automatisierte Berechnung sind strukturierte Daten. Deine Rezepturen müssen digital im System verfügbar sein.

1. Nutze das Zoho Products Modul: Jedes Deiner Gerichte oder Endprodukte sollte als eigener Datensatz im Modul „Produkte“ (oder „Items“ in Books/Inventory) angelegt sein.
2. Erstelle eine Subform für Zutaten: Füge dem Produkte-Modul eine Subform hinzu (z.B. „Zutatenliste“). Diese Subform sollte mindestens folgende Felder enthalten:
   • Zutat: Ein Textfeld für den Namen der Zutat oder – besser – ein Lookup-Feld zu einem eigenen Custom Module „Zutaten“, falls Du Zutaten zentral verwalten willst.
   • Menge: Eine Zahl (Dezimal) für die benötigte Menge pro Basis-Einheit des Produkts (z.B. Menge pro Portion, pro Stück, pro kg).
   • Einheit: Ein Dropdown- oder Textfeld für die Einheit (z.B. kg, g, l, ml, Stück). Achte auf Konsistenz!
   • Bevorzugter Lieferant (Optional): Ein Textfeld oder Lookup zu einem Lieferanten-Modul (z.B. Vendors/Lieferanten).
3. Befülle die Daten: Pflege nun für jedes Produkt (Gericht) die entsprechenden Zutaten mit Mengen und Einheiten in der Subform ein. Das ist initialer Aufwand, aber die Grundlage für alles Weitere.

Schritt 2: Aufträge korrekt erfassen

Stelle sicher, dass Deine Aufträge (Sales Orders in Zoho CRM oder Zoho Books) alle notwendigen Informationen enthalten:

• Die bestellten Produkte (die aus Schritt 1).
• Die korrekte Menge jedes Produkts.
• Ein relevantes Datum, nach dem Du filtern kannst (z.B. Lieferdatum, Event-Datum, Produktionsdatum). Lege hierfür ggf. ein Custom Field im Sales Order Modul an, falls das Standard-Lieferdatum nicht passt.

Die Umwandlung von Angeboten (Quotes) in Aufträge ist Standardfunktionalität in Zoho CRM/Books. Achte darauf, dass Deine Nummernkreise für Auftragsbestätigungen sinnvoll konfiguriert sind, um Kollisionen mit anderen Systemen (wie z.B. LexOffice für die Buchhaltung) zu vermeiden. Dies kannst Du in den Modul-Einstellungen anpassen.

Schritt 3: Daten konsolidieren mit einer Custom Function (Deluge)

Jetzt kommt die Magie ins Spiel. Wir brauchen eine Logik, die die Aufträge durchgeht, die Produkte und deren Zutaten ausliest und die Mengen summiert. Eine Custom Function, die z.B. täglich oder wöchentlich automatisch läuft (Scheduled Function) oder manuell ausgelöst wird, ist hierfür ideal.

Die Logik der Funktion (vereinfacht):

1. Definiere den relevanten Zeitraum (z.B. die nächste Woche).
2. Suche alle Aufträge (Sales Orders), deren Liefer-/Event-Datum in diesem Zeitraum liegt und die einen bestimmten Status haben (z.B. „Bestätigt“).
3. Iteriere durch jeden gefundenen Auftrag und dessen Auftragspositionen (Line Items).
4. Für jede Auftragsposition:
   • Hole die bestellte Menge des Produkts.
   • Hole den zugehörigen Produktdatensatz aus dem Produkte-Modul.
   • Greife auf die Subform „Zutatenliste“ dieses Produkts zu.
   • Iteriere durch jede Zutat in der Subform:
     • Berechne die benötigte Menge dieser Zutat für diesen Auftragsposten (Menge aus Subform * Bestellte Menge des Produkts).
     • Addiere diese Menge zu einer Gesamtsumme für diese Zutat (über alle Aufträge hinweg). Verwende hierfür am besten eine Map in Deluge, die Zutatennamen (oder IDs) als Schlüssel und die Gesamtmenge als Wert speichert. Achte auf die Einheiten!
5. Speichere die Ergebnisse (aggregierte Zutatenliste) in einem Custom Module oder übergebe sie an einen anderen Prozess.

Diese Funktion kann komplex werden, besonders wenn Einheitenumrechnungen (g in kg etc.) nötig sind. Zoho Analytics wäre eine Alternative, um solche Daten zu aggregieren, bietet aber weniger Flexibilität für die *direkte Weiterverarbeitung* oder digitale Anpassung der Liste im nächsten Schritt.

Schritt 4: Die konsolidierte Einkaufsliste bereitstellen (Custom Module / Zoho Creator)

Die berechneten Gesamtmengen müssen nun nutzbar gemacht werden.

• Option A: Custom Module: Erstelle ein Custom Module in Zoho CRM (z.B. „Wöchentlicher Einkaufsbedarf“). Die Deluge-Funktion aus Schritt 3 schreibt die Ergebnisse hier hinein. Felder könnten sein: `Zutat`, `Gesamtmenge`, `Einheit`, `Lieferant`, `Bedarfswoche`, `Status` (z.B. „Offen“, „Bestellt“). Du kannst dann Ansichten erstellen, die nach Lieferant oder Status gruppiert sind.
• Option B: Zoho Creator App: Für eine bessere User Experience, insbesondere für die geforderte digitale Anpassbarkeit (Mengen ändern, Positionen streichen basierend auf Lagerbestand), kannst Du eine kleine App mit Zoho Creator bauen. Diese App liest die Daten aus dem Custom Module (oder direkt aus den Berechnungen), stellt sie in einer editierbaren Tabelle dar und speichert die Änderungen zurück. Dies ähnelt der Idee, die Daten in editierbare Felder zu schreiben, wie es bei der KI-Angebotsfunktion erwähnt wurde.

Die digitale Anpassung ist der Knackpunkt: Hier muss die Creator App oder eine sehr clevere Custom-Module-Ansicht es erlauben, die berechnete `Gesamtmenge` zu überschreiben oder eine zusätzliche Spalte `Bestellmenge` einzuführen, die initial mit der `Gesamtmenge` befüllt und dann angepasst wird.

Schritt 5: Integration externer Systeme und Prozesse

Zoho glänzt durch seine Offenheit. Nutze sie!

• Lieferanten-APIs: Hat Dein Großhändler eine Bestell-API? Perfekt! Du könntest aus Deiner finalisierten Einkaufsliste (im Custom Module oder Creator App) per Knopfdruck (Custom Button mit Deluge-Skript) die Bestellung direkt via API an den Lieferanten senden.
• Webhooks: Wenn eine Einkaufsliste finalisiert oder bestellt wird, könntest Du einen Webhook auslösen, der eine Nachricht an einen Slack-Kanal sendet, eine Aufgabe in Deinem Projektmanagement-Tool (z.B. Asana, Trello) erstellt oder Daten an die erwähnte externe Rezept-App sendet (falls diese eine API oder einen Webhook-Endpunkt hat).
• Buchhaltung (z.B. LexOffice): Stelle sicher, dass die Auftragsnummern synchronisiert sind oder zumindest keine Konflikte entstehen. Ggf. können Bestelldaten auch an die Buchhaltung übermittelt werden, sobald aus der Einkaufsliste eine tatsächliche Bestellung (Purchase Order in Zoho Books/Inventory) generiert wird.
• Interne Kommunikation: Informiere das Küchenteam über die finale Produktionsliste (die sich aus den Aufträgen ergibt, nicht nur die Einkaufsliste) – z.B. über eine Ansicht in Zoho CRM, eine Creator App oder eine Benachrichtigung.

Codebeispiel: Deluge Custom Function (Konzeptionell)

Hier ein stark vereinfachtes Deluge-Skript, das die Logik aus Schritt 3 skizziert. Es dient als Inspiration und muss an Deine spezifischen Modul- und Feldnamen angepasst werden.

// --- Konfiguration ---
// API-Namen Deiner Module und Felder anpassen!
salesOrderModul = "Sales_Orders";
produkteModul = "Products";
zutatenSubform = "Zutatenliste"; // API Name der Subform im Produkt
zutatFeldSubform = "Zutat";
mengeFeldSubform = "Menge";
einheitFeldSubform = "Einheit";
lieferantFeldSubform = "Bevorzugter_Lieferant"; // Optional

bedarfModul = "Woechentlicher_Einkaufsbedarf"; // Dein Custom Module
zutatFeldBedarf = "Zutat";
mengeFeldBedarf = "Gesamtmenge";
einheitFeldBedarf = "Einheit";
lieferantFeldBedarf = "Lieferant"; // Optional
wocheFeldBedarf = "Bedarfswoche"; // z.B. KWJJJJ

// --- Zeitraum definieren ---
heute = zoho.currentdate;
// Beispiel: Nächste Woche (Montag bis Sonntag)
naechsteWocheStart = heute.addWeek(1).toDate().subDay(heute.getDayOfWeek()).addDay(1); // Nächster Montag
naechsteWocheEnde = naechsteWocheStart.addDay(6);
aktuelleWoche = naechsteWocheStart.getWeekOfYear() + "" + naechsteWocheStart.getYear(); // Format KWJJJJ

// --- Aggregations-Map initialisieren ---
// Struktur: { "ZutatName|Einheit|Lieferant" : Gesamtmenge }
zutatenGesamt = Map();

// --- Relevante Aufträge holen ---
// Kriterien anpassen: Status, Datumsfeld etc.
// Beispiel: Suche nach 'Lieferdatum' im Zeitraum
criteria = "((Lieferdatum:equals:" + naechsteWocheStart + ") or (Lieferdatum:between:" + naechsteWocheStart + "," + naechsteWocheEnde + ")) and (Status:equals:Bestätigt)";
auftraege = zoho.crm.searchRecords(salesOrderModul, criteria);

// --- Aufträge und Positionen durchgehen ---
for each auftrag in auftraege
{
    auftragID = auftrag.get("id");
    auftragsPositionen = zoho.crm.getRelatedRecords("Product_Details", salesOrderModul, auftragID); // API Name der Related List prüfen!

    for each position in auftragsPositionen
    {
        produktID = position.get("product").get("id");
        bestellMengeProdukt = position.get("quantity");

        // Produktdetails inkl. Subform holen
        produktRecord = zoho.crm.getRecordById(produkteModul, produktID);
        if(produktRecord != null && produktRecord.containskKey(zutatenSubform))
        {
            zutatenListe = produktRecord.get(zutatenSubform);
            for each zutatInfo in zutatenListe
            {
                zutatName = zutatInfo.get(zutatFeldSubform);
                zutatMengeProProdukt = zutatInfo.get(mengeFeldSubform);
                zutatEinheit = zutatInfo.get(einheitFeldSubform);
                zutatLieferant = ifnull(zutatInfo.get(lieferantFeldSubform),"Unbekannt"); // Optional

                if(zutatName != null && zutatMengeProProdukt != null)
                {
                    // Benötigte Menge für diesen Auftragsposten berechnen
                    benoetigteMenge = zutatMengeProProdukt * bestellMengeProdukt;

                    // Schlüssel für die Map erstellen (eindeutig pro Zutat/Einheit/Lieferant)
                    mapKey = zutatName + "|" + zutatEinheit + "|" + zutatLieferant;

                    // Menge in der Map aktualisieren/hinzufügen
                    if(zutatenGesamt.containskKey(mapKey))
                    {
                        bisherigeMenge = zutatenGesamt.get(mapKey);
                        zutatenGesamt.put(mapKey, bisherigeMenge + benoetigteMenge);
                    }
                    else
                    {
                        zutatenGesamt.put(mapKey, benoetigteMenge);
                    }
                }
            }
        }
    }
}

// --- Ergebnisse ins Custom Module schreiben ---
// Optional: Bestehende Einträge für die Woche löschen oder updaten
// deleteResp = zoho.crm.deleteRecord(bedarfModul, recordId); // Vorsicht!

// Neue Einträge erstellen
for each mapKey in zutatenGesamt.keys()
{
    gesamtMenge = zutatenGesamt.get(mapKey);
    keyParts = mapKey.toList("|");
    zutatName = keyParts.get(0);
    zutatEinheit = keyParts.get(1);
    zutatLieferant = keyParts.get(2);

    recordData = Map();
    recordData.put(zutatFeldBedarf, zutatName);
    recordData.put(mengeFeldBedarf, gesamtMenge);
    recordData.put(einheitFeldBedarf, zutatEinheit);
    if(zutatLieferant != "Unbekannt")
    {
        recordData.put(lieferantFeldBedarf, zutatLieferant);
    }
    recordData.put(wocheFeldBedarf, aktuelleWoche);
    recordData.put("Status", "Offen"); // Initialer Status

    // Create Record in Custom Module
    createResp = zoho.crm.createRecord(bedarfModul, recordData);
    info createResp; // Logging
}

info "Einkaufsbedarf Aggregation abgeschlossen für Woche: " + aktuelleWoche;
info zutatenGesamt; // Zur Kontrolle im Debug Log

Tipps und Best Practices

• Datenqualität ist King: Die Automatisierung ist nur so gut wie die Daten dahinter. Achte penibel auf korrekte und konsistente Rezepturen, insbesondere bei den Einheiten (immer Gramm oder Kilogramm? Immer Liter oder Milliliter?).
• Einheitenumrechnung: Falls nötig, baue eine Logik zur Einheitenumrechnung in Deine Funktion ein (z.B. alles auf Basiseinheiten wie kg und l umrechnen).
• Berechtigungen prüfen: Wer darf die Rezepturen sehen und bearbeiten? Wer darf die Einkaufsliste anpassen? Nutze Zoho’s Rollen und Profile, um sicherzustellen, dass sensible Daten (wie komplette Rezepte) nur für berechtigte Personen (z.B. den Koch) sichtbar sind, während andere (z.B. Servicepersonal) vielleicht nur Allergene sehen dürfen. Blende nicht benötigte Felder oder ganze Sektionen/Module per Profil aus.
• Skalierbarkeit bedenken: Bei sehr vielen Aufträgen und Produkten kann die oben skizzierte Custom Function an Deluge Limits stoßen (z.B. Anzahl API Calls). Prüfe, ob eine Scheduled Function (die nachts läuft) oder die Nutzung von Zoho Analytics zur reinen Aggregation sinnvoller ist. Die digitale Anpassung könnte dann immer noch über Creator erfolgen, das die Analytics-Daten abruft.
• Fehlerbehandlung einbauen: Was passiert, wenn ein Produkt keine Zutaten hinterlegt hat? Was, wenn Einheiten fehlen? Baue `if`-Abfragen und `try-catch`-Blöcke in Dein Deluge-Skript ein, um Fehler abzufangen und zu protokollieren.
• Start small, iterate: Beginne mit der Grundfunktionalität (Konsolidierung der Mengen). Füge dann schrittweise Erweiterungen hinzu wie Lieferantengruppierung, digitale Anpassung und erst später die komplexere Inventarintegration.

Zusätzliche Hinweise und Ausbaumöglichkeiten

• Zoho Inventory Integration: Der logische nächste Schritt ist die Anbindung an Zoho Inventory (oder Zoho Books mit aktivierter Inventarfunktion). Die generierte Einkaufsliste könnte dann automatisch mit dem aktuellen Lagerbestand abgeglichen werden. Die Deluge-Funktion müsste den Bestand abfragen und die `Bestellmenge` entsprechend reduzieren (Bedarf – Bestand = Bestellmenge).
• Zoho Analytics für tiefere Einblicke: Nutze Zoho Analytics nicht nur zur Aggregation, sondern auch für Auswertungen: Welche Zutaten verursachen die meisten Kosten? Wie entwickelt sich der Bedarf über die Zeit? Welche Lieferanten sind am zuverlässigsten oder günstigsten (wenn Preise hinterlegt sind)?
• Zoho Creator für maßgeschneiderte UIs: Baue spezifische Oberflächen für verschiedene Rollen: Eine Einkaufs-App für das Büro, eine Produktionsliste-App für die Küche (vielleicht auf einem Tablet), eine Allergen-Check-App für das Servicepersonal.
• Erweiterte Lieferantenlogik: In Zukunft könntest Du Preise von verschiedenen Lieferanten pro Zutat hinterlegen und die Funktion so erweitern, dass sie den günstigsten auswählt oder Bestellungen auf mehrere Lieferanten aufteilt.
• Anbindung an Produktionsplanung: Die konsolidierten Daten können auch als Input für eine detailliertere Produktionsplanung dienen (Was muss wann vorbereitet werden?).

Fazit

Die Automatisierung der Einkaufs- oder Produktionsplanung auf Basis von bestätigten Aufträgen ist ein Paradebeispiel dafür, wie Du das Zoho-Ökosystem über die Grenzen einzelner Apps hinaus nutzen kannst. Durch die Kombination von Stammdatenpflege (in Zoho Products), Prozesslogik (via Deluge Custom Functions) und benutzerfreundlichen Oberflächen (Custom Modules, Zoho Creator) kannst Du signifikant Zeit sparen, Fehler reduzieren und Deine betrieblichen Abläufe optimieren.

Der Schlüssel liegt darin, die Möglichkeiten von APIs, Webhooks und der internen Verknüpfung der Zoho Suite zu verstehen und kreativ einzusetzen. Auch wenn die initiale Einrichtung Aufwand bedeutet, zahlt sich eine solche maßgeschneiderte Lösung im täglichen Betrieb schnell aus. Betrachte Dein Zoho-System nicht nur als Datenspeicher, sondern als aktive Plattform zur Automatisierung Deiner Kernprozesse – von der KI-gestützten Angebotserstellung bis zur optimierten Einkaufsliste.