Wer bei uns Module zu Programmierung, Softwarearchitektur oder Cybersecurity-Konzepten belegt, kommt mit sehr unterschiedlichen Voraussetzungen. Die folgenden Stimmen stammen aus laufenden Kursen und abgeschlossenen Lernpfaden – uns interessiert vor allem, was sich danach im Arbeitsalltag verändert hat.
Im Modul zur Authentifizierung haben wir Passwort-Hashing mit Argon2 und sichere Session-Cookies direkt im Übungsprojekt umgesetzt. Vorher habe ich Login-Flows eher nach Gefühl gebaut, jetzt kann ich begründen, warum ein Token rotiert wird und welche Fehlermeldung nach außen gehen darf.
Der Threat-Modeling-Workshop war für unser kleines Team der praktischste Teil. Wir haben Datenflüsse skizziert, Vertrauensgrenzen markiert und die STRIDE-Kategorien durchgearbeitet. Die Ergebnisse liegen jetzt als Tickets im Sprint und werden im Review nachgehalten.
Die Checkliste für Code Reviews hat unsere Pull Requests verändert. Wir prüfen jetzt konsequent den Umgang mit Benutzereingaben, die Fehlerbehandlung bei externen Aufrufen und die Rechteprüfung an jeder Endpunktgrenze. Kommentare benennen das Problem und schlagen eine Alternative vor.
Im Architekturmodul haben wir Schnittstellen zwischen Diensten entworfen und die Angriffsflächen früh im Projekt sichtbar gemacht. Statt hartkodierter Zugangsdaten arbeiten wir nun mit Umgebungsvariablen und prüfen Rechte an jeder Grenze.
Im Übungsprojekt mit Node.js haben wir Rate-Limiting und CSRF-Schutz in den Ablauf eingebaut. Die Codebeispiele aus dem Kurs konnte ich fast unverändert übernehmen und im Team erklären, warum diese Schritte nötig sind.
Die Python-Module bauen sauber aufeinander auf. Von den Grundlagen bis zur Fehlerbehandlung bei externen Aufrufen war jeder Schritt an einer konkreten Aufgabe erklärt, sodass ich das Gelernte direkt in unserem internen Buchungssystem anwenden konnte.
Die Rückmeldungen beziehen sich auf konkrete Module und Übungsprojekte. Namen und Rollen geben wir so wieder, wie sie in den Kursunterlagen stehen.
Fragen zu einem Modul stellenWer bei uns einsteigt, arbeitet sich nicht durch eine Sammlung loser Videos. Die Lernwege sind in Etappen gegliedert, die aufeinander aufbauen: erst Grundlagen lesen und nachbauen, dann Systeme verstehen, schließlich selbst entwerfen und prüfen. Wie das konkret abläuft, steht unten.
Am Anfang steht ein kurzes Gespräch oder ein Einstufungsbogen. Dabei geht es nicht um Zertifikate, sondern um die Frage, wo jemand steht: schon einmal programmiert, nur Grundlagen der Netzwerktechnik, oder komplett neu im Thema. Danach wird ein Lernpfad gewählt, der zu diesem Stand passt.
Die ersten Module behandeln Syntax, Datenstrukturen und Versionsverwaltung. Jede Lektion endet mit einer Aufgabe, die lokal umgesetzt wird: ein kleines Skript, eine Funktion, ein Repository mit sinnvollen Commits. Ohne diese Übungen geht es nicht weiter, weil die nächsten Etappen darauf aufbauen.
Sobald Code sitzt, kommen die technischen Systeme dazu: wie Webanwendungen Anfragen verarbeiten, wo Daten liegen, welche Grenzen zwischen Diensten verlaufen. An Beispielen werden typische Schwachstellen durchgespielt, etwa fehlerhafte Eingabeprüfung oder ungeschützte Schnittstellen. Das Ziel ist nicht das Auswendiglernen von Angriffen, sondern das Erkennen von Mustern.
In dieser Phase entsteht ein kleiner, überschaubarer Dienst: eine API, ein internes Werkzeug, ein Prototyp. Dazu gehören Datenmodell, Authentifizierung und eine schriftliche Notiz zu den Risiken, die im Entwurf berücksichtigt wurden. Die Betreuung erfolgt über Code Reviews und feste Rückmeldetermine.
Zum Abschluss wird das Projekt gegen die eigene Risikoliste geprüft, Abhängigkeiten werden aktualisiert, und es entsteht eine kurze technische Dokumentation. Wer möchte, bekommt eine Einschätzung zum erreichten Stand und eine Empfehlung, welche Themen als Nächstes sinnvoll sind.
Die Etappen lassen sich in unterschiedlichem Tempo durchlaufen. Wer berufsbegleitend lernt, verteilt sie oft über mehrere Monate; wer Vollzeit einsteigt, kommt schneller voran. Wichtiger als das Tempo ist, dass keine Etappe übersprungen wird, weil die nächste sonst auf wackligem Fundament steht.
Fragen zum Ablauf stellen
Wer sich zum ersten Mal mit Programmierung oder Cybersicherheit beschäftigt, hat meist dieselben offenen Punkte. Hier stehen die Antworten, die im Kursalltag am häufigsten gebraucht werden.
Für die Grundlagenmodule nicht. Wir starten mit Python, weil die Syntax wenig Ballast mitbringt und sich Fehler gut nachvollziehen lassen. Wer bereits in einer anderen Sprache gearbeitet hat, kann direkt in die Aufbaumodule zu Softwarearchitektur und sicheren Schnittstellen einsteigen.
Jedes Modul läuft über mehrere Wochen und besteht aus kurzen Lerneinheiten, die sich in den Feierabend legen lassen. Dazu kommen praktische Aufgaben, die am eigenen Rechner gelöst werden. Am Ende steht eine Projektaufgabe, die wir gemeinsam durchsehen und kommentieren.
Wir behandeln Angriffsflächen in Webanwendungen, sichere Authentifizierung, den Umgang mit Benutzereingaben und das Erkennen typischer Schwachstellen im Code. Dazu kommt ein Abschnitt zu Netzwerkgrundlagen und Verschlüsselung. Es geht um Verständnis der Mechanismen, nicht um Werkzeuge für Angriffe.
Beides. Die Übungen sind bewusst klein gehalten, damit ein Konzept klar wird. Danach folgt jeweils ein Projekt, das näher an der Praxis liegt, etwa ein Buchungssystem oder eine API-Schnittstelle mit Rechteprüfung. So sieht man, wie sich einzelne Entscheidungen später auswirken.
Fragen zu Aufgaben beantworten wir schriftlich, meist innerhalb eines Werktags. Bei größeren Verständnisproblemen lässt sich ein kurzes Gespräch vereinbaren. Wer möchte, kann Zwischenstände zur Durchsicht schicken, bevor die Abgabe fällig ist.
Sie erhalten eine Rückmeldung zu Ihrer Projektarbeit mit Hinweisen, woran sich als Nächstes arbeiten lässt. Auf Wunsch schließen weitere Module an, etwa zu Code Reviews oder zu Threat Modeling im Team. Ein Einstieg in ein späteres Modul ist jederzeit möglich.
Vier Module mit unterschiedlicher Tiefe. Wer neu in die Programmierung einsteigt, beginnt bei den Grundlagen und arbeitet sich über Softwareentwicklung bis zu den Sicherheitskonzepten vor. Wer schon berufliche Praxis mitbringt, steigt direkt bei den Themen ein, die im eigenen Projekt gerade drücken.
Alle Module laufen begleitend zum Beruf oder Studium, mit festen Übungsaufgaben und Rückmeldung zu eingereichten Lösungen. Die Auswahl richtet sich nach Vorkenntnissen und dem Ziel, das im Kursverlauf erreicht werden soll.
Variablen, Kontrollstrukturen, Funktionen und Datenstrukturen anhand kleiner, in sich abgeschlossener Aufgaben. Wir arbeiten mit Python und JavaScript, damit die Konzepte in zwei Sprachumgebungen sichtbar werden. Am Ende steht ein kleines Konsolenprojekt, das selbstständig aufgebaut und getestet wird.
Modul ansehenVersionsverwaltung mit Git, Branching-Strategien, Code Reviews und der Aufbau einer nachvollziehbaren Projektstruktur. Dazu gehört der Umgang mit Tests, Fehlerbehandlung und dem Dokumentieren von Schnittstellen. Die Übungen laufen in kleinen Gruppen, damit Absprachen und Konflikte im Workflow tatsächlich geübt werden.
Modul ansehenAuthentifizierung, Session-Handling, Eingabevalidierung und der Umgang mit typischen Schwachstellen aus realen Audit-Berichten. Wir gehen durch, wie Fehlermeldungen formuliert werden, ohne interne Details preiszugeben, und wie Rechteprüfungen an jeder Endpunktgrenze aussehen. Vorausgesetzt wird Erfahrung mit mindestens einer Backend-Sprache.
Modul ansehenNetzwerkgrundlagen, Datenformate, Schnittstellen zwischen Diensten und die Frage, wo im Betrieb welche Daten anfallen. Das Modul richtet sich an Quereinsteiger, die technische Zusammenhänge einordnen wollen, ohne selbst zu programmieren. Behandelt werden unter anderem HTTP, DNS, Logs und die Grundzüge der Verschlüsselung.
Modul ansehen
Wir starten bei Variablen, Schleifen und Funktionen und gehen dann zügig zu den Stellen über, an denen in echten Projekten Fehler entstehen: ungeprüfte Eingaben, unklare Rückgabewerte, stilles Verschlucken von Ausnahmen. Jede Einheit endet mit einer kleinen Aufgabe, die im Editor läuft und nicht nur auf dem Papier.
Versionsverwaltung mit Git, sinnvolle Commit-Grenzen, Pull Requests und Reviews. Wir sprechen darüber, wie Module geschnitten werden, wann eine Abstraktion zu früh kommt und wie man Schnittstellen dokumentiert, damit sie in einem halben Jahr noch verständlich sind.
Authentifizierung, Rechteprüfung, Umgang mit Geheimnissen und das Denken in Angriffsflächen. Statt Schlagwortlisten arbeiten wir mit Datenflussdiagrammen und gehen typische Schwachstellen an kleinen Beispielanwendungen durch, bis die Gegenmaßnahme nachvollziehbar ist.
Tabellen entwerfen, Abfragen lesen, Indizes verstehen und erkennen, wann eine Abfrage teuer wird. Dazu ein Blick auf Logs, Konfiguration und Deployment, damit klar wird, wo eine Anwendung tatsächlich läuft und was dort schiefgehen kann.
Terminal, Debugger, Testläufe und statische Analyse gehören zum Handwerk. Wir richten eine Umgebung ein, die reproduzierbar ist, und üben den Ablauf vom lokalen Test bis zum nachvollziehbaren Fehlerbericht.
Die Lernmodule sind so aufgebaut, dass Theorie und Ausführung nah beieinander liegen. Jede Einheit beginnt mit einem konkreten Problem aus der Praxis und führt über kurze Erklärungen zu einer Aufgabe, die im eigenen Editor bearbeitet wird. Wer bereits programmiert, kann einzelne Module überspringen und direkt bei den Themen einsteigen, die im eigenen Projekt gerade drücken.
Die Reihenfolge ist ein Vorschlag, keine Vorschrift. Rückfragen zu einzelnen Übungen lassen sich per E-Mail an info@hakiprotection.com klären, telefonisch unter 0678 3119691.