Blog

Vom Engpass zur Strategie: So baust Du ein dynamisches Ressourcen-Dashboard mit Zoho Creator

Die Veränderung von Teamkapazitäten ist eine Konstante in jedem wachsenden Unternehmen. Ein Schlüsselmitarbeiter reduziert seine Stunden, ein anderer geht in Elternzeit oder ein neues Talent kommt an Bord. Solche Verschiebungen stellen oft eine Herausforderung dar: Wie behältst Du den Überblick über die verfügbaren Ressourcen? Wie stellst Du sicher, dass Projekte nicht ins Stocken geraten und die Qualität der Arbeit hoch bleibt? Die Antwort liegt nicht in komplexen Excel-Tabellen, sondern in einem intelligenten, zentralisierten System. In diesem Artikel zeigen wir Dir, wie Du mit dem Zoho-Ökosystem, insbesondere mit Zoho Creator, ein dynamisches Dashboard für Deine Kapazitäts- und Ressourcenplanung aufbaust. Wir gehen dabei über die reine Zoho-Welt hinaus und zeigen, wie Du externe Daten und APIs für eine 360-Grad-Sicht integrieren kannst.

Die typische Herausforderung: Ein personeller Engpass und seine Folgen

Stell Dir ein typisches Szenario in einem IT-Beratungs- oder Dienstleistungsunternehmen vor. Ein erfahrener Consultant, der mehrere wichtige Kundenprojekte betreut, entscheidet sich, seine wöchentliche Arbeitszeit zu reduzieren. Sofort tauchen kritische Fragen auf:

• Welche Projekte sind betroffen und wie hoch ist die tatsächliche Auslastung des Mitarbeiters in den kommenden Monaten?
• Wer im Team hat die nötige Kapazität und die Fähigkeiten, um Aufgaben zu übernehmen?
• Müssen wir einen neuen Mitarbeiter einstellen? Und wenn ja, wie integrieren wir ihn am besten? Geben wir ihm ein neues Projekt oder übergeben wir einen Bestandskunden?
• Wie stellen wir sicher, dass die Kundenzufriedenheit nicht leidet, besonders wenn ein neuer Ansprechpartner eingeführt wird?

Diese Fragen manuell zu beantworten, ist fehleranfällig und zeitintensiv. Eine datengestützte Entscheidungsgrundlage ist unerlässlich. Genau hier setzen wir an und bauen eine Lösung, die Daten aus Zoho People, Zoho Projects und Zoho CRM intelligent kombiniert.

Schritt-für-Schritt: Dein Ressourcen-Dashboard mit Zoho Creator

Unser Ziel ist ein zentrales Dashboard in Zoho Creator, das uns auf einen Blick die Kapazität jedes Teammitglieds anzeigt – unter Berücksichtigung von variablen Arbeitszeiten, Urlaub und der aktuellen Projektauslastung.

Schritt 1: Das Fundament in Zoho Creator anlegen

Zuerst benötigst Du eine Anwendung in Zoho Creator. Darin legen wir ein Formular namens „Mitarbeiter“ an. Dieses Formular dient als zentrale Stammdatentabelle für Deine Ressourcen.

Wichtige Felder im „Mitarbeiter“-Formular:

• Name: Name des Mitarbeiters (Textfeld).
• Email: E-Mail-Adresse (E-Mail-Feld), dient später als eindeutiger Schlüssel für die Verknüpfung.
• Rolle: z.B. Senior Consultant, Junior Entwickler (Dropdown).
• Monatliche Soll-Kapazität (Stunden): Ein Zahlenfeld, in das Du die vertraglich vereinbarten Monatsstunden einträgst. Dies ist der entscheidende Punkt, um auf variable Kapazitäten reagieren zu können.

Schritt 2: Abwesenheiten aus Zoho People per API integrieren

