Zoho CRM Custom Functions: Deluge-Scripting für Einsteiger

Wenn Standard-Automatisierungen nicht reichen

Zoho CRM bringt von Haus aus starke Automatisierungswerkzeuge mit: Workflow Rules, Blueprints, Approval Processes und seit einiger Zeit auch Zia-basierte Vorschläge. Für die meisten Standard-Szenarien – eine E-Mail bei Statuswechsel verschicken, ein Feld automatisch aktualisieren, eine Aufgabe erstellen – reichen diese Tools vollkommen aus. Kein Code nötig, alles per Drag-and-Drop konfigurierbar.

Aber irgendwann kommt der Punkt, an dem du an die Grenzen dieser No-Code-Werkzeuge stößt. Vielleicht willst du einen berechneten Wert aus mehreren Feldern ableiten und in ein Custom Field schreiben. Oder du musst bei einem Phasenwechsel im Deal automatisch alle verknüpften Kontakte benachrichtigen. Oder du willst Daten aus einem externen System per API abrufen und in Zoho CRM einfließen lassen. Genau hier kommen Custom Functions ins Spiel – und damit Deluge, Zohos eigene Skriptsprache.

Die gute Nachricht: Du brauchst keinen Informatik-Abschluss, um mit Deluge zu arbeiten. Die Sprache wurde bewusst so konzipiert, dass auch Nicht-Entwickler damit umgehen können. In diesem Artikel bringe ich dir die Grundlagen bei und zeige dir vier konkrete Praxisbeispiele, die du direkt in deinem Zoho CRM nachbauen kannst.

Was ist Deluge?

Zohos eigene Skriptsprache

Deluge steht für Data Enriched Language for the Universal Grid Environment – ein sperriger Name für eine überraschend zugängliche Programmiersprache. Deluge wurde von Zoho entwickelt und ist tief in das gesamte Zoho-Ökosystem integriert. Anders als bei Python, JavaScript oder anderen allgemeinen Programmiersprachen ist Deluge speziell darauf ausgelegt, mit Zoho-Daten zu arbeiten. Das bedeutet: Du brauchst keine externe Entwicklungsumgebung, keinen Server und kein Deployment. Alles passiert direkt in Zoho.

Die Syntax ist bewusst einfach gehalten und erinnert an natürliche Sprache. Statt kryptischer Befehle schreibst du Dinge wie zoho.crm.getRecordById("Deals", dealId) oder sendmail. Die Einstiegshürde ist damit deutlich niedriger als bei klassischen Programmiersprachen.

Wo kann Deluge eingesetzt werden?

Deluge ist nicht auf einen einzigen Anwendungsfall beschränkt. In Zoho CRM kannst du die Sprache an verschiedenen Stellen einsetzen:

• Custom Functions: Das Herzstück. Skripte, die über Workflow Rules, Blueprints oder Buttons ausgelöst werden. Hier findet der Großteil der Deluge-Programmierung statt.
• Custom Buttons: Du kannst Buttons in der Detailansicht eines Records platzieren, die beim Klick eine Deluge-Funktion ausführen. Zum Beispiel: "Angebot generieren" oder "Daten synchronisieren".
• Scheduled Functions: Zeitgesteuerte Skripte, die täglich, wöchentlich oder in einem beliebigen Intervall automatisch laufen. Perfekt für Reports, Datenbereinigung oder Synchronisierungen.
• Widgets: Benutzerdefinierte UI-Elemente, die Deluge im Backend nutzen, um Daten aufzubereiten und darzustellen.

Darüber hinaus wird Deluge auch in Zoho Creator, Zoho Flow, Zoho Analytics und weiteren Zoho-Produkten verwendet. Wenn du die Sprache einmal beherrschst, kannst du sie im gesamten Zoho-Ökosystem einsetzen.

Grundlagen der Deluge-Syntax

Bevor wir in die Praxisbeispiele einsteigen, schauen wir uns die wichtigsten Sprachelemente an. Keine Sorge – das ist kein trockener Programmierkurs. Ich zeige dir nur das, was du wirklich brauchst.

