Ein Zeitplan, der «zwei Wochen für Programmierung» als eine einzige Zeile führt, hält der Realität eines Softwareprojekts nicht stand. Programmieren ist kein linearer Prozess: Ein Feature, das auf dem Papier zwei Tage braucht, kann wegen einer inkompatiblen Bibliotheksversion plötzlich eine Woche dauern – und ein anderes, technisch komplexer wirkendes Feature ist in Stunden erledigt. Generische Zeitplanvorlagen, die für geistes- oder sozialwissenschaftliche Arbeiten entstanden sind, bilden diese Unsicherheit nicht ab.
Dieser Beitrag zeigt ein Zeitplan-Modell, das speziell auf Softwareprojekte zugeschnitten ist: mit Sprints statt starrer Wochenblöcke, mit eingebauten Pufferzeiten statt einem einzigen Reservetag am Ende, mit Meilensteinen, die tatsächlich überprüfbar sind, und mit einer Strategie für den Moment, in dem der Plan trotzdem aus dem Ruder läuft.
Warum ein generischer Zeitplan bei Softwareprojekten scheitert
Die allgemeine Systematik zur Zeitplanung einer Bachelorarbeit – Themenfindung, Literaturrecherche, Schreiben, Korrektur – ist im Beitrag Zeitplan Bachelorarbeit erstellen gut beschrieben und für die meisten Fächer zutreffend. Für ein Softwareprojekt fehlt darin aber die zentrale Grösse: die Unsicherheit der Implementierung selbst. Wer eine App entwickelt, weiss beim Start selten genau, wie lange die Integration einer bestimmten Bibliothek dauert, ob eine Programmierschnittstelle wie dokumentiert funktioniert, oder ob ein Architekturentscheid sich später als Sackgasse erweist.
Diese Unsicherheit lässt sich nicht wegplanen – aber sie lässt sich einkalkulieren, und genau das leistet das folgende Modell. Der wichtigste gedankliche Schritt dabei: Ein Zeitplan für ein Softwareprojekt ist kein Fahrplan, der exakt eintrifft, sondern ein Werkzeug, das dir frühzeitig zeigt, wenn du von der Route abkommst – rechtzeitig genug, um noch gegenzusteuern.
Die Phasen einer Informatik-Bachelorarbeit im Zeitplan
Sechs Phasen strukturieren ein typisches Softwareprojekt, wobei sich die letzten drei teilweise überlappen:
| Phase | Inhalt | Typischer Anteil |
|---|---|---|
| Konzept & Architektur | Anforderungen klären, Technologiestack wählen, Architektur skizzieren | 10–15 % |
| Setup & Prototyp | Entwicklungsumgebung, minimaler lauffähiger Prototyp, kritische Schnittstelle testen | 10 % |
| Kernentwicklung (Sprints) | Features in 1–2-wöchigen Sprints umsetzen, priorisiert nach Risiko | 35–40 % |
| Testing & Debugging | Systematisches Testen, Fehlerbehebung, Regressionstests | 15–20 % |
| Evaluation | Nutzertest, Performancemessung oder Vergleich mit Referenzimplementierung | 10 % |
| Bericht schreiben | Läuft parallel zur Entwicklung, verdichtet sich in den letzten zwei Wochen | durchgehend, Peak am Ende |

Der entscheidende Unterschied zu einem generischen Zeitplan: «Bericht schreiben» ist keine eigene Phase am Schluss, sondern eine durchgehende Aktivität. Wer das Methodikkapitel erst nach Abschluss der Implementierung beginnt, muss Architekturentscheidungen aus dem Gedächtnis rekonstruieren, die zwei Monate zuvor naheliegend waren und jetzt erklärungsbedürftig wirken. Ein kurzes Entwicklungstagebuch – auch nur stichwortartig, direkt nach jedem Sprint geführt – ersetzt später Stunden mühsamer Rekonstruktion.
Durchgerechnetes Beispiel: 16 Wochen für eine Webanwendung
Ein Student entwickelt für seine Bachelorarbeit eine Webanwendung zur Terminverwaltung mit einer Optimierungskomponente. Sein 16-Wochen-Zeitplan:
Woche 1–2: Konzept, Architekturentscheid (Backend-Framework, Datenbankschema), Literaturrecherche zu Optimierungsalgorithmen.
Woche 3: Setup, minimaler Prototyp mit Dummy-Daten, Testintegration der externen Kalender-API – bewusst früh, weil hier das grösste Risiko liegt.
Woche 4–9: Kernentwicklung in drei Zweiwochen-Sprints: Sprint 1 Benutzerverwaltung und Authentifizierung, Sprint 2 Terminlogik und Datenbankanbindung, Sprint 3 Optimierungskomponente.
Woche 10–12: Testing und Debugging, inklusive eines eingeplanten Pufferblocks von drei Tagen für die erwartungsgemäss instabile Optimierungskomponente.
Woche 13: Nutzertest mit fünf Testpersonen, Auswertung der Rückmeldungen.
Woche 14–16: Fertigstellung des Berichts, dessen Grundgerüst seit Woche 4 parallel mitgewachsen ist – in dieser Phase geht es nur noch um Diskussion, Feinschliff und Formatierung.
Auffällig an diesem Plan: Die kritischste externe Abhängigkeit – die Kalender-API – wird bereits in Woche 3 getestet, nicht erst, wenn die Funktion tatsächlich gebraucht wird. Dieses Prinzip, Risiken so früh wie möglich zu testen statt sie bis zum Schluss aufzuschieben, ist der wichtigste Unterschied zwischen einem Zeitplan, der hält, und einem, der in der letzten Woche kollabiert. Ein zweiter Blick lohnt sich auf die Reihenfolge der Sprints: Die Optimierungskomponente, technisch das riskanteste Teil, kommt zuletzt unter den Kernentwicklungs-Sprints, weil sie auf stabiler Authentifizierung und einem fertigen Datenmodell aufbaut. Das steht nur scheinbar im Widerspruch zum Prinzip «Risiken früh testen»: Den Kernalgorithmus kann man schon in Woche 3 als isolierten Prototyp mit Dummy-Daten ausprobieren und so das grösste Risiko früh entschärfen, auch wenn die vollständige Integration erst im dritten Sprint folgt.
Pufferzeiten: wie viel und wo
Die Faustregel von 20 bis 30 Prozent Pufferzeit ist bekannt, wird aber oft falsch umgesetzt: als ein einziger Block in der letzten Woche. Das funktioniert nicht, weil Softwareprobleme selten am Ende auftreten – sie tauchen genau dann auf, wenn eine neue Komponente auf eine bestehende trifft, also mitten in der Kernentwicklung. Sinnvoller ist es, den Puffer über die Sprints und die Testphase zu verteilen: ein bis zwei Puffertage pro Sprint, plus ein grösserer Block am Ende der Testphase für unvorhergesehene Regressionsfehler.
Projekte mit externen Abhängigkeiten – einer fremden API, einer Hardwareschnittstelle, einer Bibliothek in aktiver Entwicklung – brauchen tendenziell den oberen Wert der Bandbreite. Rein interne Projekte ohne solche Abhängigkeiten kommen oft mit dem unteren Wert aus. Eine einfache Faustregel für die Priorisierung: Je unsicherer eine Komponente zu Beginn wirkt, desto mehr Puffer verdient sie – und desto früher sollte sie angegangen werden, damit für den Ernstfall noch genug Zeit im Plan steckt.
Werkzeuge zur Zeitplanung
Für die praktische Umsetzung reicht selten ein einzelnes Werkzeug. Ein einfaches Kanban-Board – etwa über GitHub Projects, Trello oder ein physisches Whiteboard – macht den Sprint-Fortschritt sichtbar: geplant, in Arbeit, erledigt. Für die übergeordnete Zeitachse mit Phasen, Meilensteinen und Pufferblöcken eignet sich ein einfaches Gantt-Diagramm besser, weil es Abhängigkeiten zwischen Phasen zeigt – etwa dass die Evaluationsphase erst beginnen kann, wenn die Kernfunktionen aus der Testphase stabil sind. Wichtiger als das gewählte Werkzeug ist die Disziplin, es tatsächlich wöchentlich zu aktualisieren: Ein Zeitplan, der nach der zweiten Woche nicht mehr gepflegt wird, verliert seinen Zweck als Frühwarnsystem.
Meilensteine mit der Betreuungsperson
Vier Termine haben sich in der Praxis bewährt: ein Kickoff mit Freigabe von Konzept und Architektur, eine Zwischenpräsentation nach etwa einem Drittel der Zeit mit Live-Demo des Prototyps, ein Code-Freeze-Gespräch vor Beginn der Evaluationsphase, und ein letzter Kurzcheck kurz vor Abgabe. Diese Termine dienen nicht nur der Kontrolle, sondern zwingen dazu, den eigenen Fortschritt regelmässig ehrlich einzuschätzen – wer sich auf eine Zwischenpräsentation vorbereiten muss, erkennt Verzögerungen früher als jemand, der erst bei der Abgabe Bilanz zieht. Wie ein solches Betreuungsgespräch inhaltlich vorbereitet wird, ist im Beitrag zum Betreuungsgespräch vorbereiten ausführlich beschrieben.
Die letzte Phase, in der Ergebnisse eingeordnet und diskutiert werden, verlangt eine eigene Sorgfalt, die über reines Feature-Abhaken hinausgeht – wie eine Diskussion in der Informatik-Bachelorarbeit von Messwert zu begründeter Bewertung kommt, zeigt der Beitrag zur Diskussion und Evaluation in der Informatik-Bachelorarbeit.
Wenn der Zeitplan aus dem Ruder läuft
Auch ein gut gebauter Zeitplan gerät manchmal aus dem Takt – meist durch eine Komponente, die sich hartnäckiger zeigt als erwartet. Der wichtigste Schritt in diesem Moment ist nicht, schneller zu programmieren, sondern früh und ehrlich zu priorisieren: Welche Features sind für die Beantwortung der Forschungsfrage unverzichtbar, welche waren «nice to have»? Ein reduzierter, aber sauber evaluierter Funktionsumfang überzeugt Gutachtende zuverlässiger als ein überladenes, aber halbfertiges und schlecht getestetes System. Diese Entscheidung gehört in eines der Betreuungsgespräche, nicht in eine stille Nachtschicht drei Tage vor Abgabe.
Häufige Fehler
| Fehler | Folge |
|---|---|
| Kritischste Abhängigkeit erst spät getestet | Grösstes Risiko trifft in der Phase mit dem wenigsten Puffer |
| Pufferzeit als einzelner Block am Ende | Probleme in der Kernentwicklung haben keinen Puffer mehr |
| Bericht erst nach der Implementierung begonnen | Architekturbegründungen müssen nachträglich rekonstruiert werden |
| Sprints ohne klares Sprintziel | Fortschritt lässt sich nicht überprüfen, Verzögerung fällt spät auf |
| Evaluationsphase zu knapp bemessen | Nutzertest oder Messung muss überstürzt durchgeführt werden |
| Zeitplan nach den ersten Wochen nicht mehr aktualisiert | Verzögerungen werden erst bei der Abgabe sichtbar, zu spät zum Gegensteuern |

