Von der Zeiterfassung zur Rechnung: Einträge in gebrandete PDFs verwandeln

Was Sie bauen und warum es wichtig ist

Eine Time-to-Invoice-App löst ein häufiges Durcheinander: Stunden liegen verstreut in Kalendern, Chats und Notizen. Wenn dann der Tag der Rechnung kommt, muss jemand den Monat per Hand rekonstruieren. Dort entstehen Fehler: vergessene abrechenbare Zeit, falsche Sätze, doppelte Zeilen oder Summen, die nicht übereinstimmen.

Diese App richtet sich an alle, die stundenweise abrechnen und einen wiederholbaren Prozess wollen: Freelancer mit mehreren Kunden, Agenturen mit mehreren Personen, die Zeit auf dasselbe Projekt buchen, und interne Teams, die Zeit an Kunden oder Abteilungen weiterverrechnen.

Das Ziel ist praktisch: Zeiteinträge pro Projekt erfassen, zu einer Rechnungs-Entität zusammenfassen und ein gebrandetes PDF erzeugen, das der Kunde versteht. Wenn dieser Ablauf zuverlässig funktioniert, wird Rechnungsstellung kein monatlicher Hektik-Job mehr.

„Einfach zuerst“ bedeutet in der Regel:

• Einen Weg, Zeit zu erfassen (Datum, Projekt, Stunden, Notiz)
• Eine Regel für Sätze (pro Projekt oder pro Person)
• Eine Rechnung pro Kunde pro Periode
• Ein PDF-Layout mit Logo und Geschäftsdaten
• Klare Stati (Entwurf, Bereit, Gesendet, Bezahlt)

Ein kleines Szenario: Ein Zweipersonen-Studio erfasst Zeit für „Kunde A – Website-Updates“. Jede Person loggt Einträge während der Woche. Am Freitag erstellst du eine Rechnung für dieses Projekt und den Datumsbereich, die App wandelt Einträge in Rechnungszeilen und das PDF ist versandfertig – ohne etwas neu eintippen zu müssen.

Wenn du eine No-Code-Plattform wie AppMaster verwendest, bring die Daten und den Workflow in Ordnung, bevor du Extras hinzufügst wie Belege, Multiwährung, Rabatte oder Freigaben. Diese lassen sich leichter ergänzen, sobald der Kernfluss schnell, genau und unanfällig ist.

Kernfunktionen, die du einbauen solltest (und was du zunächst weglässt)

Eine kleine erste Version liefert „versandfertige Rechnungen“ schneller. Konzentriere dich auf drei Dinge: Zeit erfassen, Zeit in klare Rechnungszeilen verwandeln und ein lesbares PDF erzeugen.

Beginne mit einigen Kern-Datensätzen (du kannst später umbenennen, aber die Struktur ist wichtig): Client, Project, Time Entry, Invoice und Invoice Line.

Halte den Rechnungsworkflow einfach mit einem einzigen Statusfeld auf dem Rechnungs-Datensatz. Entwurf, Bereit und Bezahlt decken die meisten Teams lange Zeit ab.

Deine Pflicht-Operationen sollten zu dem passen, was jede Woche passiert:

• Zeit erfassen (manuelle Eingabe ist meist am schnellsten zu bauen und am einfachsten zu korrigieren)
• Zeit freigeben (auch nur als Status „Freigegeben“)
• Rechnung aus freigegebener Zeit erstellen
• PDF exportieren

„Gebrandet“ heißt nicht aufwendig. Es heißt konsistent und vertrauenswürdig: Logo, Geschäftsdaten, Rechnungsnummer und Daten, klare Summen und Zahlungsanweisungen.

Was du anfangs weglassen solltest: Steuern, Rabatte, mehrere Währungen und Anhänge. Sie sind nützlich, führen aber zu Randfällen (Rundung, Rechtsgebiete, Wechselkurse, Dateispeicherung), die die erste Version verlangsamen.

Datenmodell: die notwendigen Datensätze und wichtige Felder

Eine Time-to-Invoice-App lebt oder stirbt am Datenmodell. Halte es klein und vorhersehbar, damit Summen immer mit dem übereinstimmen, was du dem Kunden versprochen hast.