Variablen und Datentypen

Variablen in Deluge werden einfach durch Zuweisung erstellt. Du musst keinen Datentyp angeben – Deluge erkennt den Typ automatisch:

// String (Text)
name = "Max Mustermann";

// Integer (Ganzzahl)
anzahl = 42;

// Decimal (Dezimalzahl)
preis = 199.99;

// Boolean (Wahr/Falsch)
istAktiv = true;

// Liste (Array)
farben = {"rot", "grün", "blau"};

// Map (Schlüssel-Wert-Paare)
kontakt = Map();
kontakt.put("Name", "Max Mustermann");
kontakt.put("Email", "max@beispiel.de");

Wichtig: Jede Anweisung in Deluge wird mit einem Semikolon ; abgeschlossen. Kommentare beginnen mit // für einzeilige oder /* ... */ für mehrzeilige Kommentare.

If/Else-Bedingungen

Bedingungen funktionieren in Deluge sehr ähnlich wie in anderen Sprachen:

dealWert = 50000;

if (dealWert > 100000)
{
    info "Enterprise Deal";
    prioritaet = "Hoch";
}
else if (dealWert > 25000)
{
    info "Mid-Market Deal";
    prioritaet = "Mittel";
}
else
{
    info "Small Business Deal";
    prioritaet = "Normal";
}

Der Befehl info ist übrigens dein bester Freund beim Debugging – er schreibt Werte in die Deluge-Konsole, sodass du nachverfolgen kannst, was dein Skript macht.

Schleifen (for each)

Wenn du über eine Liste von Datensätzen iterieren willst, nutzt du for each:

// Alle offenen Deals abrufen
offeneDeals = zoho.crm.searchRecords("Deals", "(Stage:equals:Qualification)");

for each deal in offeneDeals
{
    dealName = deal.get("Deal_Name");
    betrag = deal.get("Amount");
    info dealName + " – " + betrag + " EUR";
}

Das ist ein typisches Muster: Du holst eine Liste von Records aus dem CRM und verarbeitest jeden einzelnen in der Schleife. Damit kannst du Massenaktualisierungen durchführen, Reports erstellen oder verknüpfte Datensätze prüfen.

Listen und Maps

Listen und Maps sind die beiden wichtigsten Datenstrukturen in Deluge. Listen sind geordnete Sammlungen von Werten, Maps sind Schlüssel-Wert-Paare – ähnlich wie JSON-Objekte:

// Mit Listen arbeiten
meineListe = List();
meineListe.add("Erster Eintrag");
meineListe.add("Zweiter Eintrag");
info meineListe.size(); // Gibt 2 aus

// Mit Maps arbeiten
updateMap = Map();
updateMap.put("Stage", "Closed Won");
updateMap.put("Closing_Date", zoho.currentdate);

// Record in Zoho CRM aktualisieren
zoho.crm.updateRecord("Deals", dealId, updateMap);

Maps brauchst du ständig – insbesondere wenn du Records im CRM erstellen oder aktualisieren willst. Du baust die Map mit den Feldnamen und Werten auf und übergibst sie dann an die entsprechende CRM-Funktion.

How-to: Deine erste Custom Function erstellen

Über Setup nach Automation und Custom Functions

Der Weg zu deiner ersten Custom Function führt über das Zoho CRM Setup. Navigiere zu Setup → Automation → Actions → Custom Functions. Dort klickst du auf "Configure Custom Function" und wählst das Modul aus, für das die Funktion gelten soll (z.B. Deals, Contacts, Accounts).

Im Editor siehst du ein leeres Skriptfenster und rechts daneben eine Liste verfügbarer Argumente. Du definierst zunächst die Parameter, die dein Skript entgegennimmt – zum Beispiel die Record-ID des Datensatzes, der den Trigger ausgelöst hat. Dann schreibst du deinen Deluge-Code in das Editorfenster.

