Ein Portfolio-Projekt ist besonders nützlich, wenn jemand, der es beurteilt, das Ziel versteht, das Ergebnis ausprobieren und deinen Beitrag erkennen kann. Eine Vorlage für ein spielbares Portfolio-Projekt für Studierende in der Softwareentwicklung hilft dir, eine kleine Interaktion klar einzugrenzen, ihren zentralen Ablauf fertigzustellen und die Entscheidungen dahinter zu dokumentieren. Eine spielbare Demo ist eines von mehreren möglichen Formaten und soll die Beurteilung deiner Arbeit erleichtern.
Dieser Leitfaden erklärt den Planungsaufbau anhand von Harbor Signal, einem fiktiven kleinen Spiel, bei dem es um die Navigation in einem Hafen geht. Das Projekt, die Person, die es im Studium entwickelt, der Code, die Benutzeroberfläche, die Tests und die Ergebnisse sind erfunden. Es wurde weder ein Build noch eine Bewertung im Rahmen eines Kurses durchgeführt. Nutze das Beispiel als Planungsvorlage und ersetze anschließend alle Beispiele durch deine eigene Arbeit und die dazugehörigen Nachweise.

Wähle eine Fähigkeit und ein vollständiges Ergebnis
Überlege zuerst, was jemand durch dein Portfolio über deine Arbeit erfahren soll. Vielleicht kannst du Eingaben zuverlässig verarbeiten, Spielzustände verwalten, verständliches Feedback geben oder eine kleine Webanwendung responsiv gestalten. Wähle eine zentrale Fähigkeit und ein sichtbares Ergebnis, das sie demonstriert. Versuche nicht, mit einem einzigen kurzen Projekt gleich mehrere Spezialgebiete abzudecken.
Lege einen kurzen, wiederholbaren Spiel- oder Nutzungsablauf fest. Bei Harbor Signal könnte der fiktive Ablauf so aussehen: Hafenkarte ansehen, eine sichere Route wählen, eine Rückmeldung erhalten und es erneut versuchen. Damit ließe sich zeigen, wie du Eingaben verarbeitest, Zustandswechsel umsetzt und verständliches Feedback ausgibst. Das Beispiel zeigt, wie das Ziel eines Portfolio-Projekts seinen Umfang eingrenzen kann. Die beschriebenen Systeme wurden dafür nicht umgesetzt.
Formuliere für dein eigenes Projekt in einem Satz, woran du seinen Erfolg erkennst. Wähle ein beobachtbares Kriterium, etwa „Wer die Demo öffnet, kann eine kurze Route abschließen und versteht, warum sich das Ergebnis geändert hat.“ Liste dann auf, welche Assets, Zustände und Steuerelemente dafür mindestens nötig sind. Hebe dir zusätzliche Modi für später auf, damit du den Build in einem realistischen Zeitrahmen fertigstellen kannst.
Plane die Arbeit mit einer bearbeitbaren Projektkarte
| Feld | Was du festlegst | Nachweise nach der Umsetzung |
|---|---|---|
| Ziel | Eine Fähigkeit und ein für Nutzende sichtbares Ergebnis | Kurze Demo, die diese Fähigkeit zeigt |
| Umfang | Ein Ablauf, begrenzte Inhalte, eine Zielumgebung | Fertiger Build und bekannte Einschränkungen |
| Beitrag | Deine Rolle und wer gegebenenfalls mitarbeitet | Korrekte Namensnennungen und Angaben zu den Beiträgen |
| Werkzeuge | Sprachen, Bibliotheken, Assets, KI-Unterstützung | README und Projektdateien |
| Überprüfung | Zielbrowser, Eingabemethoden, Randfälle | Testprotokoll mit Build, Datum und Gerät |
| Veröffentlichung | Hosting, Lizenz, Datenschutz, Ausweichmöglichkeit | Funktionierender Link und Bedingungen für die Weiterverwendung |
Halte den Plan während der Arbeit bearbeitbar. Wenn du eine technische Entscheidung änderst, aktualisiere die Projektkarte und die README, damit die Dokumentation zum Projekt passt. Mit einem kurzen Änderungshinweis kannst du zeigen, wie du abgewogen hast, ohne aus dem Portfolio ein Tagebuch zu machen.

