Use Case Diagramm erklärt – Use Case Diagramme gehören zu den wichtigsten Werkzeugen in der Software- und Systemanalyse, denn sie schlagen eine Brücke zwischen Fachbereich und Technik. Obwohl die Notation aus der UML stammt, können auch Nicht-Entwickler die Diagramme schnell lesen und verstehen, sodass sie sich hervorragend für Workshops, Anforderungsdokumente und Präsentationen eignen.
In diesem Artikel lernst du, was ein Use Case Diagramm ist, welche Elemente es enthält, wie du es korrekt zeichnest und welche typischen Fehler du vermeiden solltest. Außerdem erhältst du praxisnahe Tipps, damit deine Diagramme nicht nur korrekt, sondern auch wirklich hilfreich sind.

Grundlagen: Was ist ein Use Case Diagramm?
Definition und Einordnung
Ein Use Case Diagramm ist ein grafisches Modell, das zeigt, wie externe Nutzer (Akteure) mit einem System interagieren, um bestimmte Ziele zu erreichen. Es beantwortet vor allem die Fragen:
- Wer benutzt das System?
- Wozu benutzen diese Personen das System?
- Welche Funktionalität stellt das System nach außen bereit?
Das Diagramm gehört zur Unified Modeling Language (UML) und bildet die funktionalen Anforderungen eines Systems auf hoher Abstraktionsebene ab. Dadurch eignet es sich sehr gut als gemeinsames Kommunikationsmittel zwischen:
- Fachabteilung
- Produktmanagement
- Entwicklung
- Test / Qualitätssicherung
- Stakeholdern und Kunden
Während andere UML-Diagramme häufig sehr technisch wirken, bleibt das Use Case Diagramm bewusst fachlich, denn es konzentriert sich auf sichtbares Verhalten und nicht auf interne Implementierungsdetails.
Ziele eines Use Case Diagramms
Ein gutes Use Case Diagramm verfolgt mehrere Ziele gleichzeitig, und es sollte diese klar unterstützen:
- Überblick schaffen
Es zeigt alle wesentlichen Interaktionen in einer einzigen Ansicht, sodass Projektbeteiligte das System schnell erfassen. - Anforderungen strukturieren
Die Use Cases gruppieren ähnliche Szenarien und verhindern, dass Anforderungen unstrukturiert in Textdokumenten verschwinden. - Scope definieren
Die Systemgrenze macht sichtbar, was zum System gehört und was bewusst außerhalb liegt. - Kommunikation erleichtern
Fachliche Stakeholder können über die Diagramme diskutieren, ohne UML-Experten zu sein, solange du Begriffe sauber erklärst.
Zentrale Elemente eines Use Case Diagramms
Damit dein Diagramm klar und konsistent bleibt, solltest du die grundlegenden Bausteine genau kennen und bewusst einsetzen.
Akteure (Actors)
Akteure repräsentieren Rollen, die mit dem System interagieren, und sie stehen immer außerhalb der Systemgrenze. Ein Akteur kann dabei eine Person, ein anderes System oder eine Organisation sein.
Typische Merkmale von Akteuren:
- Sie lösen Use Cases aus oder nehmen an ihnen teil.
- Sie haben ein fachliches Ziel oder einen Bedarf.
- Sie sind Rollen, nicht konkrete Individuen (z. B. „Kunde“, nicht „Max Mustermann“).
Beispiele:
- „Kunde“
- „Sachbearbeiter“
- „Zahlungsdienstleister“
- „CRM-System“
Wichtig ist, dass du Akteure nach ihrem Interaktionsverhalten und nicht nach ihrer Stellenbezeichnung benennst. Ein „Buchhalter“ kann je nach System sowohl „Rechnungsprüfer“ als auch „Reporting-Verantwortlicher“ sein, sodass du besser fachliche Rollen formulierst.
Use Cases (Anwendungsfälle)
Use Cases beschreiben zusammenhängende Abläufe, in denen ein Akteur ein konkretes Ziel mit Hilfe des Systems erreicht. Im Diagramm stellst du sie als Ellipsen dar, die innerhalb der Systemgrenze liegen.
Gute Use-Cases-Formulierungen:
- „Buchung anlegen“
- „Konto eröffnen“
- „Passwort zurücksetzen“
- „Rechnung bezahlen“
Schlechte Formulierungen sind hingegen:
- „Datenbankzugriff“ (zu technisch, kein fachliches Ziel)
- „Validierung durchführen“ (Teilaktivität, die keinen eigenständigen Nutzen bietet)
Ein guter Test lautet:
Kann der Akteur sagen: „Ich möchte diesen Use Case, weil ich damit ein sinnvolles Ziel erreiche“?
Wenn die Antwort nicht klar „Ja“ lautet, solltest du den Use Case neu zuschneiden oder umbenennen.
Systemgrenze (System Boundary)
Die Systemgrenze ist meist ein Rechteck, das alle Use Cases enthält. Es markiert, welcher Teil der Gesamtlösung zu deinem System gehört und was stattdessen externe Umwelt bleibt.
Warum die Systemgrenze wichtig ist:
- Sie verhindert Scope-Creep, weil du klar festhältst, welche Verantwortung dein System trägt.
- Sie macht klar, welche Funktionen du implementierst und welche Funktionen externe Systeme liefern.
- Sie hilft dir, Schnittstellen frühzeitig zu erkennen, denn alle Interaktionen zwischen Akteuren und dem System passieren über diese Grenze hinweg.
Benutze einen konsistenten Namen für die Systemgrenze, zum Beispiel:
- „Online-Banking-System“
- „Ticket-Buchungsportal“
Beziehungen in Use Case Diagrammen
Neben den Elementen sind vor allem die Beziehungen entscheidend, denn sie machen aus einzelnen Use Cases ein strukturiertes Gesamtbild.
Assoziation zwischen Akteuren und Use Cases
Die fundamentalste Beziehung ist die Assoziation zwischen einem Akteur und einem Use Case. Du stellst sie als einfache Linie dar, und du zeigst damit, dass der Akteur an diesem Use Case teilnimmt.
Typische Muster:
- Ein Akteur ist mit mehreren Use Cases verbunden.
- Ein Use Case wird von mehreren Akteuren genutzt.
Dadurch erkennst du auf einen Blick:
- Welche Funktionen für welchen Akteur relevant sind.
- Welche Use Cases besonders zentral sind, weil sie von vielen Rollen genutzt werden.
Generalisierung von Akteuren
Manchmal teilen sich mehrere Akteure ein gemeinsames Verhalten, doch sie besitzen zusätzlich eigene Spezialfälle. In solchen Situationen nutzt du die Generalisierung (eine Vererbungsbeziehung):
- „Registrierter Kunde“ generalisiert „Kunde“.
- „Administrator“ generalisiert „Benutzer“.
Der übergeordnete Akteur beinhaltet das gemeinsame Verhalten, und die spezialisierten Akteure erben dieses Verhalten und können zusätzliche Use Cases nutzen.
Diese Struktur solltest du aber sparsam einsetzen, weil zu viele Vererbungen das Diagramm schnell unübersichtlich machen.
«include»-Beziehung
Die «include»-Beziehung zeigt, dass ein Use Case einen anderen Use Case zwingend einbindet, weil dieser Teilablauf immer benötigt wird.
Beispiel:
- Use Case „Bestellung abschicken“ include „Lieferadresse prüfen“.
Regeln für «include»:
- Der inkludierte Use Case stellt einen wiederverwendbaren Teilablauf dar.
- Er tritt immer auf, wenn der übergeordnete Use Case läuft.
- Er liefert einen klar umrissenen Mehrwert, der in mehreren Use Cases identisch abläuft.
Dadurch verhinderst du Dopplungen und sorgst für eine saubere Struktur, doch du solltest nicht jede Kleinigkeit in eigene «include»-Use-Cases auslagern, damit das Diagramm lesbar bleibt.
«extend»-Beziehung
Die «extend»-Beziehung steht für optionale oder bedingte Erweiterungen eines Use Cases. Der Basis-Use-Case beschreibt den Normalfall, und der erweiternde Use Case tritt nur unter bestimmten Bedingungen ein.
Beispiel:
- Use Case „Ticket buchen“ extend „Ticket mit Gutschein bezahlen“.
Eigenschaften von «extend»:
- Die Erweiterung ist nicht zwingend.
- Sie tritt nur in bestimmten Szenarien auf (z. B. wenn ein Gutschein vorhanden ist).
- Der Basis-Use-Case ist auch ohne die Erweiterung sinnvoll und vollständig.
Mit «extend» modellierst du Alternativ- oder Ausnahmeabläufe, ohne das Hauptszenario zu überfrachten.
Einfaches Beispiel: Use Case Diagramm für ein Online-Ticketsystem
Um die Elemente greifbar zu machen, betrachten wir ein vereinfachtes Beispiel: Ein Online-Ticketsystem für Veranstaltungen.
Akteure
- „Besucher“ (Endkunde, der Tickets kauft)
- „Veranstalter“ (stellt Events ein)
- „Zahlungsdienstleister“ (externes System)
Use Cases (Auszug)
- „Event suchen“
- „Ticket auswählen“
- „Benutzerkonto anlegen“
- „Bezahlung durchführen“
- „Ticket stornieren“
- „Event anlegen“ (für Veranstalter)
Beziehungen
- Der Besucher ist mit „Event suchen“, „Ticket auswählen“, „Bezahlung durchführen“, „Ticket stornieren“ verbunden.
- Der Veranstalter ist mit „Event anlegen“ verbunden.
- Der Zahlungsdienstleister ist mit „Bezahlung durchführen“ verbunden.
Zusätzlich kannst du sinnvolle Detailbeziehungen modellieren:
- „Bezahlung durchführen“ include „Zahlungsdaten erfassen“.
- „Bezahlung durchführen“ extend „Zahlung fehlgeschlagen behandeln“.
So entsteht ein Bild, das sowohl Fachanwendern als auch Entwicklern hilft, das System zu verstehen, und es zeigt auf einen Blick, wie die wichtigsten Rollen mit dem System interagieren.
Schritt-für-Schritt: Wie du ein Use Case Diagramm erstellst
Damit deine Diagramme nicht nur korrekt, sondern auch praxistauglich werden, kannst du nach einem klaren Vorgehen arbeiten.
1. Ziele und Scope klären
Bevor du zeichnest, solltest du beantworten:
- Welchen Teil des Systems willst du modellieren?
- Für welche Zielgruppe erstellst du das Diagramm?
- Welche Fragen soll das Diagramm beantworten?
Oft lohnt es sich, den Scope bewusst zu begrenzen, damit das Diagramm nicht überfrachtet wirkt. Für sehr große Systeme erstellst du besser mehrere Diagramme mit jeweils klarem Fokus.
2. Akteure identifizieren
Frage dich zunächst, wer mit dem System interagiert:
- Welche Personengruppen nutzen das System im Alltag?
- Welche externen Systeme greifen zu oder liefern Daten?
- Welche Organisationen sind beteiligt?
Typische Quellen dafür sind:
- Interviews mit Fachexperten
- Bestehende Prozessdokumentationen
- Kundenreisen (Customer Journeys)
Schreibe zunächst alle Kandidaten auf, und konsolidiere dann ähnlich agierende Rollen, sodass du eine überschaubare Menge erhältst.
3. Use Cases sammeln und zuschneiden
Als Nächstes überlegst du, welche fachlichen Ziele die Akteure mit Hilfe des Systems erreichen möchten. Du kannst dazu Fragen stellen wie:
- „Was möchte der Akteur tun, wenn er sich einloggt?“
- „Welches Ergebnis erwartet er am Ende der Interaktion?“
Notiere zunächst alle Use Cases in Textform, und achte auf:
- Zielorientierte Benennung (Verb + Objekt, z. B. „Rechnung erstellen“)
- Fachliche Sichtweise statt technischer Details
- Abgrenzbare Ergebnisse (nach dem Use Case ist etwas Sinnvolles erreicht)
Wenn deine Liste zu grob oder zu fein wirkt, dann schneidest du Use Cases neu zu, bis sie von Lesern intuitiv verstanden werden.
4. Systemgrenze festlegen
Nun ziehst du die Systemgrenze, und du platzierst alle Use Cases innerhalb dieses Rahmens. Externe Systeme bleiben bewusst außerhalb, weil sie als Akteure auftreten.
Frage dich dabei:
- Gehört dieser Use Case wirklich zu unserem System, oder handelt es sich um eine externe Verantwortung?
- Ist die Grenze so gezogen, dass sie dem Projektauftrag entspricht?
Eine klar definierte Systemgrenze verhindert Missverständnisse, und sie erleichtert später auch die Definition von Schnittstellen.
5. Beziehungen modellieren
Jetzt verbindest du Akteure und Use Cases mit Assoziationslinien, und du prüfst dabei:
- Hat jeder Akteur die richtigen Use Cases?
- Gibt es Use Cases ohne Akteur (was ein Warnsignal wäre)?
Danach ergänzt du optionale Beziehungen:
- «include» für wiederverwendbare Teilabläufe
- «extend» für optionale Erweiterungen
- Generalisierung zwischen Akteuren, wenn sie sich Rollenverhalten teilen
Halte dich bewusst zurück, denn zu viele Spezialfälle machen dein Diagramm schwer lesbar. Details zu Sonderfällen beschreibst du oft besser in Fließtext oder in separaten Use-Case-Beschreibungen.
6. Validieren und vereinfachen
Zum Schluss solltest du das Diagramm gemeinsam mit Fachvertretern und Entwicklern sichten, damit alle ein gemeinsames Verständnis entwickeln. In dieser Phase lohnt sich insbesondere:
- Überflüssige Use Cases streichen oder zusammenfassen
- Unklare Begriffe umbenennen
- Zu technische Formulierungen in Geschäftssprache übersetzen
Ein gutes Use Case Diagramm ist prägnant, aber nicht überladen, und es lässt sich innerhalb weniger Minuten erklären.
Typische Fehler und wie du sie vermeidest
Viele Use Case Diagramme sind formal korrekt, aber sie helfen in der Praxis nur wenig. Die folgenden Fehler treten besonders häufig auf, und du kannst sie durch einfache Regeln verhindern.
1. Technische statt fachlicher Sicht
Ein sehr verbreiteter Fehler besteht darin, technische Aktivitäten als Use Cases zu modellieren, etwa:
- „Datenbank aktualisieren“
- „Microservice aufrufen“
- „Validierung ausführen“
Solche Begriffe verstehen Fachanwender kaum, und sie spiegeln auch kein echtes Nutzerziel wider. Du solltest stattdessen fachliche Ziele formulieren, sodass die Beteiligten sofort erkennen, warum ein Use Case existiert.
2. Zu viele Details im Diagramm
Manche Teams versuchen, alle möglichen Sonderfälle, Alternativpfade und Fehlerszenarien im Diagramm unterzubringen, doch das führt fast zwangsläufig zu Unübersichtlichkeit.
Stattdessen:
- Nutze das Diagramm als Übersichtsebene.
- Dokumentiere detaillierte Abläufe in textuellen Use-Case-Beschreibungen oder Aktivitätsdiagrammen.
So behältst du die Lesbarkeit, und du kannst trotzdem ins Detail gehen, wenn es nötig ist.
3. Unklare oder uneinheitliche Namen
Uneinheitliche Begriffe führen schnell zu Missverständnissen, weil Projektbeteiligte unterschiedliche Dinge hineininterpretieren. Du solltest daher:
- Begriffe aus der Domänensprache der Fachabteilung verwenden.
- Konsistent bleiben (z. B. immer „Kunde“, nicht abwechselnd „Kunde“ und „Nutzer“).
- Use Cases so benennen, dass ein fachlicher Leser sie ohne weitere Erklärung versteht.
4. Akteure als konkrete Personen
Ein weiterer Klassiker besteht darin, reale Namen oder Jobtitel zu verwenden, etwa:
- „Max Mustermann“
- „Frau Müller aus dem Controlling“
Stattdessen modellierst du Rollen, weil sich die Verantwortlichkeiten ändern können, während das System bestehen bleibt. So bleibt dein Diagramm stabil und länger gültig.
Best Practices für wirkungsvolle Use Case Diagramme
Damit deine Diagramme nicht nur formal richtig, sondern auch in der Praxis wertvoll sind, kannst du dich an einigen erprobten Best Practices orientieren.
Klare Zielgruppenorientierung
Überlege immer zuerst, für wen du das Diagramm erstellst:
- Für Fachbereiche vereinfachst du die Notation und konzentrierst dich auf wenige, gut benannte Use Cases.
- Für Entwicklungsteams kannst du etwas mehr Struktur einführen, solange du die Fachlichkeit nicht aus den Augen verlierst.
Passe Umfang und Detailtiefe an, denn ein einziges „One-size-fits-all“-Diagramm überzeugt selten alle Stakeholder.
Verbindung mit textuellen Use-Case-Beschreibungen
Ein Diagramm ersetzt die textuelle Beschreibung eines Use Cases nicht, sondern ergänzt sie. Für zentrale Use Cases solltest du zusätzlich festhalten:
- Ziel und Auslöser
- Vorbedingungen und Nachbedingungen
- Normalablauf (Happy Path)
- Alternativ- und Fehlerabläufe
Diese Beschreibungen dienen später als Basis für Testfälle, Abnahmekriterien und Dokumentation, sodass du viel Konsistenz über das gesamte Projekt hinweg erreichst.
Iteratives Vorgehen und Feedback
Erstelle Use Case Diagramme nicht im stillen Kämmerlein, sondern iterativ:
- Grobes Diagramm skizzieren.
- Mit Fachanwendern durchgehen.
- Begriffe und Struktur nachschärfen.
- Mit Entwicklung und Test abgleichen.
Dieser Zyklus sorgt dafür, dass sich ein gemeinsames Verständnis etabliert, und er verhindert, dass das Diagramm zur bloßen Formalie verkommt.
Konsistente Visualisierung
Obwohl UML die Notation recht klar vorgibt, lässt sie im Layout Spielraum. Du solltest diesen Spielraum nutzen, um die Lesbarkeit zu verbessern:
- Akteure gruppiert platzieren (z. B. links Kunden, rechts interne Rollen).
- Verwandte Use Cases räumlich nahe beieinander zeichnen.
- Linienkreuzungen möglichst vermeiden.
Ein aufgeräumtes Layout reduziert kognitive Last, sodass Betrachter sich auf Inhalte konzentrieren können, statt die Struktur erraten zu müssen.
Fazit Use Case Diagramm erklärt: Use Case Diagramme als Brücke zwischen Fachlichkeit und Technik
Use Case Diagramme sind mehr als ein UML-Formalismus, denn sie fungieren als zentrales Kommunikationswerkzeug in der frühen Phase eines Projekts. Wenn du Akteure, Ziele und Systemgrenzen sauber herausarbeitest, erhältst du ein Modell, das:
- den fachlichen Scope klar absteckt,
- Anforderungen strukturiert und priorisierbar macht,
- Missverständnisse früh aufdeckt,
- und eine solide Basis für Design, Implementierung und Tests legt.
Entscheidend ist, dass du Use Case Diagramme zielgruppenorientiert, pragmatisch und iterativ einsetzt. Dann entwickelst du nicht nur schöne Bilder, sondern schaffst echte Klarheit im Projekt – und genau das macht aus einer einfachen UML-Notation ein wirksames Werkzeug für deine tägliche Praxis.