Software-Architektur für ein internes Buchungssystem

Dieses Projekt zeigt die Software-Architektur für ein internes Buchungssystem bei TGA-Metal. Ziel war es, mehrere bisher getrennte Programme in einer zentralen Anwendung zusammenzuführen, damit Interessenten, Aufträge, Telefontermine, Zuteilungen und Auswertungen in einem sauberen Ablauf bearbeitet werden können.

Die Software-Architektur wurde dabei nicht theoretisch geplant, sondern aus einem realen Bedarf heraus entwickelt. Denn im Alltag einer Zaunbaufirma reicht es nicht, Daten nur zu speichern. Viel wichtiger ist, dass ein System Informationen an die richtige Stelle bringt, Zuständigkeiten sichtbar macht und den gesamten Prozess von der Erfassung bis zur Auswertung stabil abbildet.

Genau deshalb ist dieses Projekt mehr als nur ein internes Tool. Es ist ein Praxisbeispiel dafür, wie Software-Architektur in einem Kundenprojekt eingesetzt werden kann, um operative Abläufe einfacher, schneller und nachvollziehbarer zu machen. Zusätzlich enthält dieser Beitrag einzelne Code-Beispiele, die sich auch in anderen internen Tools, CRM-Systemen oder Auftragsplattformen weiterverwenden lassen.

Vor dem Projekt liefen wichtige Schritte über mehrere Programme und manuelle Übergaben. Neue Interessenten mussten erfasst, Aufträge weitergegeben und Telefontermine oder Beratungstermine an die richtige Abteilung vermittelt werden. Dadurch entstanden Reibungsverluste:

• Daten lagen nicht an einer zentralen Stelle
• Zuständigkeiten waren nicht sofort sichtbar
• Aufträge mussten mehrfach geprüft oder weitergeleitet werden
• offene und erledigte Vorgänge waren schwerer auswertbar
• Bonuszahlungen konnten nicht direkt aus einer Datenbasis abgeleitet werden

Für genau solche Probleme ist eine saubere Software-Architektur entscheidend. Denn wenn der Aufbau eines Systems nicht klar definiert ist, werden Prozesse mit jeder Erweiterung unübersichtlicher. Deshalb wurde das interne Buchungssystem so konzipiert, dass alle Kernschritte in einer einheitlichen Struktur zusammenlaufen.

Die Software-Architektur des Projekts wurde in klar getrennte Bereiche aufgeteilt. Das macht die Anwendung nicht nur wartbarer, sondern auch verständlicher für die spätere Weiterentwicklung.

Diese Aufteilung ist ein gutes Beispiel für Software-Architektur in der Praxis: Nicht alles landet in einer einzigen Logik, sondern jeder Bereich übernimmt eine klar definierte Aufgabe.

Für TGA-Metal war nicht irgendeine Standardlösung gefragt, sondern eine Struktur, die zum tatsächlichen Ablauf passt. Deshalb wurde die Software-Architektur bewusst so gewählt, dass sie drei Ziele erfüllt:

1. zentrale Datenbasis statt verteilter Informationen
2. klare Zuständigkeiten zwischen Vertrieb, Leitung und Mitarbeitern
3. auswertbare Prozesse für Status, Statistik und Bonuslogik

Genau diese Kombination macht den Unterschied. Ein internes Buchungssystem ist nur dann nützlich, wenn es nicht bloß Daten sammelt, sondern die Arbeitsschritte logisch verbindet. Deshalb wurde der Aufbau so gewählt, dass neue Aufträge direkt eingeordnet, an die passende Stelle weitergegeben und später sauber ausgewertet werden können.

Ein sauberer Prozess beginnt bereits bei der Eingabe. Vertriebler tragen Interessenten und Aufträge direkt in das System ein, statt Informationen über mehrere Programme zu verteilen. Dadurch entsteht sofort eine zentrale und einheitliche Datenbasis.

Ein wiederverwendbares Beispiel für diesen Schritt:

