Helpdesk → Aufgabe → Rechnung: Support mit Entwicklungsarbeit verbinden

Verlieren Sie keine abrechenbaren Stunden mehr bei Kunden-Support. So erfassen Sie Support-Anfragen, wandeln sie in Entwicklungsaufgaben um, erfassen Zeit präzise und rechnen Kunden transparent ab – alles in einem System.

Das Abrechnungsproblem bei Support für Entwicklungsteams

Sie sind eine Entwickler-Agentur. Ein Kunde schreibt: „Die Export-Funktion funktioniert nicht.“ Was passiert danach?

Der klassische (problematische) Ablauf:

1. Support-Ticket angelegt – in Zendesk oder Freshdesk
2. Hin und her per E-Mail – „Können Sie einen Screenshot schicken?“
3. Entwickler untersucht – aber wo wird die Zeit erfasst?
4. Fix umgesetzt – in Jira, ohne Verknüpfung zum ursprünglichen Ticket
5. Zeit geht verloren – Entwickler vergisst 3 Stunden zu buchen
6. Rechnung falsch – Kunde wird nur 1 Stunde berechnet (was Sie sich gemerkt haben)
7. Gewinn fehlt – 160 $ abrechenbare Einnahmen verloren

Die Kosten getrennter Tools:

• 15–30 % der Support-Zeit werden nie abgerechnet – Entwickler vergessen die Erfassung
• Kunden hinterfragen Rechnungen – Kein klarer Zusammenhang zwischen Support und Abrechnung
• Kontextwechsel kostet Produktivität – Wechsel zwischen vier verschiedenen Tools
• Admin-Aufwand – Tickets, Aufgaben, Zeit und Rechnungen manuell verknüpfen

Die Lösung: Ein durchgängiger Workflow vom Support-Ticket bis zur Rechnung.

Dieser Artikel zeigt, wie Sie genau diesen Workflow in Corcava aufsetzen.

Der komplette Workflow im Überblick

Der 5-Schritte-Prozess von Support zur Rechnung

Schritt 1: Support-Anfrage erfassen

• Kunde meldet Anliegen per E-Mail, Formular oder direktes Ticket
• Support-Ticket mit Priorität, Status und Kundenverknüpfung anlegen
• Ticket einem Support-Mitarbeiter zur Einordnung zuweisen

Schritt 2: Ticket in Entwicklungsaufgabe umwandeln

• Support erkennt: Es braucht Entwicklungsarbeit
• Projektaufgabe anlegen, direkt mit dem Support-Ticket verknüpft
• Aufgabe erscheint auf dem Entwicklungs-Board mit vollem Kontext

Schritt 3: Entwicklungszeit erfassen

• Entwickler arbeitet an der Aufgabe mit automatischer oder manueller Zeiterfassung
• Zeit wird automatisch Projekt, Aufgabe und Kunde zugeordnet
• Echtzeit-Überblick über aufgewendete Support-Stunden

Schritt 4: Kundenrechnung aus Support-Arbeit erstellen

• Zeiterfassungsdaten fließen in die Rechnungsstellung ein
• Rechnung mit Positionen für die erbrachte Support-Arbeit erstellen
• Rechnung zeigt klar, welche Anliegen bearbeitet wurden

Schritt 5: Transparenz für den Kunden

• Kunde sieht den Fortschritt im Portal
• Rechnung enthält Kontext aus dem ursprünglichen Support-Ticket
• Nachvollziehbarer Weg von Anfrage über Lösung bis zur Abrechnung

Warum dieser Workflow wichtig ist

✅ Jede abrechenbare Stunde erfassen – Keine vergessenen Zeiteinträge
✅ Klare Kundenkommunikation – Transparenter Zusammenhang von Anliegen und Abrechnung
✅ Weniger Kontextwechsel – Alles in einem System
✅ Schnellere Reaktionszeiten – Kein Tool-Hopping
✅ Bessere Kundenbeziehungen – Transparenz schafft Vertrauen
✅ Höhere Rentabilität – 100 % der Support-Arbeit abrechnen

Schritt 1: Support-Tickets anlegen

Das Helpdesk-System verstehen

Was ist ein Support-Ticket?

Ein Support-Ticket ist der Eintrag zu einem Kundenanliegen, das bearbeitet werden muss:

Ticket-Bestandteile:

• Ticketname – Kurzbeschreibung des Anliegens
• Beschreibung – Ausführliche Erklärung und Kontext
• Status – Offen, In Bearbeitung, Gelöst, Geschlossen
• Priorität – Niedrig, Mittel, Hoch, Dringend
• Verantwortlicher – Teammitglied für das Ticket
• Quelle – Entstehung (E-Mail, Formular, manuell, Chat)
• Kunde & Kontakt – Wer das Anliegen gemeldet hat
• Aktivitätsverlauf – Vollständige Historie der Ticket-Interaktionen

Support-Tickets anlegen

Methode 1: Manuelle Ticket-Erstellung

Unter Tickets → Neu ein Ticket anlegen:

1. Ticket-Daten eingeben

   • Name: „Export-Funktion für CSV-Dateien funktioniert nicht“
   • Beschreibung: „Kunde meldet: CSV-Export lädt leere Datei“

2. Ticket-Eigenschaften setzen

   • Status: Offen
   • Priorität: Hoch (blockiert Kunden-Workflow)
   • Quelle: E-Mail

3. Verantwortung zuweisen

   • Verantwortlicher: Support-Mitarbeiter zur Einordnung