Trigger: Workflow Rule oder Button

Deine Custom Function braucht einen Auslöser. Die zwei häufigsten Optionen sind:

• Workflow Rule: Die Funktion wird automatisch ausgeführt, wenn ein bestimmtes Ereignis eintritt – z.B. ein Record wird erstellt, ein Feld wird geändert oder ein bestimmter Zeitpunkt wird erreicht. Du erstellst die Workflow Rule unter Setup → Automation → Workflow Rules und wählst als Aktion "Custom Function" aus.
• Custom Button: Die Funktion wird manuell per Klick auf einen Button in der Detailansicht ausgelöst. Ideal für Aktionen, die ein Mitarbeiter bewusst anstoßen soll, zum Beispiel "Deal an ERP übergeben" oder "Preis neu kalkulieren".

Debugging und Logs

Debugging ist bei Deluge erstaunlich komfortabel. Im Custom Function Editor gibt es einen "Execute"-Button, mit dem du dein Skript direkt testen kannst. Alle info-Anweisungen werden in der Konsole unterhalb des Editors ausgegeben. So kannst du Schritt für Schritt nachvollziehen, welche Werte deine Variablen haben und wo eventuell ein Fehler auftritt.

Zusätzlich findest du unter Setup → Developer Space → Functions eine Log-Ansicht, die dir zeigt, wann welche Custom Functions ausgeführt wurden, ob sie erfolgreich waren und welche Fehlermeldungen es gegebenenfalls gab. Nutze diese Logs intensiv – sie sind dein wichtigstes Werkzeug bei der Fehlersuche.

Praxisbeispiel 1: Automatische Berechnung eines gewichteten Deal-Werts

Starten wir mit einem einfachen, aber enorm nützlichen Beispiel. In vielen Vertriebsteams arbeitet man mit dem gewichteten Pipeline-Wert: der Deal-Betrag multipliziert mit der Abschlusswahrscheinlichkeit. Zoho CRM bietet diese Berechnung nicht nativ als eigenes Feld an – aber mit einer Custom Function ist sie in wenigen Minuten eingerichtet.

Ziel: Wenn sich der Betrag oder die Wahrscheinlichkeit eines Deals ändert, soll automatisch ein Custom Field "Gewichteter Wert" berechnet und aktualisiert werden.

Voraussetzung: Erstelle zunächst ein Custom Field vom Typ "Currency" mit dem Namen "Gewichteter_Wert" im Deals-Modul.

// Parameter: dealId (vom Workflow übergeben)
dealDetails = zoho.crm.getRecordById("Deals", dealId);

dealValue = ifnull(dealDetails.get("Amount"), 0);
probability = ifnull(dealDetails.get("Probability"), 0);

// Gewichteten Wert berechnen
gewichteterWert = dealValue * probability / 100;

// Ergebnis in Custom Field schreiben
updateMap = Map();
updateMap.put("Gewichteter_Wert", gewichteterWert);

zoho.crm.updateRecord("Deals", dealId, updateMap);

info "Deal: " + dealDetails.get("Deal_Name");
info "Gewichteter Wert: " + gewichteterWert;

Das war's. Erstelle eine Workflow Rule, die bei Erstellung und Bearbeitung eines Deals triggert, und verknüpfe diese Custom Function als Aktion. Ab sofort wird der gewichtete Wert automatisch berechnet und in deinem Dashboard oder deinen Reports nutzbar.

Was hier passiert: Die Funktion holt sich den Deal-Datensatz über die ID, liest den Betrag und die Wahrscheinlichkeit aus, berechnet den gewichteten Wert und schreibt ihn zurück in den Deal. Die ifnull-Funktion stellt sicher, dass auch bei leeren Feldern kein Fehler auftritt, sondern mit 0 gerechnet wird.

Praxisbeispiel 2: Verwandte Datensätze aktualisieren

