💼 Real Talk: Deine Chancen nach diesem Kurs

Spring Boot Aufbau – Tag 20 (10 Basic + 10 Aufbau)

Das Team spricht Klartext – über deine Zukunft im Arbeitsmarkt

Du hast jetzt 20 Tage Spring Boot gelernt (Basic + Aufbau = 160 Stunden). Zeit für ehrliche Worte über deine Job-Chancen. Das ganze Team teilt ihre Geschichten: Wie sie mit Bountie Hunting, Open Source und praktischen Projekten den Einstieg geschafft haben. Keine geschönten Success Stories – echte Wege, die funktioniert haben.

Key Takeaways: ✅ Realistische Gehaltserwartungen nach Region
✅ Bountie Hunting als Praxis-Booster und Portfolio-Builder
✅ Open Source Contributions als Einstiegsticket
✅ Team-Erfahrungen aus erster Hand

Sofort anwendbar: Konkrete Plattformen, konkrete erste Schritte, konkrete Erwartungen! 🎯

🎯 Die unbequeme Wahrheit

Franz-Martin öffnet das Meeting:

„Okay Team, lasst uns ehrlich sein. Jemand hat gerade 20 Tage Spring Boot gelernt. Was sind die realen Chancen?“

Die Stille im Raum ist greifbar. Dann spricht Cassian als erster.

🎓 Dr. Cassian Holt: „Nach 20 Tagen bist du KEIN Senior Developer“

Die harte Realität von einem, der das seit 20 Jahren macht:

„Punkt. Fertig. Das sagt dir keiner, aber ich schon.

Nach 20 Tagen Spring Boot (Basic + Aufbau) hast du ein solides Fundament. Nicht mehr, nicht weniger. Du bist bereit für:

  • ✅ Junior-Position bewerben (realistisch!)
  • ✅ Praktikum mit Spring Boot Fokus (sehr gute Chancen)
  • ✅ Werkstudent in kleineren Firmen (perfekt zum Lernen)
  • ✅ Trainee-Programme (ideal für systematischen Einstieg)

Aber du bist NICHT bereit für Mid-Level oder Senior. Und das ist okay.

Der Unterschied zwischen Junior und Mid-Level? Nicht das Wissen – sondern die Battle Scars. Du musst Production-Probleme lösen, die NICHT in Tutorials vorkommen.“

🌸 Elyndra Valen: „Ich bin vor 8 Jahren genau so gestartet“

Die optimistische Perspektive – aber mit Realismus:

„Cassian hat absolut recht. Aber lass mich dir meine Geschichte erzählen.

Meine ersten Schritte (2017):

Monat 1-2: Das Fundament

  • Spring Boot Online-Kurs gemacht (ähnlich wie du jetzt!)
  • Eigenes Projekt gebaut: Simple Todo-App mit REST API
  • GitHub-Account erstellt, README geschrieben
  • Gefühl: Ich kann was! Aber… reicht das?

Monat 3: Die Ernüchterung

  • Erste Bewerbungen geschickt: 15 Absagen
  • Feedback: „Zu wenig Praxis-Erfahrung“
  • Reality Check: Tutorials != echte Projekte
  • Entscheidung: Ich brauche nachweisbare Erfahrung

Monat 4-6: Open Source Einstieg

  • Angefangen mit good-first-issue Labels auf GitHub
  • Erste Pull Requests: Dokumentation verbessert
  • Dann: Kleine Bugfixes in Spring-Community-Projekten
  • Learning: Wie echte Teams arbeiten, Code-Reviews, Standards

Wichtige Plattformen die mir halfen:

  • GitHub Issues: label:good-first-issue language:java
  • Spring Projects: https://github.com/spring-projects
  • Up For Grabs: https://up-for-grabs.net/#/tags/java

Monat 7-9: Der Durchbruch

  • Mein GitHub-Profil hatte jetzt echte Contributions
  • 15+ Pull Requests, 3 eigene kleine Projekte
  • Bewerbung mit GitHub statt klassischem CV
  • Erste Junior-Position: 32k€/Jahr, kleine Agentur in Köln

Der Unterschied? Nicht mein Wissen, sondern sichtbare Beweise, dass ich im Team arbeiten kann.

Heute, 8 Jahre später:

  • Ich leite ein Team
  • Gehalt: 68k€/Jahr
  • Aber die wichtigste Lektion: Es braucht Zeit

Du schaffst das auch – aber unterschätze nicht die Zeit, die es braucht!“

🎯 Elyndra: „Moment – lasst mich Bountie Hunting erklären!“

Elyndra unterbricht:

„Bevor Jamal seine Geschichte erzählt, lass mich kurz erklären WAS Bountie Hunting überhaupt ist – ich merke, viele von euch haben schon davon gehört, aber wissen nicht genau, wie man anfängt!

🔍 Was ist Bug Bountie Hunting?

Die Kurzversion: Firmen bezahlen dich dafür, dass du Sicherheitslücken in ihren Systemen findest – bevor die Bösen es tun.

Wie es funktioniert:

1. Firma veröffentlicht "Bug Bounty Program"
   → "Findet Bugs in unserer App, wir zahlen!"

2. Du testest ihre App/Website auf Schwachstellen
   → Völlig legal, mit Erlaubnis!

3. Du findest einen Bug (z.B. SQL-Injection)
   → Dokumentierst ihn detailliert

4. Du reichst einen Report ein
   → Firma verifiziert den Bug

5. Du bekommst Geld (Bounty)
   → Je nach Schwere: 50€ bis 50.000€+

🎓 Warum ist das perfekt für Einsteiger?

Als ich das zum ersten Mal hörte, dachte ich: „Moment, ich kann BEZAHLT werden, während ich lerne? Und es hilft meinem Portfolio?“

Die Vorteile für dich:

✅ Lernen durch Praxis

  • Nicht „hier ist ein Tutorial“ → sondern „finde ECHTE Bugs“
  • Du siehst wie reale Apps gebaut sind (und wo sie versagen)
  • Security-Skills die JEDER Arbeitgeber will

✅ Portfolio-Builder

  • HackerOne/Bugcrowd-Profile sind öffentlich
  • Hiring Manager können deine Erfolge sehen
  • „10 valid security reports“ > „Ich habe einen Kurs gemacht“

✅ Kein Chef, keine Deadlines

  • Teste wann du willst (abends, Wochenende)
  • Kein Druck wenn du nichts findest
  • Lerne in deinem eigenen Tempo

✅ Community & Networking

  • Riesige Security-Community (sehr hilfsbereit!)
  • Kontakte zu anderen Researchern
  • Manche werden später Kollegen!

✅ Optionales Einkommen

  • Manche verdienen nebenbei 500-2000€/Monat
  • Nicht garantiert, aber möglich
  • Hauptsache: Portfolio + Skills

🚀 Die Plattformen – Wo fängt man an?

Es gibt mehrere große Bug Bounty Plattformen. Lass mich dir die wichtigsten zeigen:

1. HackerOne (https://www.hackerone.com)

Die Größte & Bekannteste

Warum HackerOne gut für Einsteiger ist:

  • Über 2.000 aktive Programme
  • Viele „Public Programs“ (jeder darf teilnehmen)
  • Gute Dokumentation & Tutorials
  • Große Community

Wie du anfängst:

Schritt 1: Account erstellen
→ Gehe zu https://www.hackerone.com
→ Klicke "Sign Up"
→ Kostenlos, keine Verpflichtungen

Schritt 2: Directory durchsuchen
→ https://hackerone.com/directory/programs
→ Filter: "Accepts submissions from everyone"
→ Sortiere nach "Launched" (neuere Programme = weniger Competition)

Schritt 3: Dein erstes Programm wählen
→ Suche nach Programmen mit:
  • "Managed" Badge (HackerOne hilft beim Triage)
  • Klare "Policy" (wissen was erlaubt ist)
  • Aktive "Thanks" Tab (Firma antwortet schnell)

Beispiel-Programme für Einsteiger:

  • Grammarly (gramm.com) – Web App Testing
  • GitLab (gitlab.com) – Developer Tools
  • Tinder (tinder.com) – Mobile & Web

Bounty-Bereich: 50€ – 10.000€+ (je nach Schwere)

2. Bugcrowd (https://www.bugcrowd.com)

Die Zweite große Plattform

Unterschied zu HackerOne:

  • Etwas weniger Programme
  • Aber oft höhere Bounties
  • Sehr professionelle Triager
  • Gute „Priority“ Bewertung

Wie du anfängst:

Schritt 1: Account erstellen
→ https://www.bugcrowd.com/hackers
→ "Join as a Researcher"

Schritt 2: Programme finden
→ https://bugcrowd.com/programs
→ Filter: "Public" Programs
→ Achte auf "Researcher-Friendly" Badge

Schritt 3: "Getting Started" Guide lesen
→ https://docs.bugcrowd.com/researchers/
→ Bugcrowd hat SEHR gute Docs!

Beispiel-Programme:

  • Tesla (tesla.com) – High-Profile, schwer aber lehrreich
  • Atlassian (atlassian.com) – Jira, Confluence, etc.
  • Western Union (westernunion.com) – Financial Services

Bounty-Bereich: 100€ – 15.000€+

3. Intigriti (https://www.intigriti.com)

Die Europäische Plattform ⭐ MEIN TIPP FÜR DEUTSCHE!

Warum Intigriti besonders für euch:

  • Europäische Firma (Belgien)
  • DSGVO-konform (wichtig!)
  • Viele deutsche/europäische Programme
  • Zahlung in Euro (keine Wechselkurs-Probleme)
  • Deutscher Support verfügbar

Wie du anfängst:

Schritt 1: Account erstellen
→ https://app.intigriti.com/auth/register
→ "I'm a Researcher"

Schritt 2: Researcher Hub erkunden
→ https://app.intigriti.com/researcher/programs
→ Filter: "Public Programs"

Schritt 3: Community beitreten
→ Discord: https://discord.gg/intigriti
→ Sehr aktive, hilfsbereite Community!

Beispiel-Programme:

  • Veepee (veepee.com) – E-Commerce
  • NN Group (nn-group.com) – Versicherung
  • Takeaway (takeaway.com) – Food Delivery

Bounty-Bereich: 50€ – 8.000€

💡 Elyndras Tipp: „Ich empfehle Intigriti für den Start wenn du aus Deutschland kommst – die Community ist freundlicher zu Neulingen und die europäischen Firmen verstehen die DSGVO-Problematik besser!“

4. YesWeHack (https://www.yeswehack.com)

Die französische Alternative

Besonderheiten:

  • Viele französische & europäische Programme
  • Gute „Beginner“ Programme
  • Starke Community in EU
  • Live-Hacking Events

Wie du anfängst:

Schritt 1: Account erstellen
→ https://www.yeswehack.com/en/hunters/register
→ "Hunter Account"

Schritt 2: Programme durchsuchen
→ https://yeswehack.com/programs
→ Achte auf "VDP" Badge für Training

Beispiel-Programme:

  • OVHcloud (ovhcloud.com) – Cloud Provider
  • Orange (orange.com) – Telecom
  • Deezer (deezer.com) – Music Streaming

Bounty-Bereich: 50€ – 5.000€

🎯 VDP vs. Bounty Programs – Der wichtige Unterschied!

Bevor du anfängst, verstehe diesen Unterschied:

VDP (Vulnerability Disclosure Program)

✅ Jeder darf teilnehmen
✅ Kein Druck, kein Stress
✅ Perfekt zum LERNEN
❌ Kein Geld
✅ Aber: "Thank You" & Reputation

Beispiel:
"Wir danken dir öffentlich und listen dich
in unserer Hall of Fame"

👉 START HIER als Anfänger!

Bounty Program

✅ Geld für Bugs (50€ - 50.000€+)
⚠️ Oft höhere Anforderungen
⚠️ Mehr Competition
⚠️ Reports müssen sehr detailliert sein

Beispiel:
"SQL-Injection: Critical → 2.500€ Bounty"

👉 Wechsle hierher nach 2-3 VDP-Reports

📚 Lern-Ressourcen BEVOR du anfängst

Wichtig: Geh NICHT blind rein! Diese Ressourcen sind kostenlos und bereiten dich vor:

1. PortSwigger Web Security Academy ⭐ START HIER!

URL: https://portswigger.net/web-security
Preis: KOSTENLOS
Dauer: 20-40 Stunden (mach in deinem Tempo)

Was du lernst:
✅ SQL-Injection (die häufigste!)
✅ XSS (Cross-Site-Scripting)
✅ CSRF (Cross-Site-Request-Forgery)
✅ Authentication Flaws
✅ Business Logic Flaws

Warum so gut?
→ Interaktive Labs (du übst in echten Szenarien)
→ Schritt-für-Schritt erklärt
→ Von PortSwigger (die machen Burp Suite)

Elyndras Empfehlung: „Ich habe ZUERST die Academy gemacht, DANN angefangen zu testen. Das hat mir SO viel Zeit gespart! Du musst die Basics kennen!“

2. OWASP Top 10

URL: https://owasp.org/www-project-top-ten/
Preis: KOSTENLOS

Was es ist:
Die 10 häufigsten Web-Schwachstellen
Updated alle paar Jahre

Warum wichtig?
→ 90% aller Bugs sind auf dieser Liste
→ Jedes Interview fragt nach OWASP
→ Verstehen = halber Erfolg

3. Bug Bounty Bootcamp (Buch)

Autorin: Vickie Li
Preis: ~30€ (Buch) oder PDF online suchen
Level: Anfänger bis Intermediate

Was es bietet:
→ Systematischer Aufbau
→ Echte Bug-Beispiele
→ Methodologie für Testing
→ Tools & Workflows

Elyndras Meinung:
"Das beste Buch zum Einstieg. Kauft es!"

4. YouTube Channels

• NahamSec: https://www.youtube.com/@NahamSec
  → Live Hacking, Bug Bounty Tips
  
• STÖK: https://www.youtube.com/@STOKfredrik
  → Recon, Methodology, Mindset
  
• InsiderPhD: https://www.youtube.com/@InsiderPhD
  → Anfängerfreundlich, Web Hacking
  
• LiveOverflow: https://www.youtube.com/@LiveOverflow
  → Technischer, aber sehr gut erklärt

5. Twitter/X Security Community

Folge diesen Accounts:
• @NahamSec
• @stokfredrik
• @TomNomNom
• @bugcrowd
• @Hacker0x01 (HackerOne official)

Warum?
→ Neue Techniken werden gepostet
→ Program-Launches announced
→ Community ist sehr aktiv!

🛠️ Tools die du brauchst (alle KOSTENLOS für Start!)

1. Burp Suite Community Edition ⭐ PFLICHT!

URL: https://portswigger.net/burp/communitydownload
Preis: KOSTENLOS (für Community Edition)

Was es macht:
→ Web Proxy (fängt HTTP-Requests ab)
→ Repeater (wiederholt Requests mit Änderungen)
→ Intruder (automatisiert Tests)
→ Scanner (in Pro Version, Community = manuell)

Warum nötig?
→ 90% aller Bug Hunter nutzen Burp
→ Industry Standard
→ Ohne Burp = schwer zu testen

Tutorial:
→ PortSwigger Academy hat Burp-Tutorials integriert

2. Firefox + FoxyProxy

Browser: Firefox (besser als Chrome für Hacking)
Extension: FoxyProxy
→ https://addons.mozilla.org/en-US/firefox/addon/foxyproxy-standard/

Warum?
→ Leitet Traffic durch Burp
→ Easy Proxy-Switching
→ Firefox Developer Tools sind besser

3. OWASP ZAP (Alternative zu Burp)

URL: https://www.zaproxy.org/
Preis: KOMPLETT KOSTENLOS & Open Source

Was es macht:
→ Ähnlich wie Burp Suite
→ Manche bevorzugen ZAP
→ Vollständiger Scanner gratis!

Elyndras Meinung:
"Ich nutze Burp, aber ZAP ist auch gut.
Probier beide und entscheide selbst!"

4. Postman / Insomnia

Postman: https://www.postman.com/
Insomnia: https://insomnia.rest/

Was sie machen:
→ API Testing
→ Request Builder
→ Collections speichern

Warum wichtig?
→ REST APIs testen (dein Spring Boot Wissen!)
→ Schneller als Burp für simple Tests

⚠️ Die WICHTIGSTEN Regeln – LIES DAS!

Bevor du anfängst zu testen, musst du diese Regeln kennen:

1. NUR autorisierte Programme testen!

❌ NIEMALS eine App testen ohne Erlaubnis!
❌ "Ich teste nur zum Lernen" = ILLEGAL!
✅ NUR Programme auf HackerOne/Bugcrowd/etc.

Warum so wichtig?
→ Ohne Erlaubnis = Hacking = Straftat!
→ Selbst mit guten Absichten = Illegal!

§ 202a StGB (Deutschland):
"Unbefugtes Ausspähen von Daten"
→ Bis zu 3 Jahre Gefängnis!

Elyndras Warnung: „ICH MEINE DAS ERNST! Teste NUR autorisierte Programme! Kein ‚ich teste nur Netflix zum Üben‘ – das ist ILLEGAL und kann dein Leben ruinen!“

2. Scope beachten!

Jedes Programm hat einen "Scope":
✅ In-Scope: Darfst du testen
❌ Out-of-Scope: NICHT testen!

Beispiel:
In-Scope:
• *.example.com
• mobile.example.com

Out-of-Scope:
• example.com/admin (Don't test!)
• partners.example.com (Don't test!)

Warum wichtig?
→ Out-of-Scope testen = Report wird rejected
→ Kann zu Ban führen

3. Keine DoS/DDoS Angriffe!

❌ Niemals Server überlasten
❌ Keine Brute-Force Angriffe (außer erlaubt)
❌ Keine Automated Scans ohne Erlaubnis

Warum?
→ Kostet Firma Geld
→ Schadet echten Usern
→ Führt zu sofortigem Ban

4. Gute Reports schreiben!

Ein guter Bug Report hat:
✅ Klare Steps to Reproduce
✅ Screenshots/Videos
✅ Impact Explanation
✅ Proof of Concept Code
✅ Suggested Fix (optional, aber gut!)

Schlechter Report:
"SQL-Injection in login form"

Guter Report:
"SQL-Injection in login form allows
complete database extraction.

Steps to Reproduce:
1. Go to https://example.com/login
2. Enter username: admin' OR '1'='1
3. Password: any
4. Click Login
5. Observe: Full database access

Impact: Attacker can extract all user data
including passwords, emails, credit cards.

Proof: [Screenshot of database dump]
Tested on: 2025-01-15 14:30 UTC"

📝 Deine ersten Schritte – 4-Wochen-Plan

Hier ist mein Plan für deinen Start:

Woche 1: Lernen

Montag-Freitag (2h/Tag):
□ PortSwigger Web Security Academy
  → Mach SQL-Injection Sektion komplett
  → Mach XSS Sektion komplett
  
□ Installiere Burp Suite
  → Folge Tutorials auf PortSwigger
  → Übe mit den Academy Labs

Wochenende (4h):
□ Lies OWASP Top 10
□ Schau 2-3 NahamSec Videos
□ Erstelle Accounts auf HackerOne & Intigriti

Woche 2: Reconnaissance lernen

Reconnaissance = Informationen sammeln

Was du lernst:
□ Subdomains finden (Subdomain Enumeration)
□ Tech-Stack identifizieren (Wappalyzer)
□ Endpoints entdecken (Directory Bruteforce)
□ Parameter testen (Fuzzing)

Tools:
• Sublist3r (Subdomains)
• Wappalyzer (Browser Extension)
• DirBuster / Gobuster (Directory Scan)

Tutorial:
https://www.youtube.com/watch?v=... (Suche: "Bug Bounty Recon")

Woche 3: Dein erstes VDP

Montag:
□ Wähle ein VDP-Programm auf Intigriti
  → Filter: "VDP" + "Public"
  → Wähle eins mit Webseite (keine Mobile App)
  
Dienstag-Donnerstag:
□ Reconnaissance (sammle Infos)
  → Welche Subdomains gibt es?
  → Welche Technologien werden verwendet?
  → Wo sind Login-Forms?
  
Freitag-Sonntag:
□ Teste auf simple Bugs
  → SQL-Injection in Forms
  → XSS in Input-Fields
  → Open Redirects

Woche 4: Dein erster Report

Ziel: 1 Report einreichen (egal ob valid oder nicht!)

□ Dokumentiere ALLES
  → Screenshots
  → Steps to Reproduce
  → Impact

□ Schreibe den Report
  → Nutze Template von HackerOne/Intigriti
  
□ Reiche ein!
  → Nervös? Normal!
  → Wird rejected? Lerne daraus!
  
□ Warte auf Response
  → Kann 1-7 Tage dauern
  → Sei geduldig!

💡 Elyndras abschließende Tipps

Das habe ICH gelernt (und wünschte ich hätte es früher gewusst):

  1. Start mit VDP, nicht Bounty
    • Kein Druck
    • Lerne die Prozesse
    • Baue Reputation
  2. 90% der Tests finden NICHTS
    • Das ist normal!
    • Nicht entmutigen lassen!
    • Die 10% wenn du was findest = unbezahlbar
  3. Community ist Gold wert
    • Discord/Twitter beitreten
    • Fragen stellen (alle waren mal Anfänger!)
    • Live-Hacking-Events besuchen
  4. Dokumentiere ALLES
    • Auch wenn kein Bug
    • Lerne aus Failures
    • Baue deine Methodologie
  5. Kombiniere es mit Spring Boot!
    • Verstehe Angriff UND Verteidigung
    • Baue sichere Apps
    • Das macht dich wertvoll!

**Okay, jetzt übergebe ich an Jamal – er zeigt dir wie er es WIRKLICH gemacht hat, mit seiner kompletten Timeline und echten Zahlen!“

🛡️ Code Sentinel: „Der Markt hat sich verändert“

Die pragmatische Security-Perspektive:

„Moin! Code Sentinel hier. Lass mich dir die Zahlen zeigen – ohne Beschönigung.

Realistische Gehälter in Deutschland (2025):

Junior-Stelle (0-2 Jahre Erfahrung):

  • Großstädte (München, Stuttgart, Frankfurt): 38-45k€/Jahr
  • Mittelgroße Städte (Köln, Düsseldorf, Hannover): 32-40k€/Jahr
  • Kleinere Städte (Paderborn, Göttingen): 28-36k€/Jahr
  • Ländliche Regionen / Osten: 26-32k€/Jahr

Was Arbeitgeber bei Juniors suchen:

  • ✅ Spring Boot Basics (hast du!)
  • ✅ Git & Maven/Gradle (hast du!)
  • ✅ REST APIs (hast du!)
  • ✅ 2-3 eigene Projekte im GitHub (❓ hast du das?)
  • ✅ Team-Erfahrung (⚠️ kommt noch!)
  • ✅ Bonus: Security-Grundlagen

Mid-Level (2-5 Jahre, 45-65k€/Jahr):

  • ❌ Production-Erfahrung (hast du nicht)
  • ⚠️ Microservices (nur Theorie)
  • ❌ Incident-Handling & On-Call
  • ❌ Legacy-Code-Wartung

Senior (5+ Jahre, 65-90k€/Jahr):

  • ❌ Architektur-Entscheidungen getroffen
  • ❌ Teams geleitet
  • ❌ Production-Katastrophen überlebt

Mein Rat:

Wir stellen regelmäßig Juniors ein. Was zählt?

Drei Dinge:

  1. Eigene Projekte (GitHub mit gutem README!)
  2. Lernbereitschaft zeigen (Blog, Contributions)
  3. Code live schreiben können (Coding Interviews überleben)

Die technischen Skills hast du – jetzt brauchst du Sichtbarkeit.“

🔥 Jamal: „Bountie Hunting hat mein Leben verändert“

Die Geschichte vom Quereinsteiger:

„Yo, Jamal hier! Ich muss euch was erzählen.

Mein Background:

  • 2019: Ausbildung zum Fachinformatiker abgebrochen
  • 2020: Online Java-Kurs gemacht
  • Problem: Keine Berufserfahrung, kein Studium, nur Theorie
  • Bewerbungen: 20+ Absagen mit „zu wenig Praxis“

Der Game-Changer: Bountie Hunting

Was ist das? Bug Bounty Hunting = Firmen zahlen dich, wenn du Sicherheitslücken in ihren Systemen findest.

Warum ich damit angefangen habe:

  • Braucht keine formale Ausbildung
  • Braucht keine Berufserfahrung
  • Jeder kann mitmachen
  • Du lernst echte Security, nicht nur Theorie

Meine Timeline:

Monat 1-2: Die Anfänge (Januar – Februar 2021)

Plattformen auf denen ich startete:

  • HackerOne (https://www.hackerone.com)
    • Start mit öffentlichen Programmen
    • Filter: „Accepts submissions from everyone“
  • Bugcrowd (https://www.bugcrowd.com)
    • Gute Dokumentation für Anfänger
    • Community ist hilfsbereit
  • Intigriti (https://www.intigriti.com)
    • Europäisch, DSGVO-konform
    • Viele deutsche/europäische Programme

Was ich gemacht habe:

  • OWASP Top 10 studiert (kostenlos!)
  • Web Security Academy von PortSwigger durchgearbeitet
  • Burp Suite installiert (Community Edition = gratis)
  • Erste Versuche: Nur VDP Programme (Vulnerability Disclosure = kein Geld, aber auch kein Druck!)

Erste Erfolge:

  • Erste XSS-Lücke gefunden in einem Testprogramm
  • Kein Geld bekommen, aber öffentlich bedankt
  • Profil aufgebaut: „1 valid report“ steht besser als „0“

Monat 3-4: Erste echte Bounties (März – April 2021)

Der erste bezahlte Bug:

  • SQL-Injection in einem kleinen E-Commerce-Programm
  • Bounty: 150€
  • Gefühl: Wie Weihnachten und Geburtstag zusammen! 🎉

Was ich lernte:

  • Reconnaissance ist 80% der Arbeit
  • Burp Suite Intruder ist dein Freund
  • Geduld: 90% der Tests finden nichts
  • Dokumentation: Gute Reports = bessere Bounties

Parallel dazu:

  • Spring Security richtig verstanden (nicht nur Tutorial-Wissen)
  • Defensive Programming gelernt (durch Angriffe verstehen)
  • Eigene Apps mit echten Security-Features gebaut

Monat 5-8: Der Aufbau (Mai – August 2021)

Statistik nach 6 Monaten:

  • Reports submitted: 47
  • Valid bugs: 12
  • Bounties verdient: ~800€ (nicht viel, aber…)
  • Wichtiger: Portfolio aufgebaut!

Was in meinem Portfolio stand:

  • ✅ HackerOne-Profil: „12 valid reports, 8/10 reputation“
  • ✅ Bugcrowd-Profil: „Top 15% of researchers“
  • ✅ GitHub: Spring Boot App mit richtiger Security
  • ✅ Blog: „Was ich über SQL-Injection gelernt habe“

Monat 9: Der Bewerbungs-Erfolg (September 2021)

Neue Bewerbungs-Strategie:

Klassischer CV:
❌ Keine Berufserfahrung
❌ Keine abgeschlossene Ausbildung

Neuer Approach:
✅ HackerOne Profil-Link im CV
✅ "Security Researcher" als Erfahrung
✅ Eigene Spring Boot Security-Demo auf GitHub
✅ Blog über Security-Testing

Erste Interview:

  • Hiring Manager: „Du hast SQL-Injection gefunden? Zeig mir wie.“
  • Ich: Live Demo mit Burp Suite
  • Seine Reaktion: „Du kannst offensiv UND defensiv denken. Das brauchen wir.“

Ergebnis:

  • Junior Security Engineer Position
  • 35k€/Jahr in Dortmund
  • Remote-Option 3 Tage/Woche
  • Nach 2 Jahren: 48k€/Jahr, Mid-Level

Warum Bountie Hunting funktioniert hat:

1. Praktische Skills

  • Nicht „Ich habe einen Kurs gemacht“
  • Sondern „Ich habe 12 echte Sicherheitslücken gefunden“

2. Nachweisbare Erfolge

  • HackerOne/Bugcrowd Profile = öffentliche Portfolios
  • Jeder kann deine Stats sehen
  • „Hall of Fame“ Einträge = Referenzen

3. Echtes Problem-Solving

  • Keine Tutorial-Probleme
  • Echte Apps, echte Bugs, echte Konsequenzen
  • Du lernst zu denken wie ein Angreifer

4. Community & Netzwerk

  • Bug Bounty Forum (https://bugbountyforum.com)
  • Twitter Security Community
  • Kontakte zu anderen Researchern

5. Geringes Risiko

  • Start mit VDP (kein Geld, kein Stress)
  • Lerne in deinem Tempo
  • Kein Chef, keine Deadlines

Meine Tipps für deinen Start:

Woche 1-2: Grundlagen legen

# Was du brauchst (alles kostenlos!):
- Burp Suite Community Edition
- OWASP ZAP (Alternative zu Burp)
- Firefox mit FoxyProxy Extension
- Account auf HackerOne + Bugcrowd

Resources die ich genutzt habe:

  • Web Security Academy (https://portswigger.net/web-security)
    • Kostenlos, interaktiv, TOP!
  • OWASP Testing Guide
    • Das Handbuch für Security-Testing
  • Bug Bounty Bootcamp (Buch von Vickie Li)
    • Beste Einführung in Bountie Hunting
  • HackerOne Hacktivity Feed
    • Lerne von anderen Reports

Woche 3-4: Erste Tests

Mein erster Testplan:
1. Start mit VDP Programmen (kein Druck!)
2. Focus: Input Validation Bugs (XSS, SQLi)
3. Tool: Burp Suite Scanner als Unterstützung
4. Ziel: 1 valid report in 2 Wochen

Realistische Erwartungen:

  • Monat 1: Viele Tests, keine Funde = normal!
  • Monat 2: Vielleicht erste kleine Bugs
  • Monat 3-6: Langsam Routine entwickeln
  • Nach 6 Monaten: Solides Verständnis, Portfolio aufgebaut

Kombiniere es mit Spring Boot:

Das war mein Secret Sauce:

Phase 1: Lernen durch Angriff

  • Finde XSS in fremden Apps
  • Danach: Baue Spring Boot App ohne XSS
  • Verstehe warum die Lücke existierte

Phase 2: Defensive Skills

  • Jeder Bug den du findest = Lektion
  • Implementiere die Fixes in deinen eigenen Apps
  • Dein Portfolio: „Ich kenne Angriff UND Verteidigung“

Phase 3: Das Interview

  • Demo: Zeige einen Bug den du gefunden hast
  • Danach: Zeige wie du ihn in Spring Boot verhindert hättest
  • Interviewer denkt: „Der versteht Security wirklich!“

Was es mir gebracht hat:

Technisch:

  • ✅ Spring Security wirklich verstanden
  • ✅ Input Validation nicht nur copy-paste
  • ✅ @PreAuthorize sinnvoll einsetzen
  • ✅ OWASP Top 10 in der Praxis

Karriere:

  • ✅ Junior Position trotz fehlendem Abschluss
  • ✅ Nach 2 Jahren: Mid-Level Security Engineer
  • ✅ Heute: 48k€, Remote, spannende Projekte
  • ✅ Nebenbei noch Bounties (passives Einkommen!)

Persönlich:

  • ✅ Selbstbewusstsein: Ich KANN was!
  • ✅ Community: Kontakte weltweit
  • ✅ Problem-Solving: Denken wie ein Hacker

Wichtige Warnung:

Bountie Hunting ist NICHT:

  • ❌ Schnelles Geld (99% der Tests finden nichts)
  • ❌ Einfach (braucht viel Geduld)
  • ❌ Garantiert (keine festen Einnahmen)

Aber es IST:

  • ✅ Praktisches Lernen (besser als jedes Tutorial)
  • ✅ Portfolio-Builder (nachweisbare Skills)
  • ✅ Networking-Tool (lerne die Community kennen)
  • ✅ Karriere-Booster (zeigt Initiative & Skills)

Mein Fazit:

Bountie Hunting hat mir das gegeben, was Bewerbungen nicht konnten:

  • Beweise statt Behauptungen
  • Praxis statt Theorie
  • Netzwerk statt Isolation
  • Selbstvertrauen statt Imposter Syndrome

Ja, es dauert Monate. Ja, es ist manchmal frustrierend. Aber es war mein Einstiegsticket – und es kann deins auch sein! 💪“

🌍 Kofi: „Open Source war mein Weg – hier ist die komplette Anleitung“

Die Geschichte vom stillen Contributor:

„Hi, Kofi hier. Englisch ist nicht meine Muttersprache, also verzeiht Fehler.

Elyndra hat Bountie Hunting super erklärt – jetzt zeige ich dir Open Source. Genauso detailliert, damit du genau weißt wo und wie du anfängst!

🎯 Was ist Open Source Contribution überhaupt?

Die Kurzversion: Open Source = Code ist öffentlich auf GitHub. Du kannst mithelfen, ihn zu verbessern – und damit dein Portfolio aufbauen!

Wie es funktioniert:

1. Projekt auf GitHub finden
   → Tausende Projekte suchen Hilfe!

2. Issue aussuchen ("Good First Issue")
   → Anfängerfreundliche Aufgaben

3. Code ändern (Bug fixen, Feature hinzufügen)
   → Du arbeitest lokal an deiner Kopie

4. Pull Request erstellen
   → "Hier ist meine Lösung!"

5. Code-Review & Merge
   → Maintainer prüfen → MERGED! 🎉

🎓 Warum Open Source perfekt für Einsteiger ist

Meine Story:

  • Ghana → Deutschland, 2018
  • Informatik-Studium angefangen
  • 2020: Studium abgebrochen (Sprache + Corona)
  • Problem: Keine deutschen Zertifikate, bescheidenes Deutsch
  • Lösung: Code spricht jede Sprache!

Warum es für MICH funktionierte:

✅ Keine perfekte Sprache nötig

  • Code-Comments können einfach sein
  • Pull Request Description = Templates helfen
  • Kein Bewerbungsgespräch auf Deutsch (am Anfang)

✅ Portfolio das für sich spricht

  • Nicht „Ich kann Java“ → Sondern „Hier ist mein Code“
  • Public Contributions = jeder kann sie sehen
  • Merged PRs = Beweis dass dein Code gut genug ist

✅ Team-Experience

  • Code-Reviews wie in echten Jobs
  • Git-Workflows lernen (Branch, Rebase, Squash)
  • Issue-Tracking & Kommunikation
  • Das ist was Arbeitgeber sehen wollen!

✅ Networking

  • Maintainer sind oft Hiring Manager
  • Community-Kontakte weltweit
  • Manche werden später Kollegen

✅ Kostenlos & Flexibel

  • Arbeite wann du willst
  • Kein Chef, keine Deadlines
  • Wenn Leben stressig = Pause ok

🔍 Plattformen & Tools zum Finden von Projekten

Es gibt mehrere Wege, das perfekte Projekt zu finden:

1. GitHub „Good First Issue“ Suche ⭐ START HIER!

Die direkte Methode:

Suche auf GitHub:
https://github.com/search?q=label%3A%22good+first+issue%22+language%3Ajava+is%3Aopen

Was diese Suche macht:
→ label:"good first issue" (anfängerfreundlich!)
→ language:java (deine Sprache!)
→ is:open (noch offen!)

Filter hinzufügen:
• Sort by: "Recently updated" (aktive Projekte!)
• Stars: >100 (beliebte Projekte)

Erweiterte Suche für verschiedene Labels:

"Good First Issue":
https://github.com/search?q=label%3A%22good+first+issue%22+language%3Ajava+is%3Aopen

"Beginner Friendly":
https://github.com/search?q=label%3A%22beginner+friendly%22+language%3Ajava+is%3Aopen

"Help Wanted":
https://github.com/search?q=label%3A%22help+wanted%22+language%3Ajava+is%3Aopen

"First Timers Only":
https://github.com/search?q=label%3A%22first+timers+only%22+language%3Ajava+is%3Aopen

Kofi’s Tipp: „Ich habe IMMER mit ‚recently updated‘ sortiert. Tote Projekte frustrieren nur – du willst schnelle Code-Reviews!“

2. Good First Issue (https://goodfirstissue.dev)

Die kuratierte Liste!

Was es ist: → Website sammelt „Good First Issues“ von vielen Projekten → Übersichtlicher als GitHub-Suche → Kategorisiert nach Sprachen

Wie du es nutzt:

Schritt 1: Gehe zu https://goodfirstissue.dev
Schritt 2: Klicke auf "Java" Tag
Schritt 3: Browse die Issues
Schritt 4: Klicke "View on GitHub" für Details

Vorteile:

  • ✅ Vorgefilter (nur anfängerfreundliche Issues!)
  • ✅ Übersichtlich (keine GitHub-Suche-Syntax nötig)
  • ✅ Updates täglich

Nachteil:

  • ⚠️ Nicht alle Java-Projekte sind hier
  • ⚠️ GitHub-Suche findet mehr

3. Up For Grabs (https://up-for-grabs.net)

Die Alternative!

Was anders ist: → Projekte MÜSSEN sich manuell registrieren → Bedeutet: Projekte WOLLEN Contributor! → Oft bessere Docs & Contributor-Guides

Wie du es nutzt:

Schritt 1: Gehe zu https://up-for-grabs.net/#/tags/java
Schritt 2: Filter nach "Java"
Schritt 3: Klicke auf Projekt-Namen
Schritt 4: Lies "Contributing Guidelines"

Beispiel-Projekte auf Up For Grabs:

  • JUnit Pioneer – Testing Extensions
  • Apache Commons – Utility Libraries
  • Checkstyle – Code Quality Tool

Kofi’s Meinung: „Up For Grabs Projekte sind meist besser dokumentiert – die WOLLEN dass du hilfst!“

4. Code Triage (https://www.codetriage.com)

Der Email-Service!

Was es macht: → Du abonnierst Projekte → Bekommst täglich Issues per Email → Hilft dir, dran zu bleiben

Wie du es nutzt:

Schritt 1: Gehe zu https://www.codetriage.com
Schritt 2: Sign Up mit GitHub
Schritt 3: Suche Java-Projekte
Schritt 4: "Subscribe" auf 2-3 Projekte
Schritt 5: Bekomme täglich Issues per Email!

Warum cool:

  • ✅ Passive Discovery (keine Suche nötig)
  • ✅ Consistency (täglich neue Issues)
  • ✅ Motivation (Emails erinnern dich)

Kofi’s Workflow: „Ich habe 3 Projekte abonniert. Jeden Morgen: Kaffee + Code Triage Emails = mein Ritual!“

5. First Timers Only (https://www.firsttimersonly.com)

Speziell für deine ERSTE Contribution!

Was besonders ist: → Issues die EXTRA für First-Timer erstellt wurden → Meist super detailliert beschrieben → Maintainer erwarten Anfänger-Fragen

Wie du es nutzt:

Schritt 1: Gehe zu https://www.firsttimersonly.com
Schritt 2: Klicke "Get Involved"
Schritt 3: Lies "How to Contribute to Open Source"
Schritt 4: Browse Issues mit "first-timers-only" Label

Typisches „First Timers Only“ Issue:

Issue #123: [First Timers Only] Fix typo in README

This is a "first timers only" issue!

What needs to be done?
• Line 45 in README.md has a typo: "recieve" → "receive"

How to fix it?
1. Fork this repository
2. Edit README.md (line 45)
3. Commit with message: "Fix typo in README.md"
4. Create Pull Request

Need help?
Comment here and we'll help you! 😊

Kofi’s Erfahrung: „Mein ERSTER PR war ein Typo-Fix von First Timers Only. Simple, aber ich lernte den ganzen Prozess!“

🎯 Die besten Projekte für Spring Boot Developer

Du hast Spring Boot gelernt – hier sind Projekte wo das hilft:

1. Spring Projekte (https://github.com/spring-projects) ⭐ TOP WAHL!

Warum perfekt für dich:

  • Du kennst Spring Boot
  • Riesige Community
  • Professionelle Code-Reviews (lernst SO viel!)
  • „Spring Contributor“ im CV = 🔥

Wichtige Repositories:

Spring Boot (https://github.com/spring-projects/spring-boot)

Stars: 75k+
Good First Issues: ~10-20 aktive
Schwierigkeit: Mittel

Typische Issues:
• Dokumentation verbessern
• Sample-Apps aktualisieren
• Kleine Bugs in Auto-Configuration

Warum gut:
→ Du verstehst den Code (hast gerade gelernt!)
→ Spring Team macht super Code-Reviews
→ "Contributed to Spring Boot" = Premium-Portfolio!

Spring Petclinic (https://github.com/spring-projects/spring-petclinic)

Stars: 8k+
Good First Issues: ~5-10 aktive
Schwierigkeit: Einfach - Mittel

Was es ist:
→ Demo-App zum Lernen
→ Klassisches CRUD-Beispiel
→ Wird ständig aktualisiert

Typische Issues:
• Dependencies upgraden
• Tests hinzufügen
• UI verbessern
• Neue Features implementieren

Warum PERFEKT für Einsteiger:
→ Kleine Codebase (überschaubar!)
→ Viele "good first issue" Labels
→ Maintainer sind sehr geduldig
→ Du kannst das ganze Projekt verstehen!

Spring Framework (https://github.com/spring-projects/spring-framework)

Stars: 57k+
Schwierigkeit: Schwer (für später!)

Warum erwähnen:
→ Core Framework
→ Schwieriger, aber lehrreich
→ Für wenn du fortgeschritten bist

Kofi's Rat:
"Start NICHT hier! Zu komplex für Anfang.
Spring Boot oder Petclinic first!"

2. Testing Libraries (gut für dein Wissen!)

JUnit Pioneer (https://github.com/junit-pioneer/junit-pioneer)

Stars: 700+
Good First Issues: ~5-10 aktive
Schwierigkeit: Einfach - Mittel

Was es ist:
→ Extensions für JUnit 5
→ Du hast JUnit gelernt! (Tag 5)

Typische Issues:
• Neue @Extension implementieren
• Tests schreiben (Meta! 😄)
• Dokumentation verbessern

Warum perfekt:
→ Kleine, fokussierte Contributions
→ Super freundliche Maintainer
→ Du verstehst Testing!

AssertJ (https://github.com/assertj/assertj)

Stars: 2.7k+
Schwierigkeit: Mittel

Was es ist:
→ Fluent Assertions für Java
→ Du hast es vielleicht benutzt!

Warum gut:
→ Klarer Code
→ Gute Docs
→ Testing-Knowledge hilft

Testcontainers (https://github.com/testcontainers/testcontainers-java)

Stars: 8k+
Schwierigkeit: Mittel - Schwer

Was es ist:
→ Docker Containers für Tests
→ Du hast Docker gelernt! (Tag 8)

Warum erwähnen:
→ Kombiniert Docker + Testing
→ Sehr gefragt in Jobs!
→ Für fortgeschritten

3. Utility Libraries (einfacher Einstieg!)

Apache Commons (https://github.com/apache/commons-lang)

Stars: 2.8k+
Good First Issues: ~3-5 aktive
Schwierigkeit: Einfach - Mittel

Was es ist:
→ Utility-Funktionen für Java
→ StringUtils, DateUtils, etc.

Typische Issues:
• Neue Utility-Methoden
• Bug-Fixes
• Performance-Improvements

Warum gut für Anfang:
→ Klare, kleine Funktionen
→ Gut getestet
→ Einfach zu verstehen

Google Guava (https://github.com/google/guava)

Stars: 50k+
Schwierigkeit: Mittel

Was es ist:
→ Google's Core Libraries
→ Collections, Caching, etc.

Warum erwähnen:
→ Premium-Projekt (Google!)
→ Sehr hohe Code-Quality
→ Schwieriger, aber lohnend

4. Build Tools (nutzt du eh!)

Maven Wrapper (https://github.com/apache/maven-wrapper)

Stars: 1.5k+
Schwierigkeit: Einfach

Was es ist:
→ Das `mvnw` Script das du nutzt!

Warum cool:
→ Du benutzt es in jedem Projekt
→ Simple Codebase
→ Direkt relevant

Gradle (https://github.com/gradle/gradle)

Stars: 17k+
Schwierigkeit: Mittel - Schwer

Warum erwähnen:
→ Alternative zu Maven
→ Große Codebase
→ Für später

📚 Wie finde ich das RICHTIGE Projekt für mich?

Meine Checkliste (nutze ich immer noch!):

✅ 1. Ist es AKTIV?
   → Letzte Updates < 1 Monat
   → Issues werden beantwortet < 1 Woche
   → Pull Requests werden reviewed

✅ 2. Hat es GUTE Docs?
   → README erklärt was es macht
   → CONTRIBUTING.md vorhanden
   → CODE_OF_CONDUCT.md vorhanden
   
✅ 3. Ist es FREUNDLICH?
   → "good first issue" Labels existieren
   → Contributor-Liste hat "first-time contributors"
   → Issues haben hilfreiche Antworten

✅ 4. Verstehe ich den CODE?
   → Klone es lokal
   → Kann ich es builden? (mvn clean install)
   → Verstehe ich die Struktur?

✅ 5. Kann ich BEITRAGEN?
   → Gibt es Issues die ich lösen kann?
   → Sind sie klar beschrieben?
   → Sind Dependencies aktuell?

Kofi’s Rot-Flaggen (Finger weg!):**

❌ Letzte Activity > 6 Monate
   → Totes Projekt = dein PR wird nie reviewed

❌ Kein CONTRIBUTING.md
   → Maintainer wollen keine Contributor

❌ Issues werden nie beantwortet
   → Zeitverschwendung

❌ Pull Requests stapeln sich unreviewed
   → Maintainer sind überfordert

❌ Unhöfliche Comments in Issues
   → Toxische Community = nicht deine Zeit wert

🛠️ Tools die du brauchst (Setup Guide!)

1. Git (PFLICHT!)

# Installieren (wenn noch nicht):

# Windows:
# Download von https://git-scm.com/download/win

# Mac:
brew install git

# Linux:
sudo apt-get install git  # Ubuntu/Debian
sudo yum install git       # CentOS/Fedora

# Konfigurieren:
git config --global user.name "Dein Name"
git config --global user.email "deine@email.com"

# SSH-Key für GitHub (empfohlen!):
ssh-keygen -t ed25519 -C "deine@email.com"
# Dann zu GitHub hinzufügen:
# https://github.com/settings/keys

Warum SSH-Key wichtig:

  • Kein Passwort-Eingabe jedes Mal
  • Sicherer
  • Professionell

2. GitHub Account (PFLICHT!)

Schritt 1: Registrieren
→ https://github.com/signup
→ Wähle einen PROFESSIONELLEN Namen!
   ✅ Gut: kofi-mensah, elyndra-dev
   ❌ Schlecht: coolguy123, hackerman99

Schritt 2: Profil ausfüllen
→ Profilbild (professionell!)
→ Bio schreiben ("Junior Java Developer")
→ Location (Deutschland / Deine Stadt)
→ Website/Blog (wenn vorhanden)

Schritt 3: SSH-Key hinzufügen
→ Settings → SSH and GPG keys
→ New SSH key
→ Paste deinen public key

Schritt 4: Email Preferences
→ Settings → Notifications
→ Wähle wie oft du Notifications willst

Kofi’s Profil-Tipps:

✅ Nutze echten Namen (builds trust!)
✅ Bio: Kurz & präzise
   "Java Developer | Spring Boot | Open Source Contributor"
✅ Pin deine besten Repositories (später!)
✅ README.md für dein Profil (https://github.com/username)

3. IDE Setup (NetBeans hast du schon!)

NetBeans ist perfekt, aber optimize it:

Schritt 1: Git Integration aktivieren
→ Team → Git → Initialize Repository

Schritt 2: GitHub Plugin (optional)
→ Tools → Plugins
→ Search "GitHub"
→ Macht PRs einfacher!

Schritt 3: Code-Style
→ Tools → Options → Editor → Formatting
→ Stelle Java Code-Style ein
→ Wichtig: Projekt-eigene Style nutzen!

Alternative: IntelliJ IDEA Community

Download: https://www.jetbrains.com/idea/download/
Preis: KOSTENLOS (Community Edition)

Warum erwähnen:
→ Viele Open Source Projekte nutzen IntelliJ
→ Bessere Git Integration
→ Mächtiger Refactoring

Kofi nutzt: IntelliJ für Open Source, NetBeans für eigene Projekte

4. Nützliche Git Commands (lerne diese!)

Die Commands die ich JEDEN Tag nutze:

# Repository klonen:
git clone https://github.com/user/project.git
cd project

# Branch erstellen (für deine Änderung):
git checkout -b fix/issue-123

# Änderungen sehen:
git status
git diff

# Änderungen stagen & committen:
git add .
git commit -m "Fix bug in UserService"

# Zu Main/Master Branch wechseln:
git checkout main

# Neueste Änderungen vom Remote holen:
git pull origin main

# Deinen Branch pushen:
git push origin fix/issue-123

# Branch löschen (nach Merge):
git branch -d fix/issue-123

Fortgeschrittene Commands (für später):

# Commits zusammenfassen (Squash):
git rebase -i HEAD~3

# Branch auf neuesten Main rebased:
git rebase main

# Änderungen temporär weglegen:
git stash
git stash pop

# Commit-Message ändern:
git commit --amend

📝 Deine erste Contribution – Kompletter Workflow

Hier ist GENAU was du machst, Schritt für Schritt:

Phase 1: Projekt & Issue finden (Tag 1)

Schritt 1: Projekt wählen
→ Nutze goodfirstissue.dev ODER GitHub-Suche
→ Wähle ein Projekt nach Checkliste oben
→ Beispiel: Spring Petclinic

Schritt 2: Repository analysieren
→ Lies README.md komplett
→ Lies CONTRIBUTING.md (WICHTIG!)
→ Lies CODE_OF_CONDUCT.md
→ Check Issue-Labels (welche existieren?)

Schritt 3: Issue finden
→ Browse "good first issue" Label
→ Wähle eins das du verstehst
→ Lies Issue KOMPLETT
→ Check: Ist es noch offen? Arbeitet jemand dran?

Schritt 4: Issue "claimen"
→ Kommentiere: "I'd like to work on this. Is it still available?"
→ Warte auf Antwort (meist < 24h)
→ Wenn approved: Start working!

Beispiel-Issue (Spring Petclinic):

Issue #456: [good first issue] Add validation for pet age

Description:
Currently, the pet age field accepts negative numbers.
This should be validated to only accept positive integers.

Acceptance Criteria:
• Age must be >= 0
• Age must be < 100 (reasonable max)
• Show error message if validation fails

Files to change:
• src/main/java/org/springframework/samples/petclinic/model/Pet.java
• src/test/java/org/springframework/samples/petclinic/model/PetTests.java

Hint: Use @Min and @Max annotations from javax.validation

Phase 2: Setup & Understanding (Tag 2-3)

Schritt 1: Repository forken
→ Gehe zu GitHub Repository
→ Klicke "Fork" (oben rechts)
→ Jetzt hast du deine eigene Kopie!

Schritt 2: Fork klonen
git clone https://github.com/DEIN-USERNAME/spring-petclinic.git
cd spring-petclinic

Schritt 3: Remote hinzufügen (für Updates)
git remote add upstream https://github.com/spring-projects/spring-petclinic.git
git remote -v  # Check: origin (dein Fork), upstream (original)

Schritt 4: Projekt builden
mvn clean install
# Dauert beim ersten Mal länger (Dependencies download)

Schritt 5: Projekt verstehen
→ Browse den Code
→ Finde die Dateien aus dem Issue
→ Run die App lokal:
  mvn spring-boot:run
→ Teste die aktuelle Funktionalität

Phase 3: Änderung implementieren (Tag 4-6)

Schritt 1: Branch erstellen
git checkout -b fix/pet-age-validation

Schritt 2: Code ändern
→ Öffne Pet.java in deiner IDE
→ Füge Validation-Annotations hinzu:

// Pet.java
public class Pet {
    // ... existing code
    
    @Min(value = 0, message = "Age must be positive")
    @Max(value = 100, message = "Age seems unrealistic")
    private Integer age;
    
    // ... existing code
}

Schritt 3: Tests schreiben
→ Öffne PetTests.java
→ Füge Tests hinzu:

// PetTests.java
@Test
void testPetAgeValidation() {
    Pet pet = new Pet();
    pet.setAge(-5);
    
    // Test that validation fails
    Set<ConstraintViolation<Pet>> violations = validator.validate(pet);
    assertFalse(violations.isEmpty());
}

Schritt 4: Lokal testen
mvn test  # Laufen alle Tests?
mvn spring-boot:run  # App startet?
# Teste manuell im Browser

Schritt 5: Code-Style checken
→ Folge Projekt-Style!
→ Meist: mvn checkstyle:check

Phase 4: Pull Request erstellen (Tag 7)

Schritt 1: Änderungen committen
git status  # Was wurde geändert?
git add src/main/java/org/springframework/samples/petclinic/model/Pet.java
git add src/test/java/org/springframework/samples/petclinic/model/PetTests.java

git commit -m "Add validation for pet age

- Add @Min and @Max annotations to Pet.age
- Add tests for age validation
- Fixes #456"

Schritt 2: Branch pushen
git push origin fix/pet-age-validation

Schritt 3: Pull Request auf GitHub erstellen
→ Gehe zu DEINEM Fork auf GitHub
→ Klicke "Compare & pull request" (erscheint automatisch!)
→ Titel: "Add validation for pet age"
→ Description schreiben (siehe unten!)
→ Klicke "Create pull request"

Pull Request Description Template:

## What does this PR do?
Adds validation for pet age field to prevent invalid values.

Fixes #456

## Changes made:
- Added `@Min(0)` and `@Max(100)` annotations to `Pet.age`
- Added validation tests in `PetTests`
- Updated error messages to be user-friendly

## How to test:
1. Run the application: `mvn spring-boot:run`
2. Try to create a pet with negative age
3. Observe validation error message
4. Try to create a pet with age > 100
5. Observe validation error message
6. Run tests: `mvn test`

## Checklist:
- [x] Tests added/updated
- [x] All tests passing
- [x] Code follows project style
- [x] Documentation updated (if needed)

## Screenshots (if applicable):
[Screenshot of validation error in UI]

Phase 5: Code-Review & Feedback (Tag 8-14)

Was jetzt passiert:

Tag 8: PR submitted
→ Maintainer bekommen Notification
→ CI/CD läuft automatisch (Tests, Style-Check)

Tag 9-10: Warten...
→ Sei geduldig!
→ Maintainer sind busy
→ 1-7 Tage ist normal

Tag 11: Feedback kommt!

Beispiel-Feedback:

Maintainer comment:
"Thanks for the contribution! Code looks good, but:
1. Can you add a message to the @Min annotation?
2. The test should also check the error message
3. Minor: Line 42 has trailing whitespace

Otherwise LGTM! 👍"

Deine Response:

Your comment:
"Thanks for the review! I'll fix these issues:
1. ✅ Added message to @Min
2. ✅ Test now checks error message
3. ✅ Removed trailing whitespace

Updated commits: a1b2c3d"

Code anpassen:

# Ändere die Dateien
git add .
git commit -m "Address review feedback

- Add message to @Min annotation
- Test error message content
- Remove trailing whitespace"

git push origin fix/pet-age-validation
# PR updated automatisch!

Phase 6: MERGED! 🎉 (Tag 14-15)

Maintainer comment:
"Perfect! Merging now. Thanks for your contribution! 🚀"

[Pull request merged successfully]

Was jetzt:

Schritt 1: Freuen! 🎉
→ Deine erste Contribution!
→ Screenshot für Portfolio!

Schritt 2: Cleanup
git checkout main
git pull upstream main  # Update dein main
git push origin main    # Update dein Fork

git branch -d fix/pet-age-validation  # Lokalen Branch löschen
git push origin --delete fix/pet-age-validation  # Remote Branch löschen

Schritt 3: Zeigen!
→ Link in CV: github.com/spring-projects/spring-petclinic/pull/456
→ LinkedIn-Post (optional)
→ Nächstes Issue suchen!

💡 Kofi’s wichtigste Lessons Learned

Was ich gelernt habe (und wünschte ich hätte es früher gewusst):

1. Start KLEIN

❌ Falsch: "Ich fixe ein komplexes Architektur-Problem!"
✅ Richtig: "Ich fixe einen Typo in der README"

Warum?
→ Du lernst den Workflow
→ Kein Druck
→ Schneller Merge = Motivation!

2. Lies ALLES bevor du anfängst

Must-Read:
1. README.md (was macht das Projekt?)
2. CONTRIBUTING.md (wie beitragen?)
3. CODE_OF_CONDUCT.md (Regeln!)
4. Issue Template (wenn vorhanden)

Warum wichtig?
→ Jedes Projekt hat eigene Regeln
→ Commit-Message-Format beachten!
→ Branch-Naming Conventions!

3. Kommunikation ist KEY

✅ Frage VOR dem Start ob Issue noch available
✅ Frage WÄHREND wenn du stuck bist
✅ Erkläre WARUM du etwas so gemacht hast

❌ Arbeite NICHT still vor dich hin
❌ Reiche NICHT PR ohne Kontext ein

Beispiel guter Comment:
"I'm implementing the validation using @Min/@Max because
these are standard javax.validation annotations and
already used in other parts of the codebase."

4. Tests sind NICHT optional

Jede Code-Änderung braucht Tests!

Minimum:
• Happy Path (funktioniert es?)
• Error Cases (was bei falsch Input?)
• Edge Cases (Grenzen?)

Ohne Tests = PR wird nicht merged

5. Code-Style ist wichtig

✅ Nutze Projekt-eigenen Style
✅ Laufe Linter/Checkstyle
✅ Keine trailing whitespaces
✅ Konsistente Formatierung

Tipp: Viele Projekte haben .editorconfig
→ IDE installiert Formatting automatisch!

6. Feedback annehmen lernen

Code-Review kann hart sein, aber:
→ Ist NICHT persönlich!
→ Macht deinen Code besser!
→ Du lernst IMMENS!

Meine erste Review hatte 15 Comments.
Ich dachte mein Code ist Müll.
Maintainer: "This is normal, you're learning!"

Nach 10 PRs: Reviews hatten nur noch 2-3 Comments.

7. Consistency > Intensity

❌ 20h in Woche 1, dann nichts für 2 Monate
✅ 5h jede Woche für 6 Monate

Warum?
→ GitHub-Contribution-Graph soll grün sein!
→ Zeigt Hiring Managern: "Dieser Dev ist consistent"
→ Baut Routine auf

🎓 Fortgeschrittene Tipps (für Monat 3+)

Wenn du 5-10 PRs gemacht hast:

1. Werde Reviewer

In manchen Projekten kannst du andere PRs reviewen!

Warum cool?
→ Du lernst von anderen
→ Du siehst verschiedene Lösungsansätze
→ Maintainer merken: "Der ist aktiv!"
→ Kann zu Committer-Status führen!

2. Fixe Issues die du selbst findest

Statt nur labeled Issues:
→ Browse Code
→ Finde Bugs/Improvements
→ Erstelle Issue
→ Biete Lösung an

Zeigt Initiative!

3. Dokumentation verbessern

Oft vergessen, aber wertvoll:
→ README verbessern
→ JavaDoc hinzufügen
→ Tutorials schreiben
→ Code-Beispiele aktualisieren

Warum gut?
→ Weniger Competition (andere wollen Code schreiben)
→ Genauso wichtig!
→ Zeigt Communication-Skills

4. Bau eigene Tools für Open Source

Beispiele:
→ GitHub-Action für CI/CD
→ Maven-Plugin
→ CLI-Tool

Warum?
→ Andere nutzen dein Tool!
→ Zeigt Creativity
→ Kann zu Job-Offers führen!

📊 Meine Statistiken nach 10 Monaten Open Source

Kofi’s Real Numbers:

Monat 1-2: Getting Started
• PRs submitted: 8
• PRs merged: 6 (75% rate)
• Projects: 3 (JUnit Pioneer, Spring Petclinic, AssertJ)
• Type: Mostly documentation & small bugfixes

Monat 3-5: Gaining Confidence
• PRs submitted: 22
• PRs merged: 16 (73% rate)
• Projects: 5 (added Spring Boot, Testcontainers)
• Type: Bug fixes & small features

Monat 6-10: Deep Contributions
• PRs submitted: 35
• PRs merged: 27 (77% rate!)
• Projects: 6 (added Micrometer)
• Type: Features & Performance improvements

Total nach 10 Monaten:
• 65 PRs submitted
• 49 PRs merged
• 75% merge rate
• 6 active projects
• 200+ contributions on GitHub

GitHub-Profil Impact:

Contribution Graph: SEHR grün!
Profile Views: 500+/month
Stars on own projects: 200+ total
Followers: 50+

Wichtigster Effekt:
→ Im Interview: "Show us your GitHub"
→ Hiring Manager: "Impressive contribution history!"
→ Job Offer ohne Coding-Test!

🎯 Dein 6-Monats-Plan für Open Source

Hier ist genau was du machen sollst:

Monat 1: Foundation

Woche 1:
□ Git Setup & GitHub-Account
□ Finde 3 Projekte (Checkliste nutzen!)
□ Lies alle CONTRIBUTING.md

Woche 2:
□ Clone Projekte lokal
□ Build sie (mvn clean install)
□ Browse Issues, verstehe Struktur

Woche 3:
□ Claim dein erstes "good first issue"
□ Implementiere die Änderung
□ Schreibe Tests

Woche 4:
□ Erstelle ersten Pull Request
□ Reagiere auf Feedback
□ MERGE! 🎉

Ziel: 1 merged PR

Monat 2-3: Momentum

Pro Woche:
□ 1 neuer PR (jede Woche!)
□ In 2-3 Projekten aktiv
□ Antworte auf Code-Reviews schnell

Ziel: 8-10 merged PRs total

Monat 4-6: Deep Contributions

Pro Woche:
□ 1-2 PRs (größere Features ok!)
□ Eigene Bugs finden & fixen
□ Anderen bei Issues helfen

Ziel: 20-30 merged PRs total

Nach 6 Monaten hast du:

  • ✅ 20-30 merged Pull Requests
  • ✅ Contributions in 3-5 bekannten Projekten
  • ✅ Grüner GitHub Contribution Graph
  • ✅ Code-Review Experience
  • ✅ Professional Git Workflow Skills
  • ✅ Portfolio das für sich spricht!

💼 Wie Open Source mir den Job brachte

Die Timeline:

Monat 10: Bewerbung geschrieben
→ CV: "Contributor to Spring Boot & Micrometer"
→ GitHub-Link prominent platziert

Woche 1: Erste Antwort!
Email: "We saw your Spring Boot contributions.
Can we schedule an interview?"

Woche 2: Interview
Hiring Manager: "Show us your best contribution"
Ich: Zeigte Performance-Improvement in Spring Boot Actuator
Er: "This is professional-level work. Explain your thought process."
Ich: Erklärte Profiling, Benchmarking, Iterationen

Woche 3: Job Offer!
→ Junior Developer, 33k€, Essen
→ Kein Coding-Test nötig!
→ Kein perfektes Deutsch nötig!
→ Mein Code sprach für mich!

Hiring Manager sagte:
"Your GitHub shows us:
• You can write clean code
• You can work in a team
• You understand code-reviews
• You're self-motivated
That's all we need to know."

🌟 Kofi’s Final Words

Was Open Source mir gab:

✅ Job – trotz abgebrochenem Studium ✅ Skills – mehr als jeder Kurs ✅ Netzwerk – Kontakte weltweit ✅ Selbstvertrauen – „Ich kann das!“ ✅ Karriere – heute Mid-Level bei Java Fleet

Für dich:

  • Du hast Spring Boot gelernt? Perfekt!
  • Du kannst Git? Perfekt!
  • Du sprichst Deutsch? Egal, Code ist universal!

Start heute:

  1. Gehe zu https://goodfirstissue.dev
  2. Wähle ein Java-Projekt
  3. Claim ein Issue
  4. Code!

In 6 Monaten:

  • 20-30 merged PRs
  • Portfolio das spricht
  • Job-Interviews die fragen: „When can you start?“

Ich habe es geschafft – und ich hatte mehr Nachteile als du!

Code spricht jede Sprache. Sprich durch deine Contributions! 💪

Jetzt kennst du BEIDE Wege: Bountie Hunting (Jamal) & Open Source (Kofi). Zeit zu entscheiden – oder BEIDE machen! 🚀

Mein Background (Ghana → Deutschland):

  • 2018: Nach Deutschland, Informatik-Studium
  • 2020: Studium abgebrochen (Sprache + Corona)
  • Problem: Keine deutschen Zertifikate, bescheidenes Deutsch
  • Vorteil: Code spricht jede Sprache

Warum Open Source für mich funktionierte:

Im Gegensatz zu Bewerbungen:

  • ❌ Keine deutschen Bewerbungsschreiben nötig
  • ❌ Keine perfekte Aussprache im Interview
  • ❌ Kein „kultureller Fit“
  • ✅ Code spricht für sich

Meine Timeline:

Monat 1-2: Die Suche (März – April 2020)

Wie ich anfing:

# GitHub-Suche die mein Leben änderte:
label:"good first issue" language:java is:open

# Filter nach:
- Aktive Repositories (letzte Updates < 1 Monat)
- Freundliche Maintainer (README checken!)
- Klare Contribution Guidelines

Erste Projekte:

  • JUnit Pioneer (https://github.com/junit-pioneer/junit-pioneer)
    • Testing Library, gut dokumentiert
    • Maintainer sind super hilfsbereit!
  • Spring Petclinic (https://github.com/spring-projects/spring-petclinic)
    • Klassisches Learning-Projekt
    • Viele „good first issue“ Labels

Erste Pull Requests:

  • Typo in Documentation gefixt
  • Broken Link repariert
  • Gefühl: Zu simpel? Aber merged!
  • Learning: Jeder Beitrag zählt

Monat 3-5: Codebase verstehen (Mai – Juli 2020)

Strategie: Vom Lesen zum Schreiben

Phase 1: Code lesen (Woche 1-2)

# So habe ich große Projekte verstanden:
git clone <projekt>
git log --oneline --graph  # Historie verstehen
git blame <datei>           # Wer hat was geschrieben?

# Dann: README + Contributing Guidelines
# Dann: Issues durchlesen (was sind häufige Probleme?)

Phase 2: Tests verstehen (Woche 3-4)

  • Tests sind die beste Dokumentation!
  • Zeigen wie Code benutzt werden soll
  • Mein Approach: Test lesen → Code verstehen → eigenen Test schreiben

Phase 3: Kleine Fixes (Woche 5-8)

  • Start mit Bugs (nicht Features!)
  • Suche: label:bug label:"good first issue"
  • Warum? Bug hat klare Definition von „fertig“

Mein erster echter Bugfix:

  • Projekt: Micrometer (Metrics Library)
  • Bug: NPE bei null-Values
  • Fix: 5 Zeilen Code, 20 Zeilen Tests
  • Dauer: 3 Tage (Code = 1h, Verstehen = Rest!)
  • Merged! 🎉

Monat 6-9: Größere Contributions (Aug – Nov 2020)

Das änderte alles:

Projekt: Spring Boot Actuator

  • Issue: Performance-Problem beim Health-Endpoint
  • Meine Analyse: Zu viele DB-Calls
  • Lösung: Caching implementiert
  • Result: 40% schneller
  • Pull Request: 200+ Zeilen, 2 Wochen Arbeit
  • Review-Runden: 3 (learned SO much!)
  • Merged! + „Thanks for this improvement!“ Kommentar

Was ich dabei lernte:

  • ✅ Code-Review-Prozesse (wie Profis arbeiten)
  • ✅ Performance-Testing (JMH Benchmarks)
  • ✅ Dokumentation (JavaDoc schreiben)
  • ✅ Communication (Issues & PR descriptions)
  • ✅ Git-Workflow (Rebase, Squash, etc.)

Mein GitHub-Profil nach 9 Monaten:

  • Repositories: 8 eigene kleine Projekte
  • Contributions: 50+ Pull Requests
  • Merged PRs: 30 (60% Merge-Rate)
  • Projects: Spring Boot, Micrometer, JUnit Pioneer
  • Stars: Meine eigenen Projekte: ~200 zusammen

Monat 10: Die Bewerbung (Dezember 2020)

Neue Strategie:

Klassische Bewerbung:

Sehr geehrte Damen und Herren,

hiermit bewerbe ich mich... [grammar mistakes]

❌ 10 Bewerbungen → 0 Antworten

GitHub-First Bewerbung:

Hi,

I'm Kofi, and I contribute to Spring Boot.
Here's my GitHub: [link]
Recent highlights:
- Performance improvement in Actuator (merged)
- Bug fixes in Micrometer (merged)
- 50+ contributions in the Spring ecosystem

I'd love to discuss how I can help your team.

Best regards,
Kofi

✅ 3 Bewerbungen → 2 Interviews → 1 Job!

Das Interview:

  • Hiring Manager: „I saw your Spring Boot contribution. Explain it.“
  • Ich: Zeigte den Code, erklärte Performance-Problem
  • Er: „Your code speaks better German than necessary.“
  • Job Offer: Junior Developer, 33k€, Essen

Was den Unterschied machte:

  • Nicht „Ich kann Java“ → Sondern „Hier ist mein Code“
  • Nicht „Ich lerne schnell“ → Sondern „Ich lerne öffentlich“
  • Nicht perfektes Deutsch → Sondern perfekter Code

Was Open Source mir gab:

Technische Skills:

  • ✅ Real-World Code lesen & verstehen
  • ✅ Professional Workflows (Git, Reviews, CI/CD)
  • ✅ Testing Best Practices (die wirklich wichtig sind)
  • ✅ Documentation (JavaDoc, README, Contribution Guides)

Soft Skills:

  • ✅ Communication (in Issues & PRs)
  • ✅ Feedback annehmen (Code-Reviews überleben!)
  • ✅ Team-Arbeit (asynchron, international)
  • ✅ Problem-Solving (echte Bugs, nicht Tutorial-Probleme)

Karriere:

  • ✅ Portfolio das für sich spricht
  • ✅ Netzwerk in der Community
  • ✅ Reputation bei Maintainern
  • ✅ Job ohne perfekte Bewerbung

Heute (2025):

  • Mid-Level Developer bei Java Fleet
  • 42k€/Jahr, Full Remote möglich
  • Immer noch aktiv in Open Source
  • Manche Maintainer sind jetzt Freunde

Meine Tipps für deinen Start:

Woche 1: Projekte finden

Tools die ich nutzte:

  • Good First Issue (https://goodfirstissue.dev)
    • Kuratierte Liste für Anfänger
  • CodeTriage (https://www.codetriage.com)
    • Schickt dir Issues per Email
  • First Timers Only (https://www.firsttimersonly.com)
    • Speziell für erste Contributions

Wie du das richtige Projekt findest:

# Auf GitHub:
1. Suche: label:"good first issue" language:java
2. Filtere: "Updated recently" (letzte 30 Tage)
3. Check README: Ist es freundlich geschrieben?
4. Check Issues: Antworten Maintainer schnell?
5. Check Contributors: Gibt es "first-time contributors"?

Gute Starter-Projekte (2025):

  • Spring Projekts: Immer welcoming für Contributor
  • JUnit Pioneer: Super Dokumentation
  • AssertJ: Testing-Library, anfängerfreundlich
  • Testcontainers: Wenn du Docker kannst

Woche 2-4: Erste Contribution

Mein bewährter Prozess:

# Tag 1: Projekt wählen & Setup
git clone <projekt>
cd <projekt>
# Installiere alle Dependencies
mvn clean install  # oder gradle build

# Tag 2-3: Verstehen
# Lies: README, CONTRIBUTING.md, CODE_OF_CONDUCT.md
# Browse: Open Issues mit "good first issue" label
# Run: Alle Tests (mvn test)

# Tag 4-5: Claim an Issue
# Kommentiere: "I'd like to work on this. Is it still available?"
# Warte auf: Maintainer Response (meist < 24h)

# Tag 6-10: Work & Submit
# Erstelle: Branch (git checkout -b fix/issue-123)
# Code: Deine Änderungen
# Test: Neue Tests für deinen Fix
# Commit: Mit guter Commit-Message
# Push & PR: Mit ausführlicher Description

Meine erste PR-Description (als Template):

## What does this PR do?
Fixes #123 (NPE when value is null)

## How to test?
1. Run new test: `NullValueTest`
2. Manual test: [steps]

## Checklist:
- [x] Added tests
- [x] Updated documentation
- [x] Follows code style

Woche 5-12: Routine entwickeln

Meine wöchentliche Routine:

  • Montag: Check Notifications, respond to PR-Reviews
  • Mittwoch: 2h neue Contribution (1 Issue pro Woche)
  • Freitag: Browse neue Issues, claim nächstes
  • Sonntag: Eigenes Projekt verbessern

Kombination mit Spring Boot Learning:

Das ist der Secret Sauce:

Woche in meinem Leben (2020):
- Montag-Mittwoch: Spring Boot Tutorial (dein Kurs!)
- Donnerstag: Suche Spring Boot related Issues
- Freitag-Samstag: Contribution an Spring-Projekt
- Sonntag: Blog-Post über was ich gelernt habe

Beispiel-Flow:

  1. Lerne: Spring Data JPA (dein Tag 3)
  2. Finde: Bug in Spring Data Commons
  3. Fixe: Den Bug mit deinem neuen Wissen
  4. Portfolio: „Contributed to Spring Data“
  5. Deep Learning: Verstehe es jetzt 10x besser!

Realistische Erwartungen:

Monat 1:

  • 2-3 kleine PRs (Documentation, Typos)
  • Merge-Rate: ~80% (einfache Fixes)
  • Zeit-Investment: 5-10h/Woche

Monat 2-3:

  • 3-5 Code-Contributions
  • Merge-Rate: ~60% (Review-Runden!)
  • Zeit-Investment: 8-15h/Woche

Monat 4-6:

  • 1-2 größere Features/Bugfixes
  • Merge-Rate: ~50% (höhere Komplexität)
  • Zeit-Investment: 10-20h/Woche
  • Bonus: Erste „Contributor“ Badge!

Nach 6 Monaten:

  • Solides Portfolio
  • 20-30 merged PRs
  • Netzwerk in Community
  • Bereit für Bewerbung!

Was Open Source NICHT ist:

❌ Schneller Weg zum Job:

  • Braucht Geduld (6+ Monate)
  • Nicht jede PR wird gemerged
  • Viel Learning-Investment

❌ Bezahlte Arbeit:

  • Open Source = meist unbezahlt
  • Aber: Investment in Portfolio
  • Später: Vielleicht Sponsoring

❌ Einfach:

  • Real Code = real komplex
  • Reviews können hart sein
  • Braucht Durchhaltevermögen

✅ Aber es IST:

  • Bestes Learning-Tool
  • Portfolio-Builder
  • Community-Zugang
  • Beweis für Hiring-Manager

Mein Fazit:

Open Source hat mir gezeigt:

  • Code ist universelle Sprache
  • Qualität > perfekte Bewerbung
  • Community > Einzel-Learning
  • Public Work > private Projects

Für dich als Junior:

  • Start klein (Documentation!)
  • Bleib dran (Consistency > Intensity)
  • Lerne öffentlich (Blog darüber!)
  • Build Portfolio (GitHub = dein CV)

Ja, es braucht Zeit. Ja, nicht jede PR wird gemerged. Aber: Es hat bei mir funktioniert – und ich hatte mehr Nachteile als du!

Du hast Spring Boot gelernt? Perfekt. Jetzt zeig es der Welt – durch Code, nicht Worte. 💪

Wenn ich das kann – kannst du das erst recht! 🌍“

💼 Franz-Martin: „Die Gehalts-Realität 2025 – ohne Beschönigung“

Der Kapitän zeigt die nackten Zahlen:

„Team, danke für eure Geschichten. Jetzt die Management-Perspektive – und ich werde brutal ehrlich sein.

💰 Die Gehaltsfrage: Was verdienst du WIRKLICH?

Wichtig vorweg: Diese Zahlen basieren auf echten Einstellungen 2024/2025 bei Java Fleet und unseren Partner-Firmen. Keine Traumgehälter, keine Ausnahmen – das ist die Realität.

📊 JUNIOR DEVELOPER (0-2 Jahre Erfahrung)

Definition:

  • Erste Position nach Ausbildung/Studium/Quereinstieg
  • Braucht Mentoring und Code-Reviews
  • Kann einfache Features selbstständig umsetzen
  • Lernt noch grundlegende Patterns

Großstädte (München, Frankfurt, Stuttgart, Hamburg):

Brutto/Jahr:
• Ohne Portfolio: 36.000 - 40.000€
• Mit Portfolio: 38.000 - 44.000€
• Mit Bountie/Open Source: 40.000 - 46.000€

Netto/Monat (Steuerklasse 1, keine Kinder):
• Ca. 2.000 - 2.400€

Realität München:

  • Miete 1-Zimmer: 900-1.200€
  • Nach Miete bleiben: 1.100-1.500€
  • Geht sich aus, aber eng

Mittelgroße Städte (Köln, Düsseldorf, Essen, Hannover, Nürnberg):

Brutto/Jahr:
• Ohne Portfolio: 32.000 - 36.000€
• Mit Portfolio: 34.000 - 39.000€
• Mit Bountie/Open Source: 36.000 - 42.000€

Netto/Monat:
• Ca. 1.800 - 2.200€

Realität Essen (wo wir sind!):

  • Miete 1-Zimmer: 550-750€
  • Nach Miete bleiben: 1.250-1.650€
  • Deutlich komfortabler als München

Kleinere Städte (Paderborn, Göttingen, Osnabrück, Jena):

Brutto/Jahr:
• Ohne Portfolio: 28.000 - 32.000€
• Mit Portfolio: 30.000 - 36.000€
• Mit Bountie/Open Source: 32.000 - 38.000€

Netto/Monat:
• Ca. 1.600 - 2.000€

Realität Paderborn:

  • Miete 1-Zimmer: 400-550€
  • Nach Miete bleiben: 1.200-1.600€
  • Ähnliche Lebensqualität wie Großstadt

Ländliche Regionen / Ostdeutschland:

Brutto/Jahr:
• Ohne Portfolio: 26.000 - 30.000€
• Mit Portfolio: 28.000 - 33.000€
• Mit Bountie/Open Source: 30.000 - 36.000€

Netto/Monat:
• Ca. 1.500 - 1.900€

ABER: Remote-Option ändert alles!

  • Wohnst in Brandenburg, arbeitest für Berliner Firma
  • Bekommst: 36.000€ (Berlin-Gehalt)
  • Zahlst Miete: 350€ (Brandenburg)
  • Best of both worlds!

📊 MID-LEVEL DEVELOPER (2-5 Jahre Erfahrung)

Definition:

  • Kann selbstständig komplexe Features umsetzen
  • Macht Code-Reviews für Juniors
  • Versteht Architektur-Entscheidungen
  • Hat Production-Katastrophen überlebt

Großstädte:

Brutto/Jahr: 48.000 - 62.000€
Netto/Monat: 2.500 - 3.200€

Typischer Sprung vom Junior:
• Nach 2 Jahren: +8.000 - 12.000€
• Nach 3 Jahren: +12.000 - 18.000€

Mittelgroße Städte:

Brutto/Jahr: 42.000 - 56.000€
Netto/Monat: 2.300 - 3.000€

Kleinere Städte:

Brutto/Jahr: 38.000 - 50.000€
Netto/Monat: 2.100 - 2.700€

Ländliche Regionen:

Brutto/Jahr: 36.000 - 46.000€
Netto/Monat: 2.000 - 2.500€

Der Mid-Level-Sprung:

  • NICHT automatisch nach 2 Jahren!
  • Braucht: Production-Experience, Incidents gelöst, kann Juniors mentoren
  • Viele bleiben 3-4 Jahre Junior (vor allem ohne formale Ausbildung)

📊 SENIOR DEVELOPER (5+ Jahre Erfahrung)

Definition:

  • Kann Architektur-Entscheidungen treffen und verteidigen
  • Mentort Teams
  • Führt technische Diskussionen
  • Hat mehrere Production-Systeme gebaut/gewartet

Großstädte:

Brutto/Jahr: 65.000 - 85.000€
Netto/Monat: 3.400 - 4.400€

Spitze (Staff/Principal):
Brutto/Jahr: 85.000 - 110.000€

Mittelgroße Städte:

Brutto/Jahr: 58.000 - 75.000€
Netto/Monat: 3.100 - 3.900€

Kleinere Städte:

Brutto/Jahr: 52.000 - 68.000€
Netto/Monat: 2.800 - 3.600€

Ländliche Regionen:

Brutto/Jahr: 48.000 - 62.000€
Netto/Monat: 2.600 - 3.300€

Der Senior-Titel:

  • NICHT nach 5 Jahren automatisch!
  • Manche erreichen es nach 7-8 Jahren
  • Braucht: Bewiesene Führung, Architektur-Skills, Team-Impact

📈 Wie hat sich der Markt in 5 Jahren verändert?

2020 vs. 2025 – Die brutale Wahrheit:

2020: Der Golden Age

Junior-Markt:
✅ Jede Bewerbung = 3-4 Interviews
✅ Startups warfen mit Geld um sich
✅ "Bootcamp-Absolventen? Nehmen wir!"
✅ Remote = Bonus, nicht Standard
✅ Gehalt-Sprünge: 15-20% beim Jobwechsel

Typisch:
• 15 Bewerbungen → 8 Interviews → 3 Angebote
• Junior ohne Portfolio: 35k€ in München
• Nach 1 Jahr Wechsel: 42k€ (+20%!)

2025: Die Normalisierung

Junior-Markt:
⚠️ Jede Bewerbung = 1-2 Interviews (wenn überhaupt)
⚠️ Startups sind vorsichtiger geworden
⚠️ "Portfolio zeigen oder nach Hause gehen"
✅ Remote = erwartet, kein Bonus mehr
⚠️ Gehalt-Sprünge: 8-12% beim Jobwechsel

Typisch:
• 50 Bewerbungen → 5 Interviews → 1 Angebot
• Junior ohne Portfolio: Oft Absage
• Nach 1 Jahr Wechsel: 38k€ (+6-8%)

Was ist passiert?

  1. COVID-Boom vorbei (2021-2022)
    • Jeder dachte „Tech = sichere Zukunft“
    • MASSIV mehr Quereinsteiger
    • Bootcamps sprossen wie Pilze
    • Result: Angebot > Nachfrage für Juniors
  2. KI-Hype (2023-2024)
    • „ChatGPT ersetzt Entwickler!“ (Spoiler: Nein.)
    • Firmen stellten weniger ein (aus Unsicherheit)
    • Mehr Seniors, weniger Juniors gesucht
    • Result: Junior-Stellen seltener
  3. Wirtschaftliche Realität (2024-2025)
    • Zinsen hoch = weniger Startup-Funding
    • Konsolidierung in Tech
    • Fokus auf profitable Teams
    • Result: Nur noch Juniors mit Beweis-Portfolio

Konkrete Zahlen aus unserem Hiring (Java Fleet):

2020:
• Junior-Stelle ausgeschrieben: 80 Bewerbungen
• Davon qualifiziert: 30 (37%)
• Interviews: 12
• Eingestellt: 2

2025:
• Junior-Stelle ausgeschrieben: 240 Bewerbungen
• Davon qualifiziert: 18 (7.5%!)
• Interviews: 8
• Eingestellt: 1

Was hat sich geändert?
→ 3x mehr Bewerbungen
→ 5x weniger qualifiziert (relativ!)
→ Härtere Competition

🎯 Was heißt das für DICH?

Die gute Nachricht: ✅ Der Markt braucht IMMER NOCH Entwickler ✅ Mid-Level & Senior = super Chancen ✅ ABER: Junior-Einstieg = schwieriger geworden

Die schlechte Nachricht: ⚠️ „Ich habe einen Kurs gemacht“ = nicht genug (2025) ⚠️ Competition ist härter als vor 5 Jahren ⚠️ Ohne Portfolio = sehr geringe Chancen

Die Lösung: 🎯 Portfolio > Zertifikate (war immer so, jetzt kritisch) 🎯 Bountie Hunting = zeigt echte Skills (wie Jamal) 🎯 Open Source = zeigt Team-Fähigkeit (wie Kofi) 🎯 Beide kombinieren = maximale Chancen

💡 Wann wirst du als Junior eingestellt?

2020: „Du kannst Java? Komm vorbei!“

2025: „Du musst beweisen dass du:

  1. ✅ Code schreiben kannst (Live-Coding-Interview!)
  2. ✅ Im Team arbeiten kannst (Open Source beweist das)
  3. ✅ Security verstehst (Bountie Hunting beweist das)
  4. ✅ Selbstständig lernen kannst (Portfolio beweist das)
  5. ✅ Production-Ready denkst (Tests, Docs, Best Practices)

Was wir 2025 bei Bewerbungen sehen wollen:

Portfolio-Checklist (MUST-HAVE):

✅ GitHub-Profil mit grünem Contribution-Graph
✅ 3-5 eigene Projekte mit README
✅ Tests in jedem Projekt
✅ ODER: 20+ merged PRs in Open Source
✅ ODER: 5-10 valid reports bei HackerOne/Bugcrowd
✅ Blog (optional, aber hilft MASSIV)

CV-Checklist:

✅ GitHub-Link in der ERSTEN Zeile
✅ HackerOne/Bugcrowd-Profil (falls vorhanden)
✅ Konkrete Projekte mit Tech-Stack
✅ "Contributions to Spring Boot" (wenn möglich)
❌ KEINE 3 Seiten Skill-Liste ohne Beweise
❌ KEINE "Expert in everything" Claims

Interview Was wir testen (2025):

1. Live-Coding (30 min):
   - Schreib einen REST-Endpoint
   - Fix einen Bug in gegebenem Code
   - Schreib einen Test

2. Portfolio-Review (15 min):
   - Erkläre dein bestes Projekt
   - Warum diese Architektur-Entscheidung?
   - Was würdest du anders machen?

3. Problem-Solving (20 min):
   - Wie würdest du Feature X implementieren?
   - Security-Concern bei diesem Code?
   - Wie testest du das?

4. Team-Fit (15 min):
   - Erzähl von einer schwierigen Code-Review
   - Wie gehst du mit Feedback um?
   - Wie lernst du neue Technologien?

2020: Code-Skill Test war genug 2025: Code + Portfolio + Team-Fit + Security = Alle 4 müssen stimmen!

🔥 Ehrliche Einschätzung: Deine Chancen nach diesem Kurs

Nur mit diesem Kurs (20 Tage):

Chancen auf Junior-Job: 15-20%
Durchschnittliche Bewerbungen bis Job: 80-120
Zeit bis Job: 6-12 Monate
Warum so wenig? Keine sichtbaren Beweise.

Mit 3 Monaten Portfolio (Bountie ODER Open Source):

Chancen auf Junior-Job: 40-50%
Durchschnittliche Bewerbungen bis Job: 30-50
Zeit bis Job: 3-5 Monate
Warum besser? Du hast Beweise!

Mit 6 Monaten Portfolio (Bountie UND Open Source):

Chancen auf Junior-Job: 70-80%
Durchschnittliche Bewerbungen bis Job: 15-25
Zeit bis Job: 2-4 Monate
Warum so gut? Du stichst heraus!

Die harte Wahrheit:

  • 2020: Kurs → sofort bewerben → Job in 2 Monaten
  • 2025: Kurs → Portfolio → dann bewerben → Job in 4 Monaten

ABER: Mit Portfolio bist du 2025 besser dran als ohne Portfolio 2020!

💪 Konkrete Empfehlungen für verschiedene Situationen

Situation A: „Ich brauche SOFORT Geld“

Empfehlung:
1. Bewirb dich trotzdem (15-20% Chance!)
2. PARALLEL: Start Bountie/Open Source
3. Freelance-Projekte (Fiverr, Upwork)
4. Werkstudent-Stellen (wenn studierst)

Realität:
• Bis zum ersten Job: 3-6 Monate
• Mit Glück: 1-2 Monate
• Plan B: Teilzeit-Job + Portfolio aufbauen

Situation B: „Ich habe 3-6 Monate Zeit“

Empfehlung:
1. NICHT sofort bewerben
2. Erst Portfolio (Jamal + Kofi's Weg)
3. Nach 3 Monaten: Erste Bewerbungen
4. Nach 6 Monaten: Starkes Portfolio

Realität:
• Das ist der OPTIMALE Weg
• Höchste Erfolgsquote
• Bessere Gehälter

Situation C: „Ich bin noch Student/in Ausbildung“

Empfehlung:
1. Du hast ZEIT - nutze sie!
2. Open Source neben Studium
3. Bountie Hunting am Wochenende
4. Werkstudent-Stelle mit echten Projekten

Realität:
• BESTER Start ins Berufsleben
• Portfolio VOR Abschluss
• Oft Job-Angebot vor Ende Studium

📊 Gehalts-Entwicklung: Beispiel-Karrieren

Jamal’s Karriere (Quereinsteiger mit Bountie):

2021: Start Bountie Hunting (Ausbildung abgebrochen)
2021 (9 Monate später): Junior - 35k€
2023 (2 Jahre): Mid-Level - 46k€
2025 (4 Jahre): Senior Security Engineer - 68k€

Total: 33k€ mehr in 4 Jahren (+94%!)

Kofi’s Karriere (ohne Abschluss, Open Source):

2020: Start Open Source (Studium abgebrochen)
2021 (10 Monate später): Junior - 33k€
2023 (2 Jahre): Mid-Level - 42k€
2025 (4 Jahre): Mid-Level (Java Fleet) - 52k€

Total: 19k€ mehr in 4 Jahren (+57%)
Langsamer, aber steady!

Durchschnitts-Karriere (mit Studium, kein Portfolio):

2021: Junior (nach Bachelor) - 38k€
2023 (2 Jahre): Junior/Mid - 42k€
2025 (4 Jahre): Mid-Level - 50k€

Total: 12k€ mehr in 4 Jahren (+31%)
Sicherer, aber langsamer Aufstieg

Was lernen wir? → Jamal: Schnellster Aufstieg (Bountie = Security-Premium!) → Kofi: Solider Aufstieg (Open Source = Team-Skills!) → Durchschnitt: Langsamer (keine Differenzierung)

🎓 Final Words

Der Markt hat sich verändert – aber Chancen gibt es immer noch!

2020: „Ich habe gelernt“ = genug 2025: „Ich kann es beweisen“ = nötig

2020: 30 Bewerbungen = Job 2025: Portfolio + 30 Bewerbungen = Job

2020: Junior-Gehalt: 35k€ (München, ohne Portfolio) 2025: Junior-Gehalt: 38k€ (München, MIT Portfolio)

Die Wahrheit:

  • Schwieriger geworden? Ja.
  • Unmöglich geworden? Nein.
  • Portfolio wichtiger? Absolut.

Jamal und Kofi haben’s bewiesen:

  • Ohne formale Ausbildung
  • Mit Portfolio-Strategie
  • Jetzt erfolgreiche Entwickler

Du kannst das auch – aber du musst JETZT anfangen!

Nach 20 Tagen Kurs bist du NICHT job-ready. Nach 20 Tagen Kurs + 6 Monaten Portfolio BIST du job-ready.

Die Frage ist nicht OB du einen Job bekommst. Die Frage ist WANN – und das entscheidest DU! 💪“

📊 Zusammenfassung: Deine nächsten Schritte

✅ Was du JETZT hast:

  • Spring Boot Grundlagen (20 Tage: Basic + Aufbau abgeschlossen!)
  • REST API Skills
  • Testing-Grundlagen
  • Security Basics
  • Git & Maven Basics
  • Deployment Basics

🎯 Was du in den nächsten 3-6 Monaten brauchst:

Die 3-Säulen-Strategie:

Säule 1: Foundation (✅ DONE!)

  • Spring Boot Basic + Aufbau ✅
  • REST APIs & Databases ✅
  • Testing & Security ✅ → Dauer: 20 Tage (ABGESCHLOSSEN!)

Säule 2: Portfolio (2-6 Monate)

Option A: Jamal’s Weg (Bountie Hunting)

Monat 1-2:
□ HackerOne + Bugcrowd Account
□ OWASP Top 10 studieren
□ Web Security Academy durcharbeiten
□ Erste VDP Programme testen

Monat 3-4:
□ Erste paid Bounties anstreben
□ Spring Boot Security-Demo bauen
□ Blog über Findings schreiben

Monat 5-6:
□ 5-10 valid reports sammeln
□ Portfolio auf GitHub
□ Bewerbungen mit HackerOne-Link

Option B: Kofi’s Weg (Open Source)

Monat 1-2:
□ GitHub "good first issue" finden
□ 5-10 kleine PRs (Docs, Typos)
□ Ein Projekt gut kennenlernen

Monat 3-4:
□ 10-15 Code-Contributions
□ Erste größere Bugfixes
□ Review-Prozesse lernen

Monat 5-6:
□ 20-30 merged PRs total
□ Eigene Projekte auf GitHub
□ Bewerbungen mit GitHub-Profil

Option C: Beides kombinieren! (Empfohlen)

Parallel:
□ 2-3 Tage/Woche: Open Source
□ 2-3 Tage/Woche: Bountie Hunting
□ Beide Skills verstärken sich!
□ Maximales Portfolio

Result:
→ Security UND Development Skills
→ Attack UND Defense Perspektive
→ Stärkste Position im Bewerbungsprozess!

🔗 Wichtige Links nochmal:

Bountie Hunting:

  • HackerOne: https://www.hackerone.com
  • Bugcrowd: https://www.bugcrowd.com
  • Intigriti: https://www.intigriti.com (Europa)
  • YesWeHack: https://www.yeswehack.com (Europa)
  • PortSwigger Academy: https://portswigger.net/web-security
  • Bug Bounty Forum: https://bugbountyforum.com

Open Source:

  • Good First Issue: https://goodfirstissue.dev
  • Up For Grabs: https://up-for-grabs.net/#/tags/java
  • Code Triage: https://www.codetriage.com
  • First Timers Only: https://www.firsttimersonly.com
  • Spring Projects: https://github.com/spring-projects
  • Awesome Java: https://github.com/akullpp/awesome-java

💬 Schlusswort vom Team

Cassian: „Realismus über Illusionen. Du hast das Fundament – jetzt bau darauf auf.“

Elyndra: „Gib dir Zeit. Ich brauchte 9 Monate bis zum ersten Job. Das ist normal!“

Code Sentinel: „Portfolio schlägt Zertifikate. Jeden. Verdammten. Tag.“

Jamal: „Bountie Hunting hat mein Leben verändert. Versuch es! Seriously!“

Kofi: „Code ist universelle Sprache. Sprich durch deine Contributions!“

Franz-Martin: „Das Team hat’s bewiesen: Es funktioniert. Aber nur wenn DU anfängst. Heute.“

🎓 Deine Fortschritts-Übersicht

🎊 Du hast den Spring Boot Kurs abgeschlossen!

  • ✅ Spring Boot Basic (Tag 1-10): ABGESCHLOSSEN! 🎉
  • ✅ Spring Boot Aufbau (Tag 11-20): ABGESCHLOSSEN! 🎉

Insgesamt: 20 Tage = 160 Stunden intensives Learning! 💪

Was du jetzt kannst:

  • Spring Boot Anwendungen entwickeln
  • REST APIs bauen und absichern
  • Mit Datenbanken arbeiten (JPA)
  • Tests schreiben (JUnit, Mockito)
  • Security implementieren (Spring Security)
  • Apps deployen (Docker Basics)
  • Performance optimieren

Was jetzt kommt: Portfolio-Phase (3-6 Monate)!

❓ FAQ

Q: Muss ich wirklich 6 Monate warten bis ich mich bewerben kann?
A: Nein! Du kannst dich sofort bewerben. Aber mit 3-6 Monaten Portfolio bist du VIEL erfolgreicher. Jamal hatte nach 2 Monaten Bountie Hunting seine erste positive Response.

Q: Ist Bountie Hunting nicht gefährlich/illegal?
A: Wenn du dich an die Regeln hältst (nur Programme die explizit erlauben, Scope beachten), ist es 100% legal und erwünscht! VDP Programme sind extra zum Üben da.

Q: Brauche ich ein Informatik-Studium?
A: Kofi zeigt: Nein! Portfolio > Abschluss. Aber ohne Studium brauchst du ein STÄRKERES Portfolio.

Q: Welches Gehalt kann ich realistisch erwarten?
A: Als Junior in deiner Region: Check Franz-Martin’s Tabelle oben. 28-45k€ je nach Stadt. Mit Portfolio eher obere Hälfte!

Q: Open Source ODER Bountie Hunting?
A: Warum nicht beides? Jamal und Kofi machen beide! Security-Skills + Team-Skills = maximale Chancen!

Q: Ich habe schlechtes Englisch. Geht Open Source trotzdem?
A: Kofi’s Englisch war auch nicht perfekt! Code spricht für sich. Start mit deutschen Projekten oder einfachen Fixes (Typos brauchen kein perfektes Englisch).

Q: Was macht ihr bei persönlichen Problemen zwischen den Projekten?
A: Das ist… kompliziert. Manche Geschichten gehören nicht in Tech-Blogs, sondern in private logs. Aber das ist ein anderes Kapitel. 🔒

Q: Ist Remote-Arbeit als Junior möglich?
A: Jamal hat Remote bekommen (3 Tage/Woche). Franz-Martin: „Wird häufiger, aber nicht Standard. Bewirb dich hybrid, verhandle dann remote!“

Autor

  • Elyndra Valen

    28 Jahre alt, wurde kürzlich zur Senior Entwicklerin befördert nach 4 Jahren intensiver Java-Entwicklung. Elyndra kennt die wichtigsten Frameworks und Patterns, beginnt aber gerade erst, die tieferen Zusammenhänge und Architektur-Entscheidungen zu verstehen. Sie ist die Brücke zwischen Junior- und Senior-Welt im Team.
← Vorheriger Artikel Tag 1: Auto-Configuration & Custom Starter
Nächster Artikel → Docker verstehen – Erklärt von jemandem, der es gerade selbst lernt