4. Mit Kunde verknüpfen

   • Kunde: [Kundenfirma]
   • Kontakt: [Ansprechpartner]
   • In Kontakt-Timeline: Ja

Methode 2: E-Mail-zu-Ticket

E-Mail-Weiterleitung einrichten, damit Tickets automatisch entstehen:

• Support-E-Mails an die Helpdesk-E-Mail des Teams weiterleiten
• Tickets werden aus dem E-Mail-Inhalt erstellt
• Betreff wird zum Ticketnamen
• Inhalt wird zur Beschreibung
• Absender wird automatisch dem Kontakt zugeordnet (falls vorhanden)

Methode 3: Formularbasierte Ticket-Erstellung

Öffentliche Support-Formulare für Kunden anlegen:

• Formular mit eigenen Feldern erstellen
• Kunde sendet Anliegen über das Formular
• Ticket wird automatisch mit Formulardaten erstellt
• Kunde erhält Bestätigung und Ticket-Nummer

Ticket-Einordnung und Priorisierung

Triage im Support-Team:

1. Neue Tickets prüfen – Täglich alle offenen Tickets durchgehen
2. Informationen sammeln – Bei Bedarf Kommentare mit Rückfragen ergänzen
3. Priorität setzen – Nach Auswirkung und Dringlichkeit
4. Anliegen-Typ zuordnen – Bug, Feature-Wunsch, Nutzerfrage usw.
5. Richtig weiterleiten – Kann Support lösen oder braucht Entwicklung

Priorisierungsrahmen:

Hohe Priorität (braucht Entwicklung):

• Blockiert produktiven Kunden-Workflow
• Datenverlust oder Sicherheitsprobleme
• Kernfunktion defekt
• Zugesagter Termin rückt näher

Mittlere Priorität (braucht Entwicklung):

• Nicht-kritischer Bug bei einzelnen Nutzern
• Feature-Verbesserung
• Performance-Probleme
• Optische Mängel in Produktion

Niedrige Priorität (Support kann lösen):

• Nutzerfragen
• Konfigurationshilfe
• Schulungswünsche
• Klärung in der Dokumentation

Schritt 2: Tickets in Entwicklungsaufgaben umwandeln

Wann eine Entwicklungsaufgabe anlegen

Entscheidungskriterien:

✅ Entwicklungsaufgabe anlegen, wenn:

• Anliegen Codeänderungen oder Deployment erfordert
• Untersuchung voraussichtlich über 30 Minuten dauert
• Mehrere Entwickler zusammenarbeiten sollen
• Arbeit in den Sprint eingeplant werden muss
• Kunde nach Entwicklungsstunden abgerechnet wird

❌ Im Helpdesk belassen, wenn:

• Schnelle Konfigurationsänderung (< 15 Min.)
• Nutzerfrage, die die Dokumentation beantwortet
• Anliegen durch Kunden-Schulung gelöst wird
• Nicht abrechenbarer interner Test

Aufgaben aus Tickets erstellen

Manueller Ablauf:

Ohne automatische Ticket-zu-Aufgabe-Konvertierung in Corcava – so geht es effizient von Hand:

1. Support-Ticket öffnen

• Ticket-Details und Kundeninfos prüfen
• Anliegen und gewünschte Lösung verstehen
• In der Beschreibung nach Reproduktionsschritten schauen

2. Zum Projekt-Board wechseln

• Zum Kundenprojekt oder zum allgemeinen „Support“-Projekt gehen
• Passendes Board wählen (z. B. „Kunden-Support“ oder „Bugfixes“)
• Richtige Spalte wählen (meist „Backlog“ oder „To Do“)

3. Entwicklungsaufgabe anlegen