Die reine Soll-Kapazität reicht nicht. Wir müssen geplante Abwesenheiten wie Urlaub oder Krankheitstage abziehen. Diese Daten liegen idealerweise in Zoho People. Wir holen sie uns per Custom Function (Deluge) und der Zoho People API.

Erstelle eine Custom Function in Deiner Creator-Anwendung, z.B. mit dem Namen `getLeaveHours`. Diese Funktion nimmt die E-Mail des Mitarbeiters und einen Datumsbereich (z.B. den aktuellen Monat) entgegen und gibt die Summe der Abwesenheitsstunden zurück.

// Deluge Script: Custom Function "getLeaveHours"
// Parameter: employeeMail (string), month_start (date), month_end (date)
int getLeaveHours(string employeeMail, date month_start, date month_end)
{
    // Abwesenheiten in Zoho People haben oft eine Dauer in Tagen oder halben Tagen.
    // Wir nehmen hier vereinfacht an, ein Tag entspricht 8 Stunden.
    totalLeaveHours = 0;
    
    // API-Aufruf an Zoho People, um die Abwesenheitsanträge abzurufen
    // Du musst zuvor eine Verbindung zu Zoho People in den Einstellungen einrichten.
    // "zohocreatordemo" muss durch den Namen deiner Verbindung ersetzt werden.
    leaveRecords = zoho.people.getRecords("leave", 1, 100, {"searchColumn":"EmailID", "searchValue":employeeMail}, "zohocreatordemo");

    if(leaveRecords.get("response").get("result").size() > 0)
    {
        for each  rec in leaveRecords.get("response").get("result"))
        {
            // Prüfen, ob die Abwesenheit im relevanten Monat liegt
            leave_from_date = rec.get("From").toDate();
            leave_to_date = rec.get("To").toDate();

            if(!(leave_from_date > month_end || leave_to_date < month_start))
            {
                // Vereinfachte Logik: Jeder Tag im Zeitraum zählt 8 Stunden
                // Für eine exakte Berechnung müsstest Du die Überschneidung der Datumsbereiche kalkulieren.
                duration = rec.get("Leavedays").toDecimal();
                totalLeaveHours = totalLeaveHours + (duration * 8);
            }
        }
    }
    return totalLeaveHours;
}

Schritt 3: Projektauslastung aus Zoho Projects abrufen

Als Nächstes müssen wir wissen, wie viele Stunden bereits für Projekte in Zoho Projects verplant sind. Auch hierfür schreiben wir eine Deluge-Funktion, die auf die Projects API zugreift.

// Deluge Script: Custom Function "getProjectHours"
// Parameter: portalId (string), employeeId (string)
// Die employeeId erhältst Du aus Zoho Projects
int getProjectHours(string portalId, string employeeId)
{
    totalProjectHours = 0;
    
    // API-Aufruf an Zoho Projects, um alle Tasks eines Mitarbeiters abzurufen
    // Du musst eine Verbindung zu Zoho Projects ("zohoprojectsdemo") einrichten.
    // Hier filtern wir nach offenen Tasks für den spezifischen Mitarbeiter.
    tasksResponse = zoho.projects.getRecords("tasks", portalId, 1, 200, {"owner_id":employeeId, "status":"open"}, "zohoprojectsdemo");
    
    if(tasksResponse.get("tasks") != null)
    {
        for each  task in tasksResponse.get("tasks"))
        {
            if(task.get("work_hours") != null)
            {
                totalProjectHours = totalProjectHours + task.get("work_hours").toLong();
            }
        }
    }
    return totalProjectHours;
}

Hinweis: In der Praxis würdest Du dies verfeinern, um nur die Stunden zu zählen, die im aktuellen Monat fällig sind, indem Du die Start- und Enddaten der Tasks auswertest.

Schritt 4: Das Dashboard in Creator Pages erstellen