Ein minimales Set an Tabellen sieht meist so aus:

• Client: Name, Abrechnungs-E-Mail, Rechnungsadresse, Standardwährung, Zahlungsbedingungen (z. B. Net 14)
• Project: client_id, Projektname, Standardstundenlohn (optional), Aktiv-Flag
• Time entry: project_id, Person (Name oder user_id), Datum, Dauer (Stunden), Beschreibung, rate_at_time, berechenbar (ja/nein), invoiced_invoice_id (leer bis abgerechnet)
• Invoice: client_id, project_id (optional), Rechnungsnummer, Ausstellungsdatum, Fälligkeitsdatum, Status, Zwischensumme, Steuer, Gesamt

Sätze sind der Punkt, an dem Apps kompliziert werden. Wähle einen Ansatz und bleibe dabei: Stundensatz pro Projekt, pro Person oder fest pro Aufgabe/Service.

Selbst wenn du einen Default-Satz auf Projekt- oder Personenebene speicherst, kopiere den tatsächlichen Satz in jeden Zeiteintrag als rate_at_time, wenn der Eintrag erstellt (oder freigegeben) wird. Das verhindert Überraschungen, wenn sich Sätze später ändern. Rechnungen sollten widerspiegeln, was zum Zeitpunkt der Arbeit galt.

Bei Zeiteinträgen kannst du oft auf einen separaten Status verzichten und stattdessen prüfen, ob invoiced_invoice_id leer ist oder nicht. Bei Rechnungen halte die Stati eng: Entwurf, Bereit, Gesendet, Bezahlt (und füge Storniert hinzu, wenn du einen sauberen Abbruchzustand brauchst).

In AppMaster bildet der Data Designer sauber PostgreSQL-Tabellen ab und hilft, Beziehungen klar zu halten, ohne Felder überall zu duplizieren.

Zeiteinträge pro Projekt erfassen (einfaches UX)

Die Zeit-Erfassung entscheidet, ob die App mühelos ist oder ignoriert wird. Halte die erste Version langweilig und schnell: ein Bildschirm, eine Hauptaktion und so wenig Optionen wie möglich.

Wähle eine Erfassungsmethode für den Anfang. Manuelle Eingabe gewinnt meist, weil sie für alle funktioniert und leicht zu prüfen ist. Ein Timer kann später kommen, wenn du gelernt hast, wie Leute tatsächlich ihren Tag tracken. Wenn du einen Timer hinzufügst, erlaube trotzdem manuelle Bearbeitungen für verpasste Stopps.

Mache die Felder, die die Abrechnungsqualität schützen, Pflichtfelder:

• Projekt (oder Kunde + Projekt)
• Datum
• Dauer (Stunden und Minuten)
• Kurze Beschreibung (etwas, das der Kunde wiedererkennt)
• Person (wenn mehr als ein Teammitglied Zeit erfasst)

Lege Rundungsregeln früh fest, weil sie Vertrauen und Summen beeinflussen. Ein verbreiteter Ansatz sind 6-Minuten-Inkremente (0,1 Stunde). Sei klar, ob du jede Eintragung rundest oder die Tagesgesamtzeit. Das Runden jeder Eintragung ist einfacher zu erklären und zu prüfen.

Wenn mehr als eine Person die Abrechnung berührt, füge einen leichten Genehmigungsschritt hinzu. Eine praktische Regel: Nach Freigabe sind Einträge standardmäßig gesperrt. Muss etwas geändert werden, sollte eine Manager-Rolle die Einträge wieder öffnen und dokumentieren, wer was warum geändert hat.

Zeit in Rechnungszeilen umwandeln (Roll-up-Regeln)

Der Roll-up ist der Moment, in dem Roh-Logs zu Rechnungszeilen werden, die ein Kunde versteht. Halte die Regeln einfach und wiederholbar, damit du jeder generierten Rechnung vertraust.

Beginne mit einer Aktion: Wähle einen Kunden und einen Datumsbereich und ziehe nur unberechnete Zeiteinträge, die passen. Dieser Filter ist die Schutzvorrichtung gegen doppelte Abrechnung. Wenn ein Eintrag keinen Kunden oder kein Projekt hat, behandle ihn als „nicht abrechnungsbereit“ und lass ihn aus dem Roll-up heraus, bis er korrigiert ist.

