IT-Skills-Gap im Team schliessen

Dein Team soll moderne IT-Projekte stemmen, aber die Skills sind ungleich verteilt oder veraltet. Du merkst das an stockenden Projekten, Abhängigkeit von Einzelpersonen und viel „Learning by Googling“ in der Überstunde. Genau hier setzt ein strukturierter Umgang mit dem IT-Skills-Gap an: Du brauchst Klarheit über den Ist-Stand, einen ehrlichen Blick auf die Lücken und einen Plan, wie ihr die wichtigsten Themen gemeinsam schließt.

Schritt 1: Ist-Stand der IT-Skills im Team erheben

Bevor du über Schulungen nachdenkst, brauchst du ein möglichst objektives Bild: Welche Skills sind im Team vorhanden, auf welchem Niveau und wofür werden sie in den nächsten 12 bis 24 Monaten benötigt?

Hilfreich ist eine einfache Skill-Matrix. Du definierst relevante Kompetenzbereiche und bewertest jede Person dazu:

Typische Bereiche in IT-Teams:

• Programmiersprachen und Frameworks, z. B. Java, .NET, Python, Angular, React
• Infrastruktur und Cloud, z. B. Azure, AWS, Kubernetes, Linux
• Daten und Integration, z. B. SQL, ETL, APIs, Messaging
• Qualität und Delivery, z. B. Testing, CI/CD, Git, Monitoring
• Architektur und Design, z. B. Microservices, Domain-Driven Design
• Arbeitsweise, z. B. agile Methoden, Requirements Engineering, DevOps

Eine einfache Skala reicht oft:

• 0: keine Erfahrung
• 1: Grundlagen, braucht Anleitung
• 2: selbstständige Arbeit in Standardfällen
• 3: sehr sicher, kann andere anleiten

Diese Bewertung kannst du so angehen:

1. Selbstbewertung: Jede Person schätzt sich selbst ein.
2. Peer-Review: Kolleginnen und Kollegen geben Feedback zu ausgewählten Bereichen.
3. Abgleich mit Praxis: Du legst konkrete Aufgaben zugrunde, etwa „neuen REST-Endpoint inkl. Tests implementieren“, „Kubernetes-Deployment anpassen“.

Wichtig ist die Kultur: Mach klar, dass es nicht um Noten geht, sondern um Planung. Wenn Selbstbewertungen systematisch zu hoch oder zu niedrig ausfallen, nutzt du Praxisbeispiele und Code-Reviews, um das Bild zu schärfen.

Ergänze die Matrix um qualitative Infos:

• Welche Technologien machen besonders Spaß?
• Wo sieht sich die Person in 1 bis 2 Jahren?
• Welche Themen meidet sie bisher bewusst?

So erkennst du nicht nur Lücken, sondern auch Potenzialträger für neue Themen.

Schritt 2: Skill-Lücken ehrlich priorisieren

Nicht jede Lücke ist gleich kritisch. Du musst unterscheiden zwischen „wäre schön zu haben“ und „ohne das schaffen wir das nächste Projekt nicht“.

Nimm dir deine Roadmap für die nächsten 12 bis 24 Monate vor: geplante Projekte, Produktfeatures, technische Modernisierung, Sicherheitsanforderungen. Dann verknüpfst du sie mit den Skills.

Typische Priorisierungskriterien:

• Relevanz für geschäftskritische Projekte
• Risiko durch Single Points of Failure (nur eine Person kann X)
• Technische Schulden, die euch regelmäßig ausbremsen
• Sicherheits- und Compliance-Anforderungen
• Abhängigkeit von externen Dienstleistern

Du kannst das in einer einfachen Tabelle visualisieren:

Skill/Thema	Projektbezug	Aktueller Stand im Team	Risiko bei Nicht-Entwicklung	Priorität
Kubernetes Basics	Neue Cloud-Plattform	1 Person auf Level 2, Rest 0 1	Hohe Abhängigkeit, Zeitverzug	Hoch
Testautomatisierung	Alle Produktteams	Viele auf Level 1	Hohe Bugrate, langsame Releases	Hoch
Angular Advanced	Neues Kundenportal	2 Personen auf Level 2	Engpass bei Features	Mittel
Data Analytics mit SQL	Reporting-Optimierung	Mehrheit Level 1 2	Langsame Auswertungen, Workarounds	Mittel

Konzentriere dich zunächst auf wenige, klar definierte Lücken mit hoher Priorität. Lieber 3 Kernbereiche im Jahr spürbar verbessern als 10 Themen nur anreißen.

Schritt 3: Lernpfade pro Rolle statt „Gießkanne“