Baue einen Vertical Slice, bevor du weitere Funktionen hinzufügst
Sorge zuerst dafür, dass eine Interaktion von Anfang bis Ende funktioniert. Zusätzliche Inhalte kannst du danach ergänzen. Ein Vertical Slice umfasst eine Aufgabenstellung oder einen Startzustand, eine Aktion, eine sichtbare Rückmeldung, einen Abschluss- oder Fehlerzustand und eine Möglichkeit zum Neustart. Teste den Ablauf zunächst mit Platzhaltergrafiken und verfeinere danach die Teile, die für dein Portfolio-Ziel wichtig sind.
Führe eine kurze Aufgabenliste mit drei Spalten: „Muss funktionieren“, „Sollte verbessert werden“ und „Außerhalb des Projektumfangs“. In die erste Spalte können etwa das Laden des Projekts, die Verarbeitung von Eingaben, die Anzeige eines Ergebnisses und die Wiederherstellung nach einem Fehler gehören. In der zweiten Spalte ist Platz für Animationen, Sound oder weiteren Feinschliff. Die dritte Spalte hilft dir, den Abgabetermin einzuhalten. Passe diese Planungsmethode an dein Projekt an und verwende sie nicht als Bewertungsraster.
Halte wichtige Änderungen in Commits oder einem anderen Versionsverlauf fest. Sichere vor riskanten Refactorings einen Build, von dem du weißt, dass er funktioniert. Wenn du mit anderen Studierenden zusammenarbeitest, klärt frühzeitig die Zuständigkeiten, die Erwartungen an Reviews und die Namensnennung. Mache deinen eigenen Beitrag auch dann nachvollziehbar, wenn das Projekt gemeinsam erstellten Code oder gemeinsam genutzte Assets enthält.
Setze KI so ein, dass du ihren Einsatz erklären kannst
KI kann helfen, den Aufwand für verschiedene Funktionen abzuwägen, eine Aufgabe in Schritte zu zerlegen, eine unbekannte Fehlermeldung zu erklären, Testfälle zu entwerfen oder die Verständlichkeit der README zu prüfen. Nutze sie als Lern- und Schreibhilfe. Überprüfe den Code in deinem Projekt und stelle sicher, dass du die endgültige Implementierung erklären kannst. Halte dich an Kursvorgaben, Teamvereinbarungen, Wettbewerbsregeln und Lizenzbedingungen. Lege wesentliche Unterstützung offen, wenn dies vorgeschrieben ist oder wenn sie beeinflusst, wie jemand deine Arbeit beurteilen sollte.
Projektziel: [eine Fähigkeit, die das Portfolio zeigen soll]
Nutzungsablauf: [Start, Aktion, Rückmeldung, Abschluss/Neustart]
Aktueller Build: [Programmiersprache, Framework, Zielumgebung]
Mein Beitrag: [konkrete Arbeiten, die ich erledigt habe]
Aufgabe: Schlage eine kurze Aufgabenliste und Tests für Randfälle vor.
Rahmenbedingungen: [Kurs- und Teamregeln, Lizenzen, Gerät]
Erfinde keine funktionierenden Features, Tests, Leistungsdaten oder Rückmeldungen von Nutzenden.
Gib keine Zugangsdaten, privaten Daten oder Code, den du nicht weitergeben darfst, in externe Tools ein. Verlass dich erst auf Vorschläge, nachdem du sie getestet hast. Wenn generierter Code Teil des Projekts wird, halte genügend Kontext fest, um erklären zu können, wie er funktioniert, was du geändert hast und welche Teile du selbst geschrieben oder geprüft hast.
Schreibe eine README, mit der andere dein Projekt ausprobieren können
Die GitHub-Dokumentation beschreibt eine README als Datei, die Besuchenden eines Repositorys das Projekt vorstellt. Für dein Portfolio sollte sie sowohl denen helfen, die sich den Code ansehen, als auch denen, die nur das Ergebnis sehen möchten. Platziere den Demo-Link und eine kurze Beschreibung weit oben und ergänze genaue Anleitungen zur Einrichtung oder zum Spielen.
- Projektname und Ziel in einem Satz.
- Demo-Link, Steuerung und ein Standbild oder eine kurze Bildschirmaufnahme.
- Voraussetzungen und Einrichtungsschritte, die mit einem frischen Checkout funktionieren.
- Deine Rolle, Mitwirkende, verwendete Werkzeuge und wesentliche KI-Unterstützung.
- Bekannte Einschränkungen, unterstützte Eingabemethoden und gegebenenfalls unfertige Funktionen.
- Angaben zur Herkunft der Assets, Lizenzen und die Kontaktdaten, die du teilen möchtest.
Teste die Einrichtungsanleitung möglichst mit einer frischen Kopie des Projekts. Entferne personenbezogene Daten und Zugangsdaten aus Commits, Screenshots und Logs. Bezeichne das Projekt nur dann als Open Source, wenn seine Lizenz und die weiterverbreiteten Assets diese Aussage zulassen.
Gestalte den spielbaren Teil barrierearm und vorhersehbar
Gib den Steuerelementen eindeutige Namen und zeige die Bedienhinweise sichtbar an. Wo es die Interaktion zulässt, mache die Funktionen per Tastatur bedienbar und zeige beim Navigieren durch die Oberfläche den aktuellen Fokus an. Biete Textalternativen für aussagekräftige Bilder und visuell dargestellte Ergebnisse. Verwende Farbe nie als einziges Signal für Erfolg oder Misserfolg. Wenn Bewegung für die Interaktion nicht wesentlich ist, biete eine Pause oder eine Einstellung für reduzierte Bewegung an.
Die WCAG 2.2 des W3C enthalten Kriterien für die Tastaturbedienung und für Textalternativen zu Nicht-Text-Inhalten. Nutze den normativen Standard als Grundlage für die Prüfung. Aus dieser informellen Checkliste allein lässt sich keine Konformität ableiten. Teste die tatsächliche Seite ausschließlich mit der Tastatur und, wo sinnvoll, auch mit assistiven Technologien. Halte die Probleme fest, die du dabei findest.
Biete Menschen, die den spielbaren Build nicht laden können oder möchten, eine Alternative an, etwa Screenshots, eine kurze Bildschirmaufnahme mit Untertiteln oder eine Beschreibung des Ablaufs in Textform. Sorge dafür, dass die Seite auf schmalen Bildschirmen nutzbar ist, erkläre die erforderlichen Eingaben und biete eine klar erkennbare Möglichkeit zum Neustart. Das Portfolio sollte auch dann verständlich bleiben, wenn das Spiel selbst nicht verfügbar ist.