export function normalizeLeadInput(payload) {
  if (!payload) throw new Error('Daten fehlen');

  return {
    customerName: String(payload.customerName || '').trim(),
    phone: String(payload.phone || '').trim(),
    city: String(payload.city || '').trim(),
    type: payload.type || 'beratung',
    source: payload.source || 'vertrieb',
    status: 'neu',
    createdAt: new Date(),
  };
}

export function validateLeadInput(lead) {
  return Boolean(
    lead.customerName &&
    lead.phone &&
    lead.city &&
    lead.type
  );
}

Dieses Muster ist nicht nur für dieses Projekt nützlich. Auch in CRM-Systemen, Kontaktformularen oder Terminplattformen hilft es, Eingaben sofort zu vereinheitlichen und Fehlerquellen früh zu reduzieren.

Ein zentraler Teil der Software-Architektur ist das Routing. Denn neue Aufträge sollen nicht nur gespeichert, sondern direkt an die zuständige Abteilung weitergegeben werden. Genau dadurch wird aus einer Eingabemaske ein echter Arbeitsprozess.

export function routeOrder(order) {
  if (!order) throw new Error('Auftrag fehlt');

  const type = String(order.type || '').toLowerCase();

  if (type === 'telefontermin') {
    return {
      department: 'telefontermine',
      priority: 'normal',
      status: 'eingegangen',
    };
  }

  if (type === 'beratung') {
    return {
      department: 'beratung',
      priority: 'hoch',
      status: 'eingegangen',
    };
  }

  return {
    department: 'vertrieb',
    priority: 'normal',
    status: 'pruefen',
  };
}

Solche Routing-Funktionen sind ein gutes Beispiel dafür, wie Software-Architektur direkt Mehrwert erzeugt. Der Code ist klein, die Wirkung im Prozess aber groß: Jede Anfrage startet sofort im richtigen Kontext.

Nachdem ein Auftrag in der zuständigen Abteilung eingegangen ist, kann die Leitung ihn direkt einem Mitarbeiter zuweisen. Dadurch bleiben Zuständigkeiten im System sichtbar und müssen nicht außerhalb der Anwendung koordiniert werden.

async function assignOrderToEmployee(orderId, employeeId, managerId) {
  return db.order.update({
    where: { id: orderId },
    data: {
      assignedEmployeeId: employeeId,
      assignedByManagerId: managerId,
      assignedAt: new Date(),
      status: 'zugeteilt',
    },
  });
}

Auch das ist ein wichtiger Teil der Software-Architektur: Die Oberfläche wirkt einfach, im Hintergrund werden aber Status, Verantwortliche und Zeitpunkte sauber gespeichert. Genau diese Klarheit macht interne Systeme wartbar und nachvollziehbar.

Jeder Mitarbeiter erhielt ein eigenes Profil. Das ist nicht nur für die Benutzeroberfläche sinnvoll, sondern auch für die gesamte Software-Architektur. Denn erst durch eindeutige Profile lassen sich Aufgaben, Status und Auswertungen sauber zuordnen.

Die Vorteile sind direkt sichtbar:

• jeder Auftrag ist einer Person zuweisbar
• offene Aufgaben sind schnell erkennbar
• abgeschlossene Aufträge lassen sich je Mitarbeiter auswerten
• Bonuszahlungen können nachvollziehbar berechnet werden

Dadurch verbindet das Projekt operative Bearbeitung und Management-Auswertung in einer gemeinsamen Struktur. Genau diese Verbindung fehlt oft, wenn Unternehmen mit mehreren unverbundenen Programmen arbeiten.

Ein gutes internes Buchungssystem braucht eine klare Statuslogik. Deshalb wurde darauf geachtet, dass Aufträge nicht beliebig zwischen Zuständen springen, sondern einen nachvollziehbaren Verlauf haben.

const allowedStatusTransitions = {
  neu: ['eingegangen'],
  eingegangen: ['zugeteilt'],
  zugeteilt: ['in_bearbeitung', 'abgeschlossen'],
  in_bearbeitung: ['abgeschlossen'],
  abgeschlossen: [],
};