Eines der häufigsten Szenarien in der CRM-Automatisierung: Du willst nicht nur den aktuellen Datensatz bearbeiten, sondern auch verknüpfte Records aktualisieren. Zum Beispiel: Wenn ein Account auf "Inaktiv" gesetzt wird, sollen alle offenen Deals dieses Accounts automatisch auf "Closed Lost" gesetzt werden.

// Parameter: accountId (vom Workflow übergeben)
accountDetails = zoho.crm.getRecordById("Accounts", accountId);
accountStatus = accountDetails.get("Account_Status");

if (accountStatus == "Inaktiv")
{
    // Alle Deals dieses Accounts abrufen
    deals = zoho.crm.getRelatedRecords("Deals", "Accounts", accountId);

    zaehler = 0;

    for each deal in deals
    {
        currentStage = deal.get("Stage");

        // Nur offene Deals aktualisieren
        if (currentStage != "Closed Won" && currentStage != "Closed Lost")
        {
            updateMap = Map();
            updateMap.put("Stage", "Closed Lost");
            updateMap.put("Reason_for_Loss", "Account inaktiv");

            dealId = deal.get("id");
            zoho.crm.updateRecord("Deals", dealId, updateMap);
            zaehler = zaehler + 1;
        }
    }

    info zaehler + " Deals wurden auf 'Closed Lost' gesetzt.";
}

Dieses Beispiel zeigt eine wichtige Deluge-Funktion: zoho.crm.getRelatedRecords. Damit kannst du alle verknüpften Datensätze eines bestimmten Records abrufen. Die Schleife iteriert dann über jeden Deal und prüft, ob er noch offen ist. Nur offene Deals werden aktualisiert – bereits abgeschlossene bleiben unberührt.

Solche kaskadierende Aktualisierungen sparen enorm viel manuelle Arbeit. Stell dir vor, ein Account hat 15 offene Deals und ein Mitarbeiter müsste jeden einzeln auf "Closed Lost" setzen. Mit dieser Custom Function passiert das automatisch in Sekunden.

Praxisbeispiel 3: Externe API aufrufen

Hier wird es richtig spannend: Deluge kann mit externen Systemen kommunizieren. Mit dem invokeurl-Befehl sendest du HTTP-Requests an beliebige APIs, empfängst die Antwort und verarbeitest sie direkt in Zoho CRM. Das öffnet die Tür zu unzähligen Integrationen – ohne Middleware wie Zapier oder Make.

Beispiel: Du willst beim Anlegen eines neuen Leads automatisch die Firmendaten über eine externe API anreichern (z.B. Firmenname, Branche, Mitarbeiterzahl).

// Parameter: leadId (vom Workflow übergeben)
leadDetails = zoho.crm.getRecordById("Leads", leadId);
firmenDomain = leadDetails.get("Website");

if (firmenDomain != null && firmenDomain != "")
{
    // Externe API aufrufen
    apiUrl = "https://api.beispiel-enrichment.de/v1/company";

    headerMap = Map();
    headerMap.put("Authorization", "Bearer DEIN_API_KEY");
    headerMap.put("Content-Type", "application/json");

    paramMap = Map();
    paramMap.put("domain", firmenDomain);

    response = invokeurl
    [
        url: apiUrl
        type: GET
        parameters: paramMap
        headers: headerMap
    ];

    info "API Response: " + response;

    // JSON-Response parsen
    if (response.get("status") == "success")
    {
        companyData = response.get("data");

        updateMap = Map();
        updateMap.put("Industry", companyData.get("industry"));
        updateMap.put("No_of_Employees", companyData.get("employee_count"));
        updateMap.put("Annual_Revenue", companyData.get("revenue"));
        updateMap.put("Description", companyData.get("description"));

        zoho.crm.updateRecord("Leads", leadId, updateMap);
        info "Lead erfolgreich angereichert.";
    }
    else
    {
        info "API-Anreicherung fehlgeschlagen: " + response.get("message");
    }
}