Zeitplan und Bericht in einem Werkzeug
Tesify hilft dir, deinen Bericht parallel zur Entwicklung aufzubauen, statt ihn erst am Ende zusammenzuschreiben. Der Text bleibt zu 100 % von dir geschrieben.
Häufige Fragen
Wie viel Pufferzeit sollte ich für Debugging einplanen?
Als Richtwert gelten 20 bis 30 Prozent der Gesamtzeit als Puffer, verteilt auf die Entwicklungs- und Testphase, nicht als einzelner Block am Ende. Bei Projekten mit externen Abhängigkeiten wie APIs oder Hardware ist der obere Wert realistischer.
Sollte ich in Sprints planen, auch wenn meine Hochschule kein Scrum verlangt?
Ja, unabhängig vom Reglement hilft eine Aufteilung in kurze, überprüfbare Zeitabschnitte von ein bis zwei Wochen, den Fortschritt früh sichtbar zu machen. Du musst das Wort «Sprint» im Bericht nicht verwenden, wenn dein Studiengang eine andere Methodik erwartet.
Wann sollte ich mit dem Schreiben des Berichts beginnen?
Nicht erst nach Abschluss der Implementierung. Methodikkapitel und Architekturentscheidungen lassen sich parallel zur Entwicklung dokumentieren, während sie noch frisch sind – das spart in der letzten Phase wertvolle Zeit und verhindert, dass Begründungen im Nachhinein rekonstruiert werden müssen.
Was, wenn eine zentrale Abhängigkeit (API, Bibliothek, Hardware) während der Arbeit ausfällt oder sich ändert?
Dokumentiere den Vorfall mit Datum und Auswirkung und informiere die Betreuungsperson umgehend – ein dokumentierter, rechtzeitig gemeldeter Rückschlag wird bei der Bewertung anders behandelt als eine verspätete Abgabe ohne Erklärung. Halte in deinem Zeitplan von Anfang an eine Ausweichoption für kritische Abhängigkeiten bereit.
Wie viele Meilensteine mit der Betreuungsperson sind üblich?
Drei bis vier feste Termine haben sich bewährt: Kickoff mit Konzeptfreigabe, eine Zwischenpräsentation nach etwa einem Drittel der Zeit, ein Code-Freeze-Gespräch vor der Auswertungsphase und ein letzter Check kurz vor Abgabe. Mehr Termine lohnen sich bei technisch komplexen oder risikoreichen Projekten.
Ein Zeitplan für ein Softwareprojekt ist nie im ersten Wurf perfekt – aber ein Plan, der Unsicherheit von Anfang an einkalkuliert statt sie zu ignorieren, bricht seltener zusammen als einer, der auf dem Papier makellos aussieht.