Wie Einträge zu Rechnungszeilen gruppiert werden

Gruppierung bestimmt, wie viele Zeilen entstehen und wie leicht der Kunde sie prüfen kann. Wähle eine Standardoption und füge bei Bedarf einen Schalter für Flexibilität hinzu.

Gängige Gruppierungsoptionen:

• Nach Projekt
• Nach Person (hilfreich, wenn sich Sätze unterscheiden)
• Nach Tag oder Woche
• Nach Aufgabe/Kategorie (Design vs Entwicklung)

Was auch immer du wählst: Jede Zeile sollte zeigen: eine klare Beschriftung, Gesamtstunden, Satz und Zeilenbetrag. Wenn Sätze sich ändern können, nutze das in jedem Eintrag gespeicherte rate_at_time (oder eine Tariftabelle mit „gültig ab“-Daten), nicht nur einen aktuellen Satz.

Als berechnet markieren (ohne dich in eine Ecke zu manövrieren)

Wenn du Einträge zu einer Rechnung hinzufügst, speichere die Rechnungs-ID auf jedem Zeiteintrag. Das schafft eine Audit-Historie und verhindert, dass derselbe Eintrag erneut gezogen wird.

Korrekturen passieren. Wenn du eine Zeile aus einer Rechnung entfernst, lösche nicht die Historie. Entkopple die betroffenen Zeiteinträge (rechne die Rechnungs-ID weg), berechne Summen neu und speichere eine kurze Notiz wie „2.0h entfernt, falsches Projekt".

In AppMaster passt das gut als einzelner Geschäftsprozess: frage unberechnete Einträge ab, gruppiere sie, erstelle Rechnungszeilen und aktua­lisiere dann jeden Eintrag mit der Rechnungsreferenz.

Rechnungsdatensätze: Summen, Nummerierung und Status

Der Rechnungsdatensatz ist der Container, den du später versenden, nachverfolgen und auditieren kannst. Er sollte stabil bleiben, auch wenn jemand den Projektnamen ändert oder einen Standardtarif anpasst.

Ein praktischer Rechnungskopf enthält:

• Rechnungsnummer (eindeutig, menschenlesbar)
• Ausstellungsdatum und Fälligkeitsdatum
• Rechnungsdetails (Kundenname, Rechnungsadresse, ggf. Steuer-ID)
• Notizen (Zahlungsanweisungen, kurzer Dankeszusatz)
• Währung (und optional gespeicherter Wechselkurs bei internationaler Abrechnung)

Halte Summen vorhersehbar. Die Zwischensumme ist die Summe der Rechnungszeilen. Dann wende Rabatt (fester Betrag oder Prozent) an, berechne Steuer (häufig auf den rabattierten Zwischenbetrag) und speichere die finale Summe. Speichere den exakten Steuersatz und die verwendeten Rabattwerte, damit du die Rechnung später reproduzieren kannst.

Rechnungsnummern müssen nicht aufwendig sein. Wähle ein Muster und halte dich daran: sequenziell (000123), pro Jahr (2026-00123) oder Kundenpräfix plus Sequenz (ACME-014). Konsistenz ist wichtiger als Perfektion.

Status sollten sich auf Kommunikation und interne Kontrolle konzentrieren:

• Entwurf (bearbeitbar, noch nicht gesendet)
• Bereit (Summen gesperrt)
• Gesendet (mit dem Kunden geteilt)
• Bezahlt (Zahlung bestätigt)
• Überfällig (Fälligkeitsdatum überschritten)
• Storniert (annulliert, zu Archivierungszwecken aufgehoben)

Ein gebrandetes PDF erzeugen, das der Kunde lesen kann

Ein gutes Rechnungs-PDF beantwortet schnell zwei Fragen: Was wird berechnet und wie wird bezahlt. Erzeuge das PDF aus dem Rechnungsdatensatz (nicht aus Roh-Zeiteinträgen), damit das Dokument immer mit Rechnungsnummer, Summen und Status übereinstimmt.

Die meisten Kunden erwarten dieselben Bereiche jedes Mal:

• Kopf mit deinem Firmennamen, Rechnungsnummer und Rechnungsdatum
• Kundendaten (Firma, Ansprechperson, Rechnungsadresse, ggf. Steuer-ID)
• Positionen (Beschreibung, Menge oder Stunden, Satz, Zeilenbetrag)
• Summen (Zwischensumme, Steuer, Rabatt, Gesamtbetrag)
• Zahlungsbedingungen (Fälligkeitsdatum, akzeptierte Zahlungsmethoden, Hinweis auf Verzugszinsen falls vorhanden)

Branding ist wichtig, aber Lesbarkeit ist wichtiger. Nutze eine Akzentfarbe, eine saubere Schrift und mache die Summen leicht erfassbar.

Layout-Probleme treten mit realen Daten auf. Teste mit langen Beschreibungen und über 30 Positionen. Sorge dafür, dass Spaltenüberschriften auf neuen Seiten wiederholt werden und der Summenbereich zusammenbleibt.

Wenn du PDFs in AppMaster erzeugst, behandle das PDF als Artefakt der Rechnung: speichere die Datei (oder den Speicher-Verweis) auf dem Rechnungsdatensatz mit Zeitstempel und Version. So lässt sich leicht dasselbe Dokument erneut senden, das der Kunde gesehen hat.

Schritt-für-Schritt-Bauplan (No-Code-Workflow)

Definiere, was die "Quelle der Wahrheit" ist. Zeiteinträge sind rohe Fakten. Rechnungen sind ein Snapshot, den du senden und später prüfen kannst.

1) Zuerst das Datenmodell anlegen

Erstelle die Tabellen und Beziehungen und füge ein paar Qualitätsfelder hinzu, sobald das Grundgerüst stabil ist:

• Clients
• Projects
• Time Entries
• Invoices
• Invoice Lines

2) Baue zwei einfache Bildschirme

Halte die UI minimal:

• Zeiteintragsformular: Projekt, Datum, Dauer, Notizen, Speichern
• Rechnungsprüfung: Kunde, Zeitraum, Zeilen, Summen, Status

Eine Web-UI reicht meist für Admin und Reviews. Mobile Bildschirme baue später, wenn Leute unterwegs Zeit erfassen.

3) Automatisiere die Roll-up-Logik

Baue einen Flow wie: Kunde + Datumsbereich wählen, unberechnete Einträge abrufen, gruppieren, Rechnungszeilen anlegen. Markiere Einträge erst dann als berechnet, wenn die Rechnung freigegeben oder auf Bereit gesetzt wird.

4) Erzeuge und speichere das PDF

Füge eine Aktion „PDF erzeugen“ hinzu, die Rechnungs-Kopf, Kundendaten und Zeilen in eine Vorlage zieht und die Ausgabe auf dem Rechnungsdatensatz speichert.

Beispiel: von wöchentlichen Zeitlogs zur clientfertigen Rechnung

Eine 3-Personen-Agentur hat einen Kunden, Northstar Co, und berechnet zwei Projekte über zwei Wochen: Website Refresh und Monthly Support. Im Team arbeiten Alex (Design), Priya (Entwicklung) und Sam (PM). Alle loggen täglich Zeit, wählen Kunde, Projekt, Datum und eine kurze Notiz.

Jeden Tag werden Einträge als Entwurf gespeichert. Am Freitagnachmittag öffnet Sam eine Prüfseite, gefiltert auf „Diese Woche, Northstar Co“. Er korrigiert zwei Notizen („Homepage hero" statt „Hero"), bestätigt berechenbar vs. nicht berechenbar und sperrt die Woche.

Hier ist ein Beispiel der Einträge der Woche:

Wenn Sam auf „Rechnung erstellen" klickt, rollt die App die Einträge in Rechnungszeilen mit einfachen Regeln: Gruppiere nach Projekt und abrechenbarem Satz, summiere Stunden und übernehme eine kurze Beschreibung. Die Rechnung hat am Ende 3 Zeilen:

Das System vergibt eine Rechnungsnummer (z. B. NS-2026-014), berechnet Zwischensumme und Steuer und setzt den Status auf Bereit. Ein weiterer Klick erzeugt ein gebrandetes PDF (Logo, Kundenadresse, Zeilen, Summen, Zahlungsanweisungen). Nach Versand ändert sich der Status auf Gesendet und die zugrundeliegenden Zeiteinträge werden als berechnet markiert, sodass sie nicht erneut abgerechnet werden können.

Häufige Fehler und wie man sie vermeidet

Die meisten Probleme sind keine Rechenfehler. Es sind Workflow-Probleme.

Nicht gebuchte Zeiteinträge sperren. Wenn Leute berechnete Einträge bearbeiten oder erneut auswählen können, kommt es irgendwann zur doppelten Abrechnung. Löse das mit einer Rechnungsreferenz auf jedem Zeiteintrag und blende berechnete Einträge in der Ansicht „Bereit zur Fakturierung“ aus.

Historie überschreiben, wenn Sätze sich ändern. Wenn du nur mit einem „aktuellen" Projekt- oder Nutzer-Satz rechnest, ändert eine Satzänderung alte Rechnungen. Kopiere den effektiven Satz in rate_at_time jedes Eintrags.

Freigegebene Zeit ohne Audit bearbeiten. Füge „Freigegeben von", „Freigegeben am" und eine kurze Änderungsnotiz für Bearbeitungen nach Freigabe hinzu.

PDFs, die mit realen Daten brechen. Lange Beschreibungen, viele Positionen und große Zahlen belasten deine Vorlage.

Schnelle Fixes, die Layout-Probleme verhindern:

• Begrenze die Beschreibungslänge und verschiebe Überlauf in einen Notizbereich
• Erlaube Zeilenumbruch und teste mit 30+ Zeilen
• Halte den Header kompakt, damit die Tabelle Raum hat
• Verwende konsistente Zahlenformate (Währung, Dezimalstellen)

Ein unscharfer Status-Flow. Ohne klare Regeln werden Rechnungen doppelt gesendet oder gar nicht.

Ein einfacher, sicherer Flow ist: Entwurf -> Bereit -> Gesendet -> Bezahlt. Erlaube Roll-ups nur im Entwurf und die PDF-Erzeugung nur, wenn Summen gesperrt sind.

Kurze Checkliste und praktische nächste Schritte

Bevor du eine Rechnung sendest, mache eine kurze Prüfung. Das verhindert die häufigsten Probleme: falsche Summen, fehlende Details und PDFs, die auf dem Bildschirm ok aussehen, beim Drucken aber kaputt sind.

Vor-Versand-Checkliste:

• Kundendaten sind vollständig (rechtlicher Name, Rechnungsadresse, richtige Kontaktperson)
• Rechnungszeitraum stimmt (Start- und Enddatum passen zur Arbeit)
• Summen sind konsistent (Zwischensumme, Steuer, Gesamt stimmen mit Einträgen, Sätzen und Rundungen überein)
• Keine Zeit fehlt oder ist doppelt (nichts unberechnet, nichts doppelt enthalten)
• Betriebliche Felder sind sauber (eindeutige Rechnungsnummer, korrekter Status, PDF auf der Rechnung gespeichert)

Preview das PDF mit „Druckerblick". Prüfe Logo-Position, lange Adressen, Tabellenumbruch und Seitenumbrüche. Teste sowohl eine kurze Rechnung (1–2 Zeilen) als auch eine lange (20+ Zeilen).

Nächste Schritte, wenn die Grundlagen stehen:

• Rechnungen per E-Mail mit einheitlicher Vorlage senden
• Stripe-Zahlungen integrieren und Rechnungen automatisch als Bezahlt markieren
• Berechtigungen hinzufügen, damit nur die richtigen Rollen Sätze ändern, Zeit freigeben oder Stati ändern können

Wenn du schnell bauen und iterieren willst, ohne alles neu zu schreiben, ist AppMaster (appmaster.io) eine praktische Option, um eine No-Code-Abrechnungs-App mit echter Datenbank, Geschäftslogik und PDF-Erzeugung zu erstellen und dann bei Bedarf sauberen Source-Code zu regenerieren.

Wenn du diese Woche nur eine Sache verbesserst: mache es unmöglich, unberechnete Zeit zu übersehen. Das allein spart Stunden und schützt Einnahmen.