Jetzt bringen wir alles zusammen. Erstelle in Zoho Creator eine „Page“. Dies ist eine leere Leinwand, die Du mit HTML, CSS und Deluge-Skriptlets füllen kannst, um ein dynamisches Dashboard zu bauen.

Dein Page-Code könnte so aussehen:

<h2>Team Kapazitäts-Dashboard (Aktueller Monat)</h2>
<table class="table">
    <thead>
        <tr>
            <th>Mitarbeiter</th>
            <th>Soll-Kapazität</th>
            <th>Abwesenheit (Std)</th>
            <th>Netto-Kapazität</th>
            <th>Verplante Projektstunden</th>
            <th>Freie Kapazität</th>
            <th>Auslastung</th>
        </tr>
    </thead>
    <tbody>
    <%
    // Aktuellen Monat bestimmen
    month_start = zoho.currentdate.toStartOfMonth();
    month_end = zoho.currentdate.toEndOfMonth();
    
    // Alle Mitarbeiter aus dem Formular abrufen
    all_employees = Mitarbeiter[ID != 0];
    
    for each employee in all_employees
    {
        // IDs für die API-Aufrufe holen (müssen im Mitarbeiter-Datensatz gespeichert sein)
        projects_user_id = employee.Zoho_Projects_User_ID; 
        portal_id = "DEIN_PROJECTS_PORTAL_ID"; // Deine Portal ID aus Zoho Projects
        
        // Custom Functions aufrufen
        leave_hours = thisapp.getLeaveHours(employee.Email, month_start, month_end);
        project_hours = thisapp.getProjectHours(portal_id, projects_user_id);
        
        // Berechnungen durchführen
        soll_kapazitaet = employee.Monatliche_Soll_Kapazität_Stunden;
        netto_kapazitaet = soll_kapazitaet - leave_hours;
        freie_kapazitaet = netto_kapazitaet - project_hours;
        auslastung = 0;
        if(netto_kapazitaet > 0)
        {
            auslastung = (project_hours * 100) / netto_kapazitaet;
        }
        %>
        <tr>
            <td><%=employee.Name%></td>
            <td><%=soll_kapazitaet%> Std</td>
            <td><%=leave_hours%> Std</td>
            <td><strong><%=netto_kapazitaet%> Std</strong></td>
            <td><%=project_hours%> Std</td>
            <td style="color:<%=if(freie_kapazitaet  95, "red", if(auslastung > 75, "orange", "green"))%>;"><%=auslastung.round(0)%>%</div>
                </div>
            </td>
        </tr>
    <%
    }
    %>
    </tbody>
</table>

Schritt 5: Proaktive Benachrichtigungen mit Zoho Cliq

Ein Dashboard ist gut, proaktive Warnungen sind besser. Richte einen Workflow in Deiner Creator-Anwendung ein, der täglich oder wöchentlich ausgeführt wird. Dieser Workflow prüft, ob die Auslastung eines Mitarbeiters einen kritischen Wert (z.B. 100 %) überschreitet und sendet dann eine Nachricht an einen relevanten Kanal in Zoho Cliq.

// Deluge Script für einen scheduled Workflow
// Iteriert durch alle Mitarbeiter und prüft die Auslastung
for each employee in Mitarbeiter[ID != 0]
{
    // ... (Logik zur Berechnung der Auslastung wie im Dashboard)
    
    if(auslastung > 100)
    {
        message = "⚠️ *Überlastungs-Warnung:* " + employee.Name + " ist zu " + auslastung.round(0) + "% für diesen Monat verplant. Bitte Kapazitäten prüfen!";
        
        // Nachricht an den 'projektleitung' Kanal in Cliq senden
        // Du musst eine Verbindung zu Zoho Cliq ("zohocliqdemo") einrichten.
        zoho.cliq.postToChannel("projektleitung", message, "zohocliqdemo");
    }
}

Tipps und Best Practices für die Umsetzung