Die meisten Teams sind gemischt: Backend, Frontend, DevOps, QA, Product Owner. Ein Einheitsprogramm für alle verschwendet Zeit und Nerven. Besser sind rollenbezogene Lernpfade.

Ein Lernpfad beschreibt:

• Startniveau: Wo steht die Person heute?
• Zielniveau: Was soll sie in 6 bis 12 Monaten sicher können?
• Bausteine: Schulungen, Selbstlernmaterial, Learning-on-the-job
• Praxisprojekte: Konkrete Aufgaben im Arbeitsalltag
• Checkpoints: Wie wird der Fortschritt überprüft?

Ein Beispiel für einen Lernpfad „Backend-Entwickler mit Fokus Cloud-native“:

1. Grundlagen festigen

• Wiederholung von Clean Code, SOLID, Unit Testing
• Kurzer interner Workshop oder kompakte Schulung

2. Cloud- und Container-Basics

• Docker-Grundlagen, Images, Container
• Basiswissen zu einer Cloud-Plattform (z. B. Azure oder AWS)
• erste Deployments in einer Testumgebung

3. Kubernetes und CI/CD

• Einführung in Kubernetes-Konzepte
• Pipeline-Aufbau mit eurem Toolstack (z. B. GitLab CI, GitHub Actions)
• kleine Service-Erweiterung inklusive Deployment

4. Vertiefung und Spezialisierung

• Sicherheit, Observability, Fehleranalyse in verteilten Systemen
• Mentoring durch erfahrene Kolleginnen oder Kollegen

Wichtig: Lernpfade müssen zu eurem Tech-Stack passen. Keine generischen Listen aus dem Internet übernehmen, sondern konkretisieren: Welche Tools, welche Framework-Versionen, welche Umgebungen verwendet ihr wirklich?

Schritt 4: Schulung und Learning-on-the-job sinnvoll kombinieren

Nur Schulung ohne Praxis verpufft. Nur Learning-on-the-job ohne Struktur führt zu Flickwerk. Die Mischung macht den Unterschied.

Ein pragmatisches Setup sieht oft so aus:

1. Fokus-Schulung zu einem klar abgegrenzten Thema Zum Beispiel „Einführung in Kubernetes für Entwicklerinnen und Entwickler“. Ziel: gemeinsames Begriffsverständnis, Best Practices, typische Stolperfallen.

2. Direkt im Anschluss ein kleines, echtes Projekt Keine Spielwiese im luftleeren Raum, sondern eine Aufgabe, die wirklich gebraucht wird, z. B.:

• einen bestehenden Service containerisieren
• ein neues Stage-Environment aufsetzen
• ein Monitoring-Dashboard für einen Kernservice bauen

3. Geplante Lernzeit im Arbeitsalltag Reserviere bewusst Zeitfenster, etwa 4 Stunden pro Woche, in denen die Person an Lernaufgaben arbeitet, Dokus liest oder Übungen umsetzt. Ohne eingeplante Zeit fällt Lernen immer gegen „dringende Tickets“ hinten runter.

4. Mentoring und Pairing Kombiniere weniger erfahrene Leute mit erfahrenen Kolleginnen oder Kollegen:

• Pair Programming
• gemeinsame Architektur-Reviews
• „Tech Time“, in der offene Fragen gestellt werden können

5. Kurze, interne Wissens-Sessions Lass Teilnehmende nach einer Schulung kurze Sessions im Team halten: „Was haben wir gelernt? Was setzen wir konkret um?“. Das festigt Wissen und verteilt es im Team.

Für strukturierte Präsenz- oder Online-Schulungen zu konkreten Themen lohnt sich der Blick auf etablierte Anbieter. Aktuelle Termine und passende Kurse findest du bei cmt.de.

Schritt 5: Erfolg messbar machen und dranbleiben

Ohne sichtbaren Fortschritt kippt die Motivation schnell. Du brauchst einfache, aber aussagekräftige Indikatoren.

Mögliche Messpunkte:

• Skill-Matrix-Updates alle 6 bis 12 Monate Sieh dir an, wie sich die Bewertungen verändert haben. Wichtig ist nicht, dass alle auf „3“ landen, sondern dass kritische Lücken kleiner werden.

• Projektmetriken

• weniger Produktionsfehler nach Einführung von Testautomatisierung

• kürzere Durchlaufzeiten bei Deployments

• weniger Rückfragen an einzelne „Expertinnen“ oder „Experten“, weil mehr Leute das Thema beherrschen

• Qualitative Rückmeldungen

• Wie sicher fühlen sich die Leute in neuen Technologien?