Der invokeurl-Befehl ist eines der mächtigsten Werkzeuge in Deluge. Du kannst damit GET-, POST-, PUT- und DELETE-Requests senden, Header und Parameter definieren und die JSON-Response direkt als Map verarbeiten. Damit integrierst du im Prinzip jede REST-API direkt in Zoho CRM.

Beachte dabei: Für externe API-Aufrufe benötigst du gegebenenfalls eine Verbindung (Connection) in Zoho, insbesondere wenn OAuth-Authentifizierung im Spiel ist. Diese Connections verwaltest du unter Setup → Developer Space → Connections.

Praxisbeispiel 4: Automatische Aufgabenerstellung bei Phasenwechsel

Ein klassisches Vertriebsszenario: Wenn ein Deal in eine neue Phase wechselt, sollen automatisch die passenden Aufgaben für den zuständigen Vertriebsmitarbeiter erstellt werden. Zum Beispiel: Wechselt ein Deal in die Phase "Proposal", soll automatisch eine Aufgabe "Angebot erstellen" mit Fälligkeitsdatum in drei Tagen angelegt werden.

// Parameter: dealId (vom Workflow übergeben)
dealDetails = zoho.crm.getRecordById("Deals", dealId);
aktuellePhase = dealDetails.get("Stage");
dealName = dealDetails.get("Deal_Name");
ownerId = dealDetails.get("Owner").get("id");

// Aufgaben je nach Phase definieren
aufgaben = List();

if (aktuellePhase == "Proposal/Price Quote")
{
    aufgabe = Map();
    aufgabe.put("Subject", "Angebot erstellen für: " + dealName);
    aufgabe.put("Due_Date", zoho.currentdate.addDay(3));
    aufgabe.put("Priority", "High");
    aufgabe.put("Status", "Not Started");
    aufgaben.add(aufgabe);

    aufgabe2 = Map();
    aufgabe2.put("Subject", "Follow-up Call planen für: " + dealName);
    aufgabe2.put("Due_Date", zoho.currentdate.addDay(5));
    aufgabe2.put("Priority", "Normal");
    aufgabe2.put("Status", "Not Started");
    aufgaben.add(aufgabe2);
}
else if (aktuellePhase == "Negotiation/Review")
{
    aufgabe = Map();
    aufgabe.put("Subject", "Vertragsdetails prüfen für: " + dealName);
    aufgabe.put("Due_Date", zoho.currentdate.addDay(2));
    aufgabe.put("Priority", "High");
    aufgabe.put("Status", "Not Started");
    aufgaben.add(aufgabe);
}
else if (aktuellePhase == "Closed Won")
{
    aufgabe = Map();
    aufgabe.put("Subject", "Onboarding starten für: " + dealName);
    aufgabe.put("Due_Date", zoho.currentdate.addDay(1));
    aufgabe.put("Priority", "High");
    aufgabe.put("Status", "Not Started");
    aufgaben.add(aufgabe);

    aufgabe2 = Map();
    aufgabe2.put("Subject", "Willkommensmail senden für: " + dealName);
    aufgabe2.put("Due_Date", zoho.currentdate);
    aufgabe2.put("Priority", "High");
    aufgabe2.put("Status", "Not Started");
    aufgaben.add(aufgabe2);
}

// Aufgaben erstellen und dem Deal zuweisen
for each task in aufgaben
{
    task.put("Owner", ownerId);
    task.put("What_Id", dealId);
    task.put("$se_module", "Deals");

    zoho.crm.createRecord("Tasks", task);
}

info aufgaben.size() + " Aufgabe(n) erstellt für Phase: " + aktuellePhase;

Dieses Skript zeigt, wie du phasenabhängige Logik aufbaust. Je nachdem, in welche Phase der Deal wechselt, werden unterschiedliche Aufgaben mit unterschiedlichen Prioritäten und Fälligkeitsdaten erstellt. Die Aufgaben werden automatisch dem Deal-Owner zugewiesen und mit dem Deal verknüpft.