• In der Spalte „Aufgabe hinzufügen“ klicken
• Aufgabenname: Mit Ticket-Bezug – „Fix: CSV-Export leere Datei (#TKT-123)“
• Beschreibung: Relevante Infos aus dem Ticket übernehmen

  Support-Ticket: #TKT-123
  Kunde: ACME Corp
  Kontakt: Jane Smith
  
  Anliegen: CSV-Export lädt leere Dateien
  
  Reproduktion:
  1. Berichte → Export
  2. „CSV“ wählen
  3. Export klicken
  4. Heruntergeladene Datei 0 Bytes
  
  Erwartet: Datei mit vollständigen Berichtsdaten
  Tatsächlich: Datei leer
  
  Auswirkung: Blockiert monatliche Berichterstellung des Kunden
  

4. Aufgabe dem Kunden zuordnen

• Kunde aus der Liste wählen
• Optional spezifischen Kontakt verknüpfen
• Bei abrechenbarem Projekt: Aufgabe diesem Projekt zuordnen

5. Aufgabeneigenschaften setzen

• Zeitschätzung: 2–4 Std. (Untersuchung + Fix + Test)
• Fälligkeitsdatum: Nach Ticket-Priorität und Kunden-SLA
• Betrag: Falls Festpreis
• Labels: „bug“, „client-support“, „high-priority“

6. Entwickler zuweisen

• Passendes Teammitglied zuweisen
• Expertise und aktuelle Auslastung berücksichtigen
• Entwickler über Dringlichkeit informieren

7. Support-Ticket aktualisieren

• Kommentar im Ticket: „Entwicklungsaufgabe #123 angelegt – zugewiesen an [Entwickler]“
• Ticket-Status auf „In Bearbeitung“ setzen
• Nach Möglichkeit Link zur Aufgabe (Aufgaben-URL in Ticket-Notizen)

Ein „Support“-Projekt anlegen

Warum ein eigenes Support-Projekt:

• Support-Arbeit gebündelt – Alle Kunden-Support-Aufgaben an einem Ort
• Einfache Zeiterfassung – Entwickler wissen, wo Support-Zeit buchen
• Klares Reporting – Support-Stunden vs. Projektarbeit
• Kundenabrechnung – Support getrennt von Projekt-Lieferables

Support-Projekt einrichten:

1. Projekt anlegen

   • Name: „Kunden-Support“ oder „Bugfixes & Support“
   • Abrechenbar: Ja (falls Support abgerechnet wird)
   • Alle Entwickler dem Projekt zuweisen

2. Support-Board anlegen

   • Name: „Support-Queue“
   • Spalten: Backlog → In Prüfung → In Bearbeitung → Test → Erledigt

3. Labels konfigurieren

   • Bug (rot)
   • Enhancement (blau)
   • Urgent (orange)
   • Kunden-spezifische Labels

4. Zugriff fürs Team

   • Alle Entwickler können Aufgaben sehen und bearbeiten
   • Support-Team kann Aufgaben anlegen
   • Kunden können optional über Portal einsehen

Schritt 3: Zeiterfassung für Support-Arbeit

Zeiterfassung bei Support-Aufgaben

Warum Zeiterfassung im Support wichtig ist:

• Abrechnungsgenauigkeit – Jede Minute wird abgerechnet
• Umfangssteuerung – Kunden mit hohem Support-Bedarf erkennen
• Ressourcenplanung – Tatsächliche Support-Last verstehen
• Kundenkommunikation – Zeigen, welche Arbeit erbracht wurde

Automatische Zeiterfassung im Support

Mit der Desktop-App:

1. Arbeitsphase starten

   • Corcava-Desktop-App für Zeiterfassung öffnen
   • Projekt „Kunden-Support“ wählen
   • Konkrete Aufgabe wählen (z. B. „#123 – Fix CSV-Export“)
   • „START“ klicken

2. Am Anliegen arbeiten

   • Bug im Code untersuchen
   • Fix umsetzen
   • Lösung testen
   • App erfasst die Zeit im Hintergrund

3. Arbeit dokumentieren

   • Notizen zur Aufgabe ergänzen
   • Aufgabenstatus im Workflow aktualisieren
   • Kommentare zu Ergebnissen hinzufügen

4. Session beenden

   • „FINISH“ klicken, wenn das Support-Anliegen erledigt ist
   • Zeit wird automatisch berechnet und gespeichert
   • Erscheint auf der Aufgabenkarte und in Reports

Vorteile automatischer Erfassung im Support:

• Genauere Untersuchungszeit – Recherche- und Debug-Zeit wird erfasst
• Keine vergessenen Sessions – Jede Arbeitsphase wird erfasst
• Detaillierte Zeiteinträge – Exakte Start/Stopp für die Abrechnung
• Nachweis für Kunden – Optionale Screenshots belegen die Arbeit

Manuelle Zeiterfassung im Support

Wann manuell buchen:

• Schnelle Fixes, für die sich automatische Erfassung nicht lohnt
• Support außerhalb der Arbeitszeiten
• Zeiterfassung anfangs vergessen
• Zeit für Telefon/E-Mail-Support

Support-Zeit manuell erfassen:

1. Meine Arbeit → Zeiteintrag öffnen
2. Datum der Support-Arbeit wählen
3. Start- und Endzeit eingeben
4. Projekt „Kunden-Support“ wählen
5. Konkrete Aufgabe wählen
6. Beschreibung: z. B. „CSV-Export-Bug untersucht – Ursache: Encoding in Export-Bibliothek“
7. Als abrechenbar markieren (falls zutreffend)
8. Zeiteintrag speichern

Best Practices für Support-Zeiterfassung

1. Gesamte Untersuchungszeit erfassen

• Nicht nur „Programmierzeit“
• Recherche, Debugging, Tests, Dokumentation mit erfassen
• Untersuchung ist abrechenbar – erfassen

2. Aussagekräftige Beschreibungen

• „Bug behoben“ ❌
• „CSV-Export untersucht – Encoding-Problem in Export-Bibliothek gefunden, auf UTF-8 umgestellt, mit Beispieldaten getestet“ ✅

3. Wenn möglich in Echtzeit erfassen

• Support-Zeit nicht erst abends nachtragen
• Während der Arbeit erfassen für maximale Genauigkeit
• Nach 8 Stunden fällt die Erinnerung schwer

4. Support von Projektarbeit trennen

• Support-Zeit nicht mit Feature-Entwicklung mischen
• Getrennte Projekte oder klare Aufgaben-Labels nutzen
• Macht Abrechnung und Reporting klarer

5. Kommunikationszeit einbeziehen

• Kundenanrufe und -E-Mails sind abrechenbare Support-Zeit
• Zeit für Slack/E-Mail zum Anliegen erfassen
• Zeit für Status-Updates mit erfassen

Schritt 4: Rechnungen aus Support-Arbeit erstellen

Rechnungen aus erfasster Zeit

Vom Zeit-Eintrag zur Rechnung:

Die integrierte Rechnungsstellung in Corcava nutzt Zeiterfassungsdaten automatisch für Rechnungen.

Rechnung manuell aus Support-Zeit erstellen:

1. Rechnungen → Neue Rechnung öffnen

2. Kunde wählen

   • Kunde, für den Support abgerechnet wird
   • Währung wird aus den Kundeneinstellungen übernommen

3. Rechnungsdaten setzen

   • Rechnungsdatum: Heute
   • Fälligkeit: Nach Zahlungsbedingungen (z. B. Netto 30)
   • Rechnungsnummer: Wird automatisch vergeben

4. Positionen aus Zeiterfassung ergänzen

   Variante A: Manuelle Positionen

   • Position: „Support & Bugfixes – Januar 2025“
   • Menge: 12,5 Stunden
   • Satz: 120 $/Stunde
   • Betrag: 1.500 $

   Variante B: Detaillierte Positionen pro Aufgabe

   • Position 1: „CSV-Export-Bugfix – Aufgabe #123“

     • Menge: 3,5 Stunden
     • Satz: 120 $/Stunde
     • Betrag: 420 $

   • Position 2: „Benutzerberechtigung – Aufgabe #124“

     • Menge: 2,0 Stunden
     • Satz: 120 $/Stunde
     • Betrag: 240 $

5. Zeitberichte prüfen

   • Zu Zeitberichte gehen
   • Nach Kunde und Zeitraum filtern
   • Prüfen, ob Gesamtstunden zur Rechnung passen
   • Bericht exportieren und der Rechnung beifügen

6. Rechnungshinweise ergänzen

   Erbrachte Support-Arbeit:
   - CSV-Export-Encoding behoben (Ticket #123)
   - Bug bei Benutzerberechtigung behoben (Ticket #124)
   - Dokumentation zur Export-Funktion aktualisiert
   
   Alle Punkte geprüft, behoben und in Produktion ausgerollt.
   

7. Rechnung senden

   • Gesamtbetrag prüfen
   • „Rechnung senden“ klicken
   • Kunde erhält E-Mail mit Rechnung und Link zum Kundenportal

Automatische wiederkehrende Support-Rechnungen

Bei Kunden mit Support-Retainer:

Wenn Sie monatliche Support-Stundenpakete anbieten:

1. Rechnungseinstellungen beim Kunden

• Kunde → Rechnungseinstellungen
• Wiederkehrende Rechnungen aktivieren
• Intervall: Monatlich
• Tag: 1. (oder nach Wunsch)

2. Automatische zeitbasierte Abrechnung

• System sammelt die Zeiteinträge des Monats
• Erstellt die Rechnung zum geplanten Termin
• Versendet sie automatisch an den Kunden

3. Support-Stundenpakete

Beispiel: 20-Stunden-Support pro Monat
- Kunde zahlt 2.000 $/Monat für bis zu 20 Std. Support
- Alle Support-Zeiten wie gewohnt erfassen
- Rechnung zeigt genutzte vs. Paket-Stunden
- Überstunden zum Stundensatz berechnen

4. Abrechnung Überstunden

• Position 1: „Support-Paket (20 Std.)“ – 2.000 $
• Position 2: „Zusätzlicher Support (3,5 Std.)“ – 420 $
• Summe: 2.420 $

Best Practices für Support-Abrechnung

1. Klare Beschreibungen Schlecht: „Entwicklungsarbeit – 10 Std. – 1.200 $“

Gut:

Support & Bugfixes – Januar 2025
- CSV-Export-Bug (Ticket #123): 3,5 Std.
- Benutzerberechtigung (Ticket #124): 2,0 Std.
- Performance-Optimierung (Ticket #125): 4,5 Std.
Gesamt: 10 Std. à 120 $/Std. = 1.200 $

2. Bezug zu den Original-Tickets

• Ticket-Nummern in den Rechnungstext aufnehmen
• Ticket-Titel nennen, damit der Kunde das Anliegen zuordnen kann
• Erleichtert dem Kunden den Abgleich mit Support-Anfragen

3. Zeitberichte anhängen

• Detaillierten Zeitbericht aus Corcava exportieren
• Als PDF der Rechnungs-E-Mail beifügen
• Zeigt die tägliche Aufschlüsselung der Stunden

4. Nach Projekt oder Zeitraum gruppieren

• Monatsrechnungen: „Support – Januar 2025“
• Projektbezogen: „Projekt X – Support-Stunden“
• Macht die Abrechnung vorhersehbar und nachvollziehbar

5. Lieferung beschreiben

• Nicht nur „Bug behoben“
• „Bug behoben, Lösung getestet, in Produktion ausgerollt, Lösung verifiziert“
• Den gelieferten Mehrwert zeigen

Schritt 5: Transparenz für Kunden über das Portal

Kundenportal für Support-Einblick

Was Kunden sehen:

Das Kundenportal zeigt Support-Arbeit in Echtzeit:

1. Zugriff auf das Projekt-Board

• Kunde kann das Support-Projekt-Board einsehen
• Aktuellen Status seiner Support-Tickets sehen
• Sehen, welcher Entwickler zugewiesen ist
• Fortschritt über die Workflow-Spalten verfolgen

2. Aufgabendetails

• Auf eine Aufgabe klicken für Details
• Kommentare und Updates lesen
• Anhänge und Screenshots ansehen
• Verstehen, woran gearbeitet wird

3. Sichtbarkeit der Zeiterfassung (optional)

• Erfasste Zeit zu ihren Support-Aufgaben sehen
• Zeitaufwand pro Anliegen nachvollziehen
• Vertrauen durch Transparenz
• Keine Überraschungen bei der Abrechnung

4. Rechnungsbereich im Portal

• Alle Rechnungen an einem Ort
• Rechnung anklicken für Positionsdetails
• Von der Rechnung zu den abgerechneten Aufgaben verlinken
• Zahlung direkt im Portal durchführen

Kundenportal-Zugriff einrichten

1. Kundenportal für den Kunden aktivieren

• Kundendetails öffnen
• „Kundenportal-Zugriff“ aktivieren
• Kunde erhält Zugangsdaten zum Portal

2. Sichtbarkeit des Projekts konfigurieren

• Support-Projekt → Einstellungen
• „Kundenportal-Zugriff“ aktivieren
• Festlegen, welche Kunden das Projekt sehen
• Steuern, welche Spalten sichtbar sind

3. Sichtbarkeit der Zeiterfassung

• Entscheiden, ob Kunden erfasste Zeit sehen sollen
• Manche wollen Transparenz
• Manche möchten keine laufende Zeit sehen
• Pro Kunde nach Wunsch einstellen

4. Portal-Benachrichtigungen einrichten

• Kunde wird bei Aufgabenstatus-Änderung benachrichtigt
• Kunde wird bei neuer Rechnung benachrichtigt
• Optional: Bei erfasster Zeit benachrichtigen
• Kunden bleiben informiert ohne manuelle Updates

Kommunikation – Best Practices

1. Erwartungen von vornherein klären

• „Sie erhalten Portal-Zugang, um den Support-Fortschritt zu verfolgen“
• „Rechnungen verweisen auf Ticket-Nummern aus dem Portal“
• „Sie sehen den Echtzeit-Status aller Support-Anfragen“

2. Kunden im Portal schulen

• Kurzes Video oder Anleitung schicken
• Zeigen, wie der Aufgabenstatus angezeigt wird
• Erklären, wie Rechnungen mit Aufgaben verknüpft sind
• Weniger „Wie ist der Stand?“-E-Mails

3. Proaktiv informieren

• Nicht nur auf das Portal setzen
• Wöchentliche Zusammenfassung der Support-Arbeit senden
• Erledigte Tickets hervorheben
• Anstehende Abrechnungen erwähnen

4. Portal für Nachvollziehbarkeit nutzen

• „Wie im Portal sichtbar, hat dies wegen X 4 Stunden gedauert“
• „Details zur Untersuchung finden Sie in Aufgabe #123 im Portal“
• Reduziert Abrechnungsstreit von vornherein

Beispiele aus der Praxis

Beispiel 1: Dringender Produktions-Bug

Szenario: Kunde meldet kritischen Bug, der Produktionsnutzer betrifft.

Ablauf:

9:00 – Ticket angelegt

• Kunde mailt: „Nutzer können sich nicht einloggen!“
• Support legt Ticket #156 an
• Priorität: Dringend
• Status: Offen
• Zugewiesen: Support-Lead

9:05 – Triage

• Support-Lead prüft
• Bestätigt: Login fehlgeschlagen bei E-Mails mit Sonderzeichen
• Nicht durch Support lösbar – Code-Änderung nötig
• Erstellt Entwicklungsaufgabe #234 auf Support-Board

9:10 – Entwickler zugewiesen

• Aufgabe an Senior-Entwickler
• Benachrichtigung per Slack
• Entwickler startet Zeiterfassung für Aufgabe #234

9:15 – Untersuchung

• Entwickler prüft Code
• Findet Bug in E-Mail-Validierungs-Regex
• Kommentar: „Ursache: Regex-Pattern zu strikt“

10:30 – Fix ausgerollt

• Fix umgesetzt und getestet
• In Produktion ausgerollt
• Zeiterfassung beendet: 1,25 Std.
• Aufgabe in Spalte „Erledigt“
• Ticket #156: „Behoben und ausgerollt – bitte testen“

10:45 – Kundenbestätigung

• Kunde bestätigt Lösung
• Support schließt Ticket #156

Monatsende – Abrechnung

• Rechnung für Januar-Support erstellt
• Position: „Kritischer Login-Bugfix (Ticket #156) – 1,25 Std. à 150 $/Std. = 187,50 $“
• Kundenportal verlinkt Rechnung mit Aufgabe #234

Ergebnis:

• ✅ Anliegen von Meldung bis Deployment in 1,5 Std. gelöst
• ✅ Alle Zeit erfasst und abgerechnet
• ✅ Nachvollziehbarer Weg von Ticket zur Rechnung
• ✅ Kunde erlebt Transparenz und schnelle Reaktion

Beispiel 2: Feature-Erweiterung

Szenario: Kunde wünscht kleines Feature während eines Support-Anrufs.

Ablauf:

Montag – Support-Anruf

• 30 Min. Gespräch zu Reporting-Bedarf
• Kunde: „Können wir PDF-Export im Dashboard haben?“
• Support legt Ticket #157 an: „Feature-Wunsch: PDF-Dashboard-Export“
• Priorität: Mittel | Status: Offen

Montag Nachmittag – Scoping

• Support-Lead prüft Anforderung
• Erstellt Aufgabe #235: „PDF-Dashboard-Export umsetzen“
• Schätzung: 6–8 Std.
• Zugewiesen: Mid-Level-Entwickler
• Fällig: Freitag

Dienstag – Entwicklung

• Entwickler beginnt mit Aufgabe #235
• Zeiterfassung über Desktop-App
• Tag 1: 4,5 Std. (Recherche, Design, erste Umsetzung)
• Commit-Hash in Aufgabennotizen

Mittwoch – Weitere Entwicklung

• Tag 2: 3 Std. (Fertigstellung, Unit-Tests)
• Aufgabe in Spalte „Test“

Donnerstag – Test & Kundendemo

• QA: 1 Std. | Nachbesserungen: 0,5 Std.
• Kurze Demo per Screenshare
• Kunde akzeptiert Feature
• Aufgabe „Erledigt“, Ticket #157 geschlossen
• Gesamt: 9 Std.

Freitag – Rechnung

• Rechnung für dieses Feature
• Position: „Feature-Entwicklung: PDF-Dashboard-Export (Ticket #157) – 9 Std. à 120 $/Std. = 1.080 $“
• Screenshot des umgesetzten Features beifügen
• Im Kundenportal: Aufgabe #235 mit allen Zeiten

Ergebnis:

• ✅ Klarer Scope von Anfrage bis Lieferung
• ✅ Gesamte Entwicklungszeit erfasst (Recherche + Code + Test)
• ✅ Kunde bestätigt vor Abrechnung
• ✅ Rechnung erklärt klar, was umgesetzt wurde

Beispiel 3: Monatlicher Support-Retainer

Szenario: Kunde hat 20-Stunden-Support-Paket pro Monat.

Ablauf:

Im Januar:

• Mehrere Support-Tickets angelegt und gelöst
• Jedes Ticket als Aufgabe auf dem Support-Board
• Alle Zeiten auf den jeweiligen Aufgaben erfasst

Tickets & Zeit:

• Ticket #140 (kleiner UI-Bug) → Aufgabe #210 → 2,5 Std.
• Ticket #143 (API-Integration) → Aufgabe #213 → 4 Std.
• Ticket #148 (Performance) → Aufgabe #218 → 6 Std.
• Ticket #152 (Datenexport) → Aufgabe #222 → 3,5 Std.
• Ticket #156 (Dokumentation) → Aufgabe #227 → 2 Std.
• E-Mail-Support (Kurzfragen) → Manuelle Einträge → 3 Std.
• Summe: 21 Std.

31. Januar – Automatische Rechnung:

• System erstellt Rechnung automatisch
• Rechnung #2025-01-31-ACME
• Position 1: „Monatliches Support-Paket (20 Std.)“ – 2.000 $
• Position 2: „Zusätzliche Support-Stunden (1 Std. à 120 $/Std.)“ – 120 $
• Summe: 2.120 $

Rechnungshinweise:

Support im Januar 2025:
- UI-Bug behoben (Ticket #140)
- API-Integration behoben (Ticket #143)
- Report-Abfrage optimiert (Ticket #148)
- Datenexport-Encoding behoben (Ticket #152)
- API-Dokumentation aktualisiert (Ticket #156)
- Diverse E-Mail-Support und Kurzfragen

Stunden: 20 (Paket) + 1 (Überstunden)

Kundenportal:

• Kunde sieht alle 6 bearbeiteten Aufgaben
• Zeitaufschlüsselung pro Aufgabe
• Prüft 21 Std. gesamt
• Versteht Überstunden-Position

Ergebnis:

• ✅ Volle Transparenz der Stundennutzung
• ✅ Automatische Rechnungen sparen Admin-Zeit
• ✅ Kunde versteht genau, was erbracht wurde
• ✅ Klarer Nachweis für Retainer-Stunden

Typische Herausforderungen und Lösungen

Herausforderung 1: Entwickler vergessen die Zeiterfassung

Problem: Entwickler springen direkt in die Fehlerbehebung, ohne die Zeiterfassung zu starten – abrechenbare Stunden gehen verloren.

Lösungen:

1. In den Aufgaben-Workflow einbauen

• Status-Änderung löst Erinnerung zur Zeiterfassung aus
• Schulung: „Erster Schritt beim Öffnen einer Aufgabe: Erfassung starten“
• Sichtbare Hinweise auf den Aufgabenkarten

2. Standardmäßig automatische Erfassung

• Desktop-App für Support-Arbeit vorgeben
• Keine manuelle Nachpflege nötig – weniger Vergessen
• Optionale Screenshot-Verifikation sichert die Erfassung

3. Tägliche Zeitprüfung

• Kurze 5-Minuten-Runde am Tagesende
• „Hast du bei allen angefassten Support-Aufgaben Zeit erfasst?“
• Vergessene Zeit sofort nachtragen

4. Zeit an Aufgabenbewegung koppeln

• Von „To Do“ nach „In Bearbeitung“ nur mit gestarteter Erfassung
• Bei „Erledigt“ mindestens X Stunden erfasst haben
• Dashboard: Aufgaben ohne Zeiteintrag sichtbar machen

5. Positive Verstärkung

• Monatlich teilen: „Team hat 98 % der Support-Stunden erfasst!“
• Entwicklern für zuverlässige Erfassung danken
• Vergessene Zeit nicht bestrafen – Genauigkeit fördern

Herausforderung 2: Kunden hinterfragen Support-Rechnungen

Problem: Kunde erhält Rechnung über 8 Std. Support und sagt: „So viel Support habe ich nicht angefordert.“

Lösungen:

1. Alles verknüpfen

• Jede Rechnungsposition verweist auf eine Ticket-Nummer
• Kunde kann Ticket im Portal nachschlagen
• Ursprüngliche Anfrage, erbrachte Arbeit, Lösung sichtbar

2. Proaktive Kommunikation

• Wöchentliche Kurzinfo: „Diese Woche: Tickets #123, #124, #125 – gesamt 6 Std.“
• Keine Überraschungen bei der Abrechnung
• Kunde weiß, dass Abrechnung kommt

3. Detaillierte Zeitberichte

• Zeitbericht der Rechnung beifügen
• Tägliche Aufschlüsselung
• Mit Beschreibung der erbrachten Arbeit

4. Portal-Sichtbarkeit

• Kunde kann (optional) Zeiterfassung in Echtzeit sehen
• Sieht Fortschritt der Aufgaben
• Versteht Umfang bei komplexen Fällen

5. Vorab-Schätzungen

• Beim Anlegen der Aufgabe: „Voraussichtlich 4–6 Std.“
• Bei Überschreitung eines Schwellwerts Kundenfreigabe einholen
• Freigabe in Aufgabennotizen dokumentieren

Herausforderung 3: Support-Zeit übersteigt Schätzung

Problem: Schätzung war 2 Std. für einen Bug, tatsächlich 8 Std. wegen Komplexität.

Lösungen:

1. Früh kommunizieren

• Nach 2 Std. bei unerwarteter Komplexität Kunde informieren
• „Stellt sich als komplexer heraus – Ursache in der Datenbankschicht“
• Neue Schätzung nennen und Freigabe zum Weitermachen einholen

2. Begründen

• Nicht nur „hat länger gedauert“
• Erklären: „Untersuchung zeigte Index-Problem, das mehrere Abfragen betrifft – größerer Fix nötig“
• Mehrwert: „Ursache behoben, die sonst weitere Probleme verursacht hätte“

3. Gründlich dokumentieren

• Detaillierte Aufgabennotizen zum Untersuchungsverlauf
• Commits und Code-Änderungen sichtbar
• Klare Erklärung der festgestellten Komplexität

4. Ehrliche Zeiterfassung

• Alle Zeit erfassen, unerwartete Anteile kennzeichnen
• Bei stark abweichender Schätzung Kostenteilung anbieten
• Vertrauen durch Transparenz aufbauen

5. Fürs nächste Mal lernen

• Monatlich Ist vs. Schätzung auswerten
• Muster erkennen (z. B. DB-Themen dauern länger)
• Schätzgenauigkeit verbessern

Herausforderung 4: Support und Projektarbeit vermischt

Problem: Abrechenbare Support-Stunden sind schwer von Festpreis-Projektarbeit am gleichen Code zu trennen.

Lösungen:

1. Getrennte Projekte

• „Projekt ABC – Lieferumfang“ (Festpreis)
• „Projekt ABC – Support & Erweiterungen“ (Stunden)
• Klare Trennung für die Abrechnung

2. Klare Aufgaben-Labels

• Labels: „support“, „bug“, „project-feature“
• Zeitberichte nach Label filtern
• Abrechnung nach Labels trennen

3. Support vs. Projektumfang vorab definieren

• Vertrag: Was gehört zum Projekt, was zum Support
• „Bugs in neuen Features = Projektumfang (inklusive)“
• „Bugs in bestehendem Code = Support (abrechenbar)“
• „Neue Features/Erweiterungen = Support (abrechenbar)“

4. Wöchentliche Prüfung

• Wöchentlich Zeit mit dem Team durchgehen
• Richtige Projekt-/Aufgaben-Zuordnung prüfen
• Falsch zugeordnete Zeit vor der Rechnungsstellung korrigieren

5. Kundenkommunikation

• Aufschlüsselung zeigen: „10 Std. Projekt-Features, 3 Std. Support“
• Unterschied in den Aufgabenbeschreibungen erklären
• Im Portal die Trennung sichtbar machen

Best Practices – Kurzüberblick

Für Support-Teams

✅ Detaillierte Tickets – Mehr Kontext erleichtert die Umwandlung in Aufgaben
✅ Schnelle Triage – Dringende Fälle innerhalb 1 Std. an Entwicklung weiterleiten
✅ Kunden zuordnen – Tickets immer dem richtigen Kunden zuweisen
✅ Status aktuell halten – Ticket-Status mit Aufgabenstatus abstimmen
✅ Lösung dokumentieren – Festhalten, was zur Lösung getan wurde

Für Entwicklungsteams

✅ Zuerst Erfassung starten – Vor der Arbeit die Zeiterfassung starten
✅ Aufgabenbeschreibung nutzen – Relevanten Kontext aus dem Ticket übernehmen
✅ Detaillierte Notizen – Was gefunden und wie behoben wurde, dokumentieren
✅ Aufgabenstatus aktualisieren – Im Workflow mitziehen
✅ Zeit täglich prüfen – Kurz am Tagesende prüfen, ob alles erfasst ist

Für Projekt- und Kundenverantwortliche

✅ Support-Volumen beobachten – Stunden pro Kunde monatlich erfassen
✅ Trends erkennen – Welche Kunden brauchen am meisten Support?
✅ Zeit vor Rechnung prüfen – Sicherstellen, dass alle Support-Zeiten erfasst sind
✅ Proaktiv kommunizieren – Kunden nicht mit hohen Rechnungen überraschen
✅ Daten für Planung nutzen – Historische Support-Daten verbessern Schätzungen

Für die Kundenkommunikation

✅ Portal-Zugang – Kunden Einblick in die Support-Queue geben
✅ Wöchentliche Kurzinfos – Proaktiv über Support-Arbeit informieren
✅ Rechnungen mit Tickets verlinken – Klarer Bezug zwischen Anfrage und Rechnung
✅ Zeitberichte anhängen – Detaillierte Aufschlüsselung schafft Vertrauen
✅ Komplexe Fälle erklären – Kunden verstehen lassen, warum etwas länger dauerte

Erfolg messen

Wichtige Kennzahlen

Erfassungsquote der Zeit:

• Ziel: 95 %+ der Support-Stunden erfasst und abgerechnet
• Messung: Abgerechnete Stunden vs. geschätzte Gesamt-Support-Zeit
• Vorgehen: Wöchentlich Aufgaben ohne Zeit vs. mit Zeit prüfen

Abrechnungsstreit-Quote:

• Ziel: Weniger als 5 % der Rechnungen von Kunden hinterfragt
• Messung: Anzahl Abrechnungsfragen pro 100 Rechnungen
• Vorgehen: Kundenanfragen zu Support-Rechnungen erfassen

Support-Reaktionszeit:

• Ziel: Unter 2 Std. von Ticket bis Aufgaben-Zuweisung
• Messung: Durchschnitt von Ticket-Erstellung bis Start der Entwicklerarbeit
• Vorgehen: Ticket-Zeitstempel vs. erster Zeiteintrag auswerten

Kundenzufriedenheit:

• Ziel: 4,5+ von 5 bei Support-Zufriedenheit
• Messung: Umfrage nach Lösung
• Vorgehen: Automatische Umfrage nach Ticket-Schließung

Support-Rentabilität:

• Ziel: Faktor 2,5+ beim abrechenbaren Satz
• Messung: Support-Umsatz / tatsächliche Kosten der Support-Zeit
• Vorgehen: Monatlicher Bericht Support-Umsatz vs. Teamkosten

Kontinuierliche Verbesserung

Monatlicher Review:

1. Support-Zeitdaten exportieren

   • Alle auf Support-Aufgaben erfassten Zeiten
   • Gruppierung nach Kunde, Anliegen-Typ, Entwickler

2. Trends auswerten

   • Welche Kunden brauchen am meisten Support?
   • Welche Anliegen dauern am längsten?
   • Werden Schätzungen besser?

3. Team-Retro

   • Was lief beim Support-Workflow gut?
   • Wo gibt es Reibung?
   • Wie können wir die Zeiterfassung verbessern?

4. Kundenfeedback

   • Kunden zur Support-Erfahrung befragen
   • Nach Transparenz der Abrechnung fragen
   • Verbesserungsvorschläge sammeln

5. Prozess optimieren

   • Vorlagen und Workflows anpassen
   • Ticket-zu-Aufgabe-Ablauf verbessern
   • Zeiterfassung verfeinern

Einstieg: Umsetzungs-Checkliste

Woche 1: Einrichtung

• Projekt „Kunden-Support“ anlegen
• Support-Board mit Workflow-Spalten einrichten
• Support-Ticket-System konfigurieren
• Vorlagen für Aufgaben und Tickets anlegen
• Support-Team in der Ticket-Erstellung schulen

Woche 2: Team-Schulung

• Entwickler im Ticket-zu-Aufgabe-Workflow schulen
• Zeiterfassung einrichten (Desktop-App + manuell)
• Richtlinien zur Support-Zeiterfassung erstellen
• Workflow mit Test-Tickets durchspielen
• Kundenportal-Zugang einrichten

Woche 3: Pilot

• Pilot mit 2–3 Kunden starten
• Gesamten Support über den neuen Workflow abwickeln
• Team-Feedback zum Ablauf einholen
• Reibungspunkte identifizieren und beheben
• Erste Test-Rechnungen erstellen

Woche 4: Ausrollen

• Auf alle Kunden ausweiten
• Erfassungsquote der Zeit überwachen
• Vorlagen und Dokumentation verfeinern
• Kundenzufriedenheit messen
• Laufenden Verbesserungsprozess etablieren

Fazit: Ein Workflow von Support zur Rechnung

Keine abrechenbaren Stunden mehr durch getrennte Support-Tools verlieren. Mit einem durchgängigen Workflow vom Helpdesk zur Rechnung können Sie:

✅ 100 % der Support-Zeit erfassen – Keine vergessenen Stunden
✅ Sicher abrechnen – Nachvollziehbarer Weg von Ticket zur Rechnung
✅ Kundenbeziehungen verbessern – Transparenz schafft Vertrauen
✅ Admin-Aufwand senken – Ein System statt vier getrennter Tools
✅ Rentabilität steigern – Jährlich 20.000–50.000 $ mehr erfassen
✅ Bessere Entscheidungen – Daten zeigen, welche Kunden am meisten Support brauchen

Bereit, Ihre Support-Abrechnung zu straffen?

Corcava bietet den kompletten Workflow in einer Plattform: Helpdesk für Tickets, Projekt-Boards für Aufgaben, Zeiterfassung für die Abrechnung und Rechnungsstellung – alles verbunden mit voller Transparenz im Kundenportal.

Nächste Schritte:

1. Support-Projekt einrichten – Checkliste oben befolgen
2. Team schulen – Diesen Artikel als Leitfaden nutzen
3. Mit einem Kunden starten – Workflow im Pilot testen
4. Ergebnisse messen – Erfassung und Kundenzufriedenheit erfassen
5. Auf alle Kunden ausrollen – Bewährten Prozess einführen

Keine abrechenbaren Stunden mehr verlieren. Jede Minute Support-Arbeit erfassen und Kunden transparent abrechnen.

Weitere Ressourcen:

• Sprint Planning in Corcava
• Automatische vs. manuelle Zeiterfassung
• Support-Ticketing (Dokumentation)
• Zeiterfassung – Grundlagen
• Professionelle Rechnungsstellung
• Kundenportal-Funktionen

Bereit zum Start?Jetzt bei Corcava registrieren und Ihren einheitlichen Support-zu-Rechnung-Workflow aufbauen.