• Wie oft wird ad hoc nach externer Hilfe gesucht?

• Werden neue Technologien aktiv vorgeschlagen oder eher gemieden?

Plane von Anfang an „Refresh“- und Vertiefungsphasen ein. Technologien entwickeln sich weiter, und Wissen rostet. Das kann so aussehen:

• jährliche Technik-Reviews: Welche Tools und Frameworks bleiben, welche laufen aus?
• gezielte Vertiefungs-Workshops zu Themen, die ihr schon einsetzt, z. B. „Fortgeschrittene Git-Workflows“, „Teststrategie für Microservices“
• kleine interne Communities of Practice, in denen sich Leute zu bestimmten Themen regelmäßig austauschen

Schritt 6: Rahmenbedingungen schaffen, damit Lernen wirklich passiert

Der beste Plan hilft nichts, wenn die Umgebung nicht passt. Drei Punkte sind entscheidend:

1. Zeit und Priorität Wenn Lernen immer „on top“ kommt, verliert es. Plane Lernzeit explizit ein, etwa:

• „Kein Meeting-Tag“ für Fokusarbeit und Lernen
• feste Lernblöcke in Sprint-Planungen
• realistische Projektplanung mit Puffer für Skill-Aufbau

2. Fehlerkultur Neue Technologien bedeuten neue Fehler. Wichtig ist, dass dein Team ohne Angst experimentieren kann. Das heißt:

• Fehler in Retrospektiven sachlich analysieren
• kein Fingerpointing, sondern Fokus auf Systemverbesserungen
• sichere Spielwiesen-Umgebungen, in denen man Dinge kaputtmachen darf, ohne den Betrieb zu stören

3. Sichtbare Unterstützung durch Führung Wenn Teamleitungen und Management Lernen nur auf Folien loben, aber im Alltag jedes Lernfenster mit „kurz wichtigen“ Aufgaben zupflastern, merken das alle. Zeige durch dein Verhalten, dass Skill-Aufbau wirklich zählt:

• Lernziele in Mitarbeitergesprächen konkret vereinbaren
• Erfolge bei Skill-Entwicklung sichtbar machen
• bei Konflikten zwischen Lernzeit und Ticketdruck klar Stellung beziehen

Praxisbeispiel: Von „Wir müssen Kubernetes können“ zu messbarem Fortschritt

Ein kurzes, typisches Szenario aus vielen Münchner Unternehmen:

Ausgangslage: Ein Entwicklungsteam soll mittelfristig Anwendungen in einer Kubernetes-Umgebung betreiben. Derzeit hat nur eine Person ernsthafte Container-Erfahrung, alle anderen fühlen sich unsicher. Gleichzeitig drängen Deadlines.

Vorgehen:

1. Ist-Stand: Skill-Matrix mit Fokus „Container“, „Kubernetes“, „CI/CD“. Ergebnis: Nur eine Person auf Level 2 bei Containern, sonst Level 0 1.

2. Priorisierung: Entscheidung: Kubernetes und Container sind Top-Priorität, weil sonst die geplante Plattformmigration nicht klappt.

3. Lernpfade:

• für 3 Backend-Leute: „Kubernetes-fähig“ in 6 Monaten
• für 1 Person: Vertiefung Richtung „Platform Engineer“

4. Maßnahmen:

• 2-tägige Grundlagen-Schulung zu Containern und Kubernetes
• direkt danach: kleines internes Projekt, bei dem ein bestehender Service containerisiert und in ein Test-Cluster gebracht wird
• wöchentliche 2-Stunden-Slots, in denen die Leute gezielt an Aufgaben aus dem Cluster arbeiten
• 1 erfahrener Kollege als Mentor, regelmäßige Pairing-Sessions

5. Nach 6 Monaten:

• 3 Personen können neue Services eigenständig containerisieren und im Test-Cluster deployen
• die frühere „Einzelkämpferin“ ist entlastet und konzentriert sich auf Plattform-Themen
• die Roadmap für die eigentliche Migration ist realistisch planbar

Genau das ist das Ziel, wenn du den IT-Skills-Gap systematisch angehst: weg von vagen Wünschen wie „Wir sollten mal mehr Schulungen machen“, hin zu klaren Lernpfaden, die sich in Projekterfolg und Alltagssicherheit niederschlagen.

Wenn du das als kontinuierlichen Prozess verstehst und nicht als einmalige Aktion, schrumpft der Skills-Gap Schritt für Schritt. Und dein Team gewinnt die Souveränität zurück, neue Technologien nicht nur mitzuschleppen, sondern aktiv zu gestalten.