Teste den veröffentlichten Build und dokumentiere die Ergebnisse
Teste neben der lokalen Entwicklungsversion auch die gehostete Version. Öffne sie in den Browsern und auf den Geräten, die du unterstützen möchtest. Prüfe den ersten Ladevorgang, die Anleitungen, die Eingabe, den Neustart, den Abschlusszustand, das Verhalten bei Fehlern und die Ausweichmöglichkeit. Bitte nach Möglichkeit jemanden, der das Projekt noch nicht kennt, es auszuprobieren. Halte genau fest, wer getestet hat und was die Person dabei getan hat. Aus dem Testlauf einer einzelnen Person lässt sich nicht ableiten, dass alle das Projekt verstehen werden.
- Können neue Besuchende die Demo finden und starten?
- Führt der zentrale Ablauf zu einem Ende und lässt er sich neu starten?
- Funktioniert die Steuerung mit den unterstützten Eingabemethoden?
- Wird erklärt, was bei Fehlern, beim Laden oder bei Nichtverfügbarkeit passiert?
- Lässt sich das Projekt auch ohne Farbe, Ton oder schnelle Bewegungen verstehen?
- Entspricht die README dem aktuell gehosteten Build?
- Beziehen sich Screenshots und Aussagen auf dieselbe Version?
Dokumentiere die Build-Kennung, das Datum, das Gerät, den Browser und deine tatsächlichen Beobachtungen. Gib klar an, was du nicht getestet hast. Erfinde keine Leistungsdaten und erwecke nicht den Eindruck, dass eine Kursgruppe, ein Arbeitgeber oder eine Nutzergruppe das Projekt geprüft hat. Harbor Signal ist fiktiv und hat kein Testprotokoll.
Erzähle im Portfolio, wie dein Projekt entstanden ist
Beschreibe knapp dein Ziel, die Rahmenbedingungen, deine Rolle, eine wichtige Entscheidung, ein Problem, das du gelöst hast, und was du dabei gelernt hast. Verlinke die Demo und das Repository. Gestalte die Seite so, dass sie auch dann verständlich bleibt, wenn einer der Links vorübergehend nicht erreichbar ist. Zeige Screenshots aus dem tatsächlichen Build und kennzeichne Prototypen oder Konzeptgrafiken eindeutig.
Beschreibe Einschränkungen sachlich, etwa „Diese Demo lässt sich auf Desktop-Rechnern per Tastatur steuern. Die Touch-Eingabe ist noch nicht implementiert.“ Konkrete Angaben helfen den Lesenden, die Arbeit einzuordnen, und zeigen, dass du sie geprüft hast. Wenn du später eine Funktion hinzufügst, aktualisiere die Nachweise zum Build und das Testprotokoll, statt frühere Aussagen stillschweigend zu ändern.
Ein fertiges Portfolio-Projekt kann klein sein. Setze eine Interaktion vollständig um, mache deinen Beitrag sichtbar, dokumentiere die Einrichtung und die Einschränkungen und überprüfe die veröffentlichte Version. So können andere deine Arbeit selbst ausprobieren und fundiert beurteilen, was du umgesetzt hast.
Häufig gestellte Fragen
Was macht ein gutes Portfolio-Projekt für Studierende in der Softwareentwicklung aus?
Ein klar umrissenes Projekt zeigt eine Fähigkeit anhand eines vollständigen, nachvollziehbaren Ergebnisses. Erkläre das Problem, deine Rolle, deine Entscheidungen und was funktioniert. Ein kleines, abgeschlossenes Projekt mit klaren Nachweisen lässt sich oft leichter beurteilen als eine lange Liste unfertiger Funktionen.
Sollte ein Portfolio-Projekt für Studierende in der Softwareentwicklung spielbar sein?
Nur wenn die Interaktion hilft, die Arbeit zu erklären. Ein spielbarer Build kann die Steuerung, den Umgang mit Zuständen oder die Spiellogik zeigen. Bei anderen Projekten können Screenshots und eine kurze Demo ausreichen. Ergänze ein Standbild oder eine Erklärung in Textform und gib an, welche Geräte und Browser du tatsächlich getestet hast.
Wie kann KI bei einem studentischen Portfolio-Projekt helfen?
KI kann helfen, Ideen für den Projektumfang zu sammeln, die Arbeit in Aufgaben zu unterteilen, Testfälle zu entwerfen, unbekannten Code zu erklären oder die Dokumentation zu prüfen. Überprüfe die Vorschläge, stelle sicher, dass du den eingereichten Code verstehst, halte dich an Kurs- und Teamregeln und lege wesentliche Unterstützung offen, wenn es vorgeschrieben ist. KI-generierte Ergebnisse belegen weder die Urheberschaft noch die Korrektheit.
Was gehört in die README eines Projekts?
Erkläre, was das Projekt macht, wie man es ansehen oder ausführen kann, wie die Steuerung funktioniert, welche Voraussetzungen und bekannten Einschränkungen es gibt und was du beigetragen hast. Laut GitHub-Dokumentation stellt die README das Projekt den Besuchenden vor. Halte die Einrichtungsschritte aktuell und korrekt. Veröffentliche keine privaten Schlüssel, personenbezogenen Daten oder Assets, die du nicht weitergeben darfst.
Wie mache ich ein spielbares Portfolio-Projekt barriereärmer?
Mache die Funktionen, wo es sinnvoll ist, per Tastatur bedienbar. Sorge für einen sichtbaren Fokus, eindeutig benannte Steuerelemente, ausreichende Kontraste und Textalternativen für wichtige Nicht-Text-Inhalte. Die WCAG 2.2 des W3C nennen Erfolgskriterien für die Tastaturbedienung und für Textalternativen. Teste die tatsächliche Seite und gib Konformität nur nach einer geeigneten Prüfung an.
Suchst du einen strukturierten Einstieg in ein kleines spielbares Projekt? Entdecke den Ablauf der KI-gestützten Spieleerstellung und passe ihn an deine Ziele an.