export function canChangeStatus(currentStatus, nextStatus) {
  const allowed = allowedStatusTransitions[currentStatus] || [];
  return allowed.includes(nextStatus);
}

Solche Funktionen sind in vielen Projekten direkt einsetzbar. Wer ein Auftragsmanagement, Ticketsystem oder internes Freigabetool baut, kann diesen Ansatz schnell übernehmen und anpassen.

Die Software-Architektur endet nicht bei der Eingabe oder Bearbeitung. Für TGA-Metal war auch die Auswertung entscheidend. Deshalb wurde die Struktur so aufgebaut, dass offene und abgeschlossene Aufträge direkt analysiert werden können.

function calculateBonus(completedOrders, bonusPerOrder) {
  if (!completedOrders || completedOrders < 0) return 0;
  return completedOrders * bonusPerOrder;
}

function buildEmployeeStats(employee) {
  const openOrders = employee.orders.filter(
    order => order.status !== 'abgeschlossen'
  );

  const completedOrders = employee.orders.filter(
    order => order.status === 'abgeschlossen'
  );

  return {
    employeeId: employee.id,
    openCount: openOrders.length,
    completedCount: completedOrders.length,
    bonus: calculateBonus(completedOrders.length, employee.bonusRate),
  };
}

Gerade hier zeigt sich der Nutzen einer guten Software-Architektur: Daten werden nicht nur verwaltet, sondern in eine Form gebracht, die für Entscheidungen und Steuerung direkt verwendbar ist.

Auch wenn dieses System für TGA-Metal entwickelt wurde, lassen sich mehrere Bausteine direkt auf andere Projekte übertragen. Besonders nützlich sind:

• Normalisierung und Validierung von Eingaben
• Routing in passende Abteilungen oder Prozesse
• Zuteilung per Zuständigkeitslogik
• Statusübergänge mit klaren Regeln
• statistische Auswertung aus operativen Daten

Damit bietet der Beitrag nicht nur eine Projektpräsentation, sondern auch wiederverwendbare technische Muster. Genau das macht ihn für Leser interessant, die selbst interne Tools, Kundenportale oder Verwaltungssoftware planen.

Das Ergebnis des Projekts ist eine zentrale Anwendung, die mehrere bisher getrennte Schritte sinnvoll verbindet. Neue Interessenten und Aufträge werden aufgenommen, an die richtige Stelle geroutet, von der Leitung verteilt und von Mitarbeitern im eigenen Profil bearbeitet. Gleichzeitig entstehen daraus Statistiken und eine Grundlage für Bonuszahlungen.

Die wichtigsten Ergebnisse auf einen Blick:

• zentrale Erfassung statt verteilter Daten

• klare Software-Architektur mit getrennten Modulen

• schnellere interne Auftragsverteilung

• Mitarbeiterprofile mit sauberer Zuständigkeit

• Statusübersicht für offene und abgeschlossene Vorgänge

• Statistik und Bonuslogik auf derselben Datenbasis

• Software-Architektur für einen echten Unternehmensprozess umgesetzt

• mehrere Programme in einer zentralen Anwendung gebündelt

• wiederverwendbare Logik für Routing, Status und Statistik integriert

• internen Ablauf für TGA-Metal klarer und effizienter gemacht

Dieses Projekt zeigt sehr konkret, was Software-Architektur in der Praxis bedeutet. Nicht abstrakte Diagramme allein, sondern eine klare Struktur für Eingabe, Routing, Zuteilung, Bearbeitung und Auswertung. Genau dadurch wird aus mehreren Einzelschritten ein stabiles internes Buchungssystem.

Für TGA-Metal entstand so eine Lösung, die tägliche Prozesse besser bündelt und gleichzeitig eine saubere Basis für Weiterentwicklung bietet. Und genau darin liegt der eigentliche Mehrwert guter Software-Architektur: Sie macht Systeme verständlicher, wartbarer und im Alltag nützlicher.