• Datenqualität sichern: Die Genauigkeit Deines Dashboards hängt von der Qualität der Quelldaten ab. Stelle sicher, dass Abwesenheiten in Zoho People und Aufgabenstunden in Zoho Projects konsequent gepflegt werden. Garbage in, garbage out.
• Alternative zu Code: Zoho Flow: Für einfachere, ereignisbasierte Verknüpfungen (z.B. „Wenn ein neuer Urlaub in People genehmigt wird, aktualisiere einen Datensatz in Creator“) kann Zoho Flow eine hervorragende No-Code-Alternative zu komplexen Deluge-Skripten sein.
• Kundenbeziehung einbeziehen: Um strategische Entscheidungen zur Projektübergabe zu treffen, kannst Du Daten aus Zoho CRM integrieren. Füge dem Dashboard eine Spalte hinzu, die den „Kunden-Gesundheits-Score“ oder die „Beziehungsintensität“ anzeigt. So siehst Du schnell, bei welchem Projekt ein Wechsel des Ansprechpartners unkritischer wäre, weil bereits ein hohes Vertrauen besteht.
• Wettbewerbsbeobachtung: Der Markt für Talente ist umkämpft. Du kannst eine einfache Creator App nutzen, um Informationen über Wettbewerber und deren Teams zu sammeln (z.B. durch manuelle Recherche auf deren Webseiten oder über die LinkedIn API). So behältst Du den Überblick, wohin sich Talente bewegen.
• Skalierbarkeit: Beginne einfach, aber denke langfristig. Dein Dashboard kann erweitert werden, um Budget-Tracking aus Zoho Books oder die Kandidaten-Pipeline aus Zoho Recruit zu integrieren.

Zusätzliche Optimierungen mit dem Zoho-Ökosystem

Die wahre Stärke von Zoho liegt im Zusammenspiel der Apps. Hier sind weitere Ideen, wie Du Deine Lösung ausbauen kannst:

• Zoho Analytics: Während Creator Pages für operative Dashboards hervorragend sind, kannst Du für tiefere, strategische Analysen die Daten aus Creator, Projects, People und CRM nach Zoho Analytics synchronisieren. Dort erstellst Du komplexe, interaktive Dashboards und Trendanalysen über längere Zeiträume.
• Zoho Recruit: Wenn Dein Dashboard einen Personalbedarf signalisiert, kannst Du direkt einen Prozess anstoßen. Integriere eine Ansicht der aktuellen Kandidatenpipeline aus Zoho Recruit in Dein Dashboard, um die Lücke zwischen Bedarf und Einstellung zu schließen.
• Zoho WorkDrive: Verknüpfe jeden Mitarbeiter in Deinem Creator-Dashboard mit seinem persönlichen Ordner in WorkDrive, um schnellen Zugriff auf relevante Dokumente wie Entwicklungspläne oder Zertifikate zu haben.

Fazit: Von reaktiver Panik zu proaktiver Steuerung

Ein personeller Engpass muss kein unkontrollierbares Geschäftsrisiko sein. Indem Du die Daten, die bereits in Deinem Zoho-Ökosystem schlummern, intelligent anzapfst und visualisierst, verwandelst Du eine unsichere Situation in eine strategische Chance. Ein mit Zoho Creator gebautes Ressourcen-Dashboard gibt Dir die Transparenz, die Du für fundierte Entscheidungen benötigst. Du kannst Lasten fair verteilen, Engpässe frühzeitig erkennen und Projektübergaben datengestützt planen.

Diese Lösung zeigt eindrücklich, wie Zoho mehr ist als nur eine Sammlung einzelner Apps. Durch die Kombination von Zoho Creator, Zoho Projects, Zoho People, Zoho CRM und Zoho Cliq schaffst Du ein maßgeschneidertes Betriebssystem für Dein Unternehmen, das mit Deinen Anforderungen wächst und Dir hilft, jede Herausforderung souverän zu meistern.