In der Praxis kannst du dieses Muster beliebig erweitern: Aufgaben an verschiedene Personen verteilen, Benachrichtigungen verschicken, Felder im Deal aktualisieren oder sogar Einträge in anderen Modulen anlegen. Die Phasenwechsel-Automatisierung ist einer der häufigsten und wertvollsten Anwendungsfälle für Custom Functions.

Scheduled Functions: Zeitgesteuerte Automatisierungen

Nicht alle Automatisierungen sollen durch eine Benutzeraktion ausgelöst werden. Manchmal brauchst du Skripte, die regelmäßig und automatisch laufen – unabhängig davon, ob gerade jemand im CRM arbeitet. Dafür gibt es Scheduled Functions.

Du findest sie unter Setup → Automation → Schedules. Dort legst du fest, wann und wie oft die Funktion laufen soll: täglich, wöchentlich, monatlich oder in einem benutzerdefinierten Intervall.

Täglicher Report per E-Mail

Ein beliebter Use Case: Jeden Morgen eine automatische Zusammenfassung der Pipeline per E-Mail an den Vertriebsleiter senden.

// Scheduled Function: Täglicher Pipeline-Report
deals = zoho.crm.searchRecords("Deals", "(Stage:not_equal:Closed Won)and(Stage:not_equal:Closed Lost)");

gesamtWert = 0;
anzahl = 0;
reportHTML = "<h2>Täglicher Pipeline-Report</h2>";
reportHTML = reportHTML + "<table border='1' cellpadding='8'>";
reportHTML = reportHTML + "<tr><th>Deal</th><th>Phase</th><th>Betrag</th><th>Owner</th></tr>";

for each deal in deals
{
    name = deal.get("Deal_Name");
    stage = deal.get("Stage");
    amount = ifnull(deal.get("Amount"), 0);
    owner = deal.get("Owner").get("name");

    reportHTML = reportHTML + "<tr><td>" + name + "</td><td>" + stage + "</td><td>" + amount + " EUR</td><td>" + owner + "</td></tr>";
    gesamtWert = gesamtWert + amount;
    anzahl = anzahl + 1;
}

reportHTML = reportHTML + "</table>";
reportHTML = reportHTML + "<p><strong>Gesamt: " + anzahl + " offene Deals im Wert von " + gesamtWert + " EUR</strong></p>";

sendmail
[
    from: zoho.adminuserid
    to: "vertriebsleiter@beispiel.de"
    subject: "Pipeline-Report vom " + zoho.currentdate
    message: reportHTML
];

Datenbereinigung: Alte Leads archivieren

Ein weiterer klassischer Anwendungsfall: Leads, die seit mehr als 90 Tagen nicht bearbeitet wurden, automatisch als "Archiviert" markieren.

// Scheduled Function: Alte Leads archivieren
grenzDatum = zoho.currentdate.subDay(90);
grenzDatumStr = grenzDatum.toString("yyyy-MM-dd");

alteLeads = zoho.crm.searchRecords("Leads", "(Modified_Time:before:" + grenzDatumStr + ")and(Lead_Status:not_equal:Archiviert)and(Lead_Status:not_equal:Converted)");

zaehler = 0;

for each lead in alteLeads
{
    leadId = lead.get("id");
    updateMap = Map();
    updateMap.put("Lead_Status", "Archiviert");

    zoho.crm.updateRecord("Leads", leadId, updateMap);
    zaehler = zaehler + 1;
}

info zaehler + " Leads archiviert (älter als 90 Tage).";

Scheduled Functions sind ein mächtiges Werkzeug, um dein CRM dauerhaft sauber und aktuell zu halten. Denke an regelmäßige Datenqualitätschecks, automatische Erinnerungen oder Synchronisierungen mit externen Systemen. Einmal eingerichtet, laufen sie zuverlässig im Hintergrund.

Best Practices und Limits

Deluge gibt dir viel Freiheit – aber mit Freiheit kommt Verantwortung. Hier sind die wichtigsten Best Practices, die du von Anfang an beherzigen solltest:

API-Limits und Credits

Jeder Zoho CRM Plan hat API-Limits. Jeder zoho.crm.getRecordById-, zoho.crm.searchRecords- oder zoho.crm.updateRecord-Aufruf verbraucht API-Credits. Bei der Professional Edition sind es 20.000 Credits pro Tag und Organisation. Klingt viel, kann aber bei schlecht geschriebenen Skripten schnell aufgebraucht sein.

Achte darauf, API-Aufrufe effizient zu gestalten. Statt in einer Schleife einzelne Records abzurufen, nutze zoho.crm.searchRecords mit Filtern, um mehrere Records auf einmal zu holen. Und vermeide unnötige Aufrufe – wenn du einen Record bereits abgerufen hast, speichere ihn in einer Variable, statt ihn erneut abzufragen.

Fehlerbehandlung mit try/catch

In produktiven Custom Functions solltest du immer mit Fehlerbehandlung arbeiten. Deluge unterstützt try/catch-Blöcke:

try
{
    dealDetails = zoho.crm.getRecordById("Deals", dealId);
    // ... weitere Logik
}
catch (e)
{
    info "Fehler aufgetreten: " + e;
    // Optional: Fehler-Benachrichtigung senden
    sendmail
    [
        from: zoho.adminuserid
        to: "admin@beispiel.de"
        subject: "Custom Function Fehler"
        message: "Fehler in Deal-Funktion: " + e
    ];
}

Ohne Fehlerbehandlung bricht dein Skript bei einem unerwarteten Fehler einfach ab – und du erfährst es möglicherweise nicht einmal. Mit try/catch kannst du Fehler abfangen, loggen und gegebenenfalls eine Benachrichtigung versenden.

Code-Organisation und Kommentare

Auch wenn Deluge-Skripte oft nur 20 bis 50 Zeilen lang sind, lohnt es sich, sauber zu arbeiten:

• Kommentiere deinen Code. Auch wenn dir die Logik heute glasklar erscheint – in sechs Monaten wirst du dankbar sein, wenn du Kommentare hast, die erklären, warum du etwas so und nicht anders gemacht hast.
• Verwende sprechende Variablennamen. gw sagt nichts, gewichteterWert sagt alles.
• Halte Funktionen fokussiert. Eine Custom Function sollte eine klar definierte Aufgabe erfüllen. Wenn dein Skript zu komplex wird, überlege, ob du es in mehrere Funktionen aufteilen kannst.
• Teste gründlich. Nutze den "Execute"-Button im Editor mit verschiedenen Test-Datensätzen. Teste auch Randfälle: Was passiert, wenn ein Feld leer ist? Was passiert, wenn kein verwandter Datensatz existiert?
• Dokumentiere deine Functions. Halte eine einfache Liste aller aktiven Custom Functions, was sie tun und welche Workflows sie triggern. Wenn du das Unternehmen verlässt oder neue Kollegen einarbeitest, wird dir das die Arbeit massiv erleichtern.

Von hier aus weiter: Dein Einstieg in Deluge

Mit den Grundlagen und vier Praxisbeispielen hast du jetzt alles, was du brauchst, um deine ersten eigenen Custom Functions zu schreiben. Mein Rat: Fang klein an. Nimm dir ein konkretes Problem in deinem Zoho CRM – eine repetitive Aufgabe, eine fehlende Berechnung, eine manuelle Aktualisierung, die immer wieder vergessen wird – und löse es mit einer einfachen Custom Function.

Die offizielle Zoho Deluge Dokumentation ist übrigens hervorragend und sollte dein ständiger Begleiter sein. Dort findest du alle Befehle, Funktionen und Methoden mit Beispielen erklärt.

Und wenn du merkst, dass du an einem Punkt nicht weiterkommst oder ein komplexeres Automatisierungsprojekt planst – meld dich gerne. Genau solche Projekte sind mein Tagesgeschäft bei Anubis Analytics: Zoho CRM implementieren, konfigurieren und mit Custom Functions auf das nächste Level heben.