czay.dev
0/32
Roadmaps

Junior Backend Developer 2026

In Stellenanzeigen für Junior-Backend-Entwickler stapeln sich Kubernetes, Kafka, AWS-Architektur, Redis Cluster und Microservices auf ein bisschen Go oder C#. Unternehmen versuchen, die gesamte Arbeit eines Infrastruktur-Teams auf einen einzigen Junior abzuladen.

20 Buzzwords oberflächlich auswendig zu lernen bringt dir keinen Job; was dich wirklich weiterbringt, ist EIN laufendes Live-API-Projekt, bei dem du deine Architektur-, Datenbank- und Sicherheitsentscheidungen verteidigen kannst. Geh der Reihe nach vor, sieh dir jedes Thema genau an und hake ab, was du gelernt hast.

  • KernDas solltest du gut können, bevor du dich bewirbst
  • WünschenswertTaucht oft in Stellenanzeigen auf und verschafft dir einen Vorteil
  • SpäterWenn du im Job bist und es brauchst

Klicke auf ein Thema, um zu sehen, was du wissen musst und wo du es lernen kannst.

  1. 01

    Grundlagen & Web-Protokolle

    Die universellen Regeln und Protokolle, die APIs sprechen. Sprachunabhängig – das gemeinsame Alphabet jedes Backend-Entwicklers.

  2. 02

    Datenbanken & SQL

    Das eigentliche schlagende Herz des Backends. UIs und Frameworks kommen und gehen, aber Datenintegrität und relationale Schemas bleiben.

  3. 03

    Authentifizierung & Sicherheit

    Das unterscheidet einen Engineer vom Hobby-Programmierer. Eine API, die Sicherheit vernachlässigt, gehört nie in Produktion.

  4. 04

    Jobreif werden & echtes Projekt

    Was dich vor Tausenden von Bewerbern nach vorn bringt. Nicht nur Code schreiben – ihn auch verpacken, dokumentieren und live deployen.

  5. 05

    Das kannst du später lernen

    Themen, die in Junior-Stellenanzeigen hineinkopiert werden, aber KEINE Voraussetzung für eine Einstellung sind. Du lernst sie im Job, wenn die Produktionsgröße es verlangt.

Thema für Thema

Jedes Thema auf der Karte mit Beschreibung, Wissenswertem und Ressourcen — in einer Liste.

  1. 01Grundlagen & Web-Protokolle

    • HTTP-Protokoll & REST· Kern

      Das Tor des Backends zur Welt. Wer HTTP-Methoden und Statuscodes falsch einsetzt, gerät ständig mit den Frontend-Teams aneinander.

      Das solltest du wissen

      • HTTP-Methoden: Semantik von GET, POST, PUT, PATCH, DELETE und Idempotenz
      • Statuscodes: Unterschiede zwischen 200, 201, 204, 400, 401, 403, 404, 409, 422, 500
      • Header: Content-Type, Authorization, Accept, Cache-Control
      • REST-Prinzipien: Statelessness, ressourcenorientierte URL-Benennung und JSON-Format

      Ressourcen

      • Request-Lebenszyklus· Kern

        Welche Stationen durchläuft eine Anfrage, vom Verlassen des Browsers über Controller, Service-Schicht und DB bis zur Antwort?

        Das solltest du wissen

        • Middleware-Konzept: Request-Validierung, Logging, globale Fehlerbehandlung
        • Unterschiede zwischen Query-Parametern, Route-Parametern und Request Body
      • Postman / Bruno / cURL· Kern

        Das tägliche Werkzeug, um deine Endpoints unabhängig zu testen und zu debuggen, ohne auf das Frontend zu warten.

        Ressourcen

    • Eine Backend-Sprache· Kern

      Hör auf, zwischen Sprachen zu springen. Such dir für deinen Markt eine aus – Go, Node.js (TypeScript) oder C# (.NET) – und geh in die Tiefe.

      Das solltest du wissen

      • Die Sprache über die Syntax hinaus verstehen: Speicherverwaltung, Typsicherheit und die Standardbibliothek
      • Asynchrone Programmierung: Event Loop / Goroutines / Async-Await & Threading
      • Datei-I/O, Streams und das sichere Laden von Umgebungsvariablen (.env)

      Ressourcen

      • Fehlerbehandlung & Logging· Kern

        Eine zentrale Fehlerbehandlung aufbauen, die Abstürze bei unbehandelten Exceptions verhindert, ohne den Code mit blindem try-catch zu verstopfen.

        Das solltest du wissen

        • Interne Stack Traces bei 500er-Fehlern niemals an Endnutzer weitergeben
        • Strukturiertes Logging (JSON-Logs, Log-Level: INFO, WARN, ERROR)
      • Konfiguration & Secrets· Kern

        Datenbank-Zugangsdaten und geheime Schlüssel dürfen niemals hartcodiert sein. Aus der .env lesen und per .gitignore schützen.

  2. 02Datenbanken & SQL

    • PostgreSQL & relationales SQL· Kern

      Tapp nicht zu früh in die NoSQL-/MongoDB-Falle; 90 % der Branche setzen auf relationale Datenbanken. Mit PostgreSQL-Kenntnissen kommst du durch jedes Backend-Interview.

      Das solltest du wissen

      • Grundlegendes CRUD und Filtern: SELECT, INSERT, UPDATE, DELETE, WHERE, GROUP BY, HAVING
      • Tabellenbeziehungen: One-to-Many, Many-to-Many, Primary-Key- und Foreign-Key-Constraints
      • JOIN-Arten: Unterschiede zwischen INNER, LEFT und FULL JOIN und wann du welchen einsetzt
      • ACID-Prinzipien: Atomicity, Consistency, Isolation, Durability und Transaktionen (COMMIT / ROLLBACK)

      Ressourcen

      • Datenbank-Indizes (B-Tree)· Kern

        Warum die Suche in 1 Mio. Zeilen 3 Sekunden dauert und CREATE INDEX sie auf 2 ms drückt. Abwägungen bei Indizes und EXPLAIN-Abfragen.

        Das solltest du wissen

        • Unterschied zwischen Full Table Scan und Index Scan
        • Der Performance-Nachteil bei Schreibvorgängen (INSERT/UPDATE), wenn du jede Spalte indizierst
      • Transaktionen & Konsistenz· Kern

        Was passiert bei einer Überweisung, wenn das Geld von Konto A abgebucht, aber Konto B nicht gutgeschrieben wird? Operationen zu einer atomaren Einheit bündeln.

    • ORM & Migrationen· Kern

      DB-Schemas auf Code abbilden. ORMs sparen Zeit, aber wer das generierte SQL nicht prüft, tappt direkt in die N+1-Falle.

      Das solltest du wissen

      • Wähle ein ORM bzw. einen Query Builder für deinen Stack: Prisma, TypeORM, GORM, EF Core oder Dapper
      • Das N+1-Query-Problem: 101 Roundtrips vermeiden, wenn du 100 Nutzer samt Bestellungen abrufst
      • Datenbankmigrationen: Schemaänderungen zwischen Teams und Umgebungen synchronisieren

      Ressourcen

      • N+1-Problem & Lösungen· Kern

        Die häufigste Performance-Frage in Backend-Interviews. Eager Loading, JOINs und Batching-Mechanismen.

      • Wann du Raw SQL schreibst· Wünschenswert

        Wissen, wann du das ORM beiseitelegst und natives SQL für komplexe Aggregationen und Reports schreibst.

  3. 03Authentifizierung & Sicherheit

    • Authentifizierung (Auth)· Kern

      Wer ist der Nutzer, und hat er die Berechtigung? Die Ära der Klartext-Passwörter ist seit zwanzig Jahren vorbei.

      Das solltest du wissen

      • Passwort-Hashing: Salting mit bcrypt oder Argon2, Schutz vor Rainbow-Table-Angriffen
      • JWT: Aufbau aus Header, Payload, Signature. Verstehen, dass JWTs signiert, aber nicht verschlüsselt sind
      • Lebenszyklus von Access Token & Refresh Token: Sichere Speicherung (HttpOnly Cookies vs. Header)
      • Autorisierung (RBAC): Rollenbasierte Zugriffskontrolle per Middleware (Admin, User, Editor)

      Ressourcen

      • Session vs. JWT· Wünschenswert

        Abwägungen zwischen zustandsbehafteten Sessions (serverseitiger Zustand in Redis/DB) und zustandslosen JWTs.

      • OAuth-2.0-Grundlagen· Wünschenswert

        Wie „Mit Google oder GitHub anmelden“ im Hintergrund funktioniert (Authorization Code Flow).

    • Validierung & API-Schutz· Kern

      Vertraue niemals Nutzereingaben (Zero Trust). Du musst eingehende Request-Payloads konsequent gegen ein Schema validieren.

      Das solltest du wissen

      • Request-DTOs / Validierung: Strikte Payload-Schemas mit Zod, Joi oder FluentValidation durchsetzen
      • SQL Injection: Warum Prepared Statements und parametrisierte Abfragen Pflicht sind
      • CORS: Was passiert eigentlich, wenn ein Frontend deine API von einer anderen Domain aus aufruft?
      • Rate Limiting: Endpoints gegen Brute-Force und DDoS-Bots drosseln

      Ressourcen

      • CORS & Preflight-Anfragen· Kern

        Was eine OPTIONS-Preflight-Anfrage ist, warum Browser sie senden und wie du die Backend-Header richtig konfigurierst.

  4. 04Jobreif werden & echtes Projekt

    • Docker-Grundlagen· Kern

      Schluss mit der Ausrede „Bei mir läuft es aber“. Ein Junior-Backend-Entwickler braucht kein Kubernetes, aber ein Dockerfile zu schreiben ist unverzichtbar.

      Das solltest du wissen

      • Container vs. Images: Was ist ein Docker-Image, und wie läuft ein Container?
      • Ein Dockerfile schreiben: Schlanke Images mit Multi-Stage-Builds erzeugen und Ports freigeben
      • Docker Compose: API-Service und PostgreSQL-DB mit einem einzigen `docker compose up` gemeinsam hochfahren

      Ressourcen

      • Lokale Entwicklung mit Compose· Kern

        Einen isolierten Datenbank-Container über Docker starten, statt dein Host-Betriebssystem zuzumüllen.

    • Dokumentation (Swagger / OpenAPI)· Kern

      Eine undokumentierte API existiert praktisch nicht. Du solltest einem Frontend-Entwickler eine lebendige Swagger-URL oder eine Postman Collection übergeben können.

      Ressourcen

      • API-Verträge· Wünschenswert

        Strikte Request-/Response-Verträge vorab definieren, um mit den Client-Teams dieselbe Sprache zu sprechen.

    • Eine echte Live-API· Kern

      Lass Todo-Apps und Tutorial-Klone hinter dir. EINE Live-API mit Auth, relationalem PostgreSQL, Docker-Paketierung und öffentlichem Deployment bringt dir den Job.

      Das solltest du wissen

      • Echte Geschäftslogik: Buchungs-, E-Commerce-Checkout-, Ticketing- oder Abrechnungs-API
      • Mindestens 4–5 miteinander verknüpfte PostgreSQL-Tabellen (User, Product, Order, OrderItem)
      • Live-Deployment: Ein öffentlich erreichbarer Endpoint auf Render, Railway, Fly.io oder einem Cloud-VPS
      • README: Architekturdiagramm, Tabelle der Umgebungsvariablen, Anleitung fürs lokale Setup und Swagger-Link
      • Integrationstests· Wünschenswert

        Automatisierte End-to-End-Tests gegen eine Testdatenbank für geschäftskritische Endpoints schreiben (Login, Bestellung anlegen).

      • Deine Architektur verteidigen· Kern

        Fragen wie „Warum PostgreSQL?“, „Wie werden Passwörter gespeichert?“ und „Warum hast du für diese Spalte einen Index angelegt?“ souverän beantworten.

  5. 05Das kannst du später lernen

    • Verteilte Architektur & Queues· Später

      Eine App mit 10 Nutzern in 10 Microservices zu zerlegen ist ein Rezept für das Scheitern. Starte monolithisch; lerne Microservices, wenn die Produktion es erfordert.

      • Microservices· Später

        Kommunikation zwischen Services (gRPC, HTTP), Netzwerklatenz und verteilte Konsistenz. Keine Aufgabe für den ersten Tag eines Juniors.

      • Kafka & RabbitMQ· Später

        Event-getriebene Architekturen und asynchrone Queues. In ein paar Wochen gelernt, wenn die Arbeitslast deines Unternehmens es wirklich verlangt.

      • Redis & Caching· Später

        Cache-Invalidierung ist notorisch schwierig. Optimiere nicht vorschnell; optimiere zuerst deine Datenbankabfragen und Indizes.

    • Fortgeschrittenes DevOps & Cloud· Später

      Cluster- und Cloud-Provisionierung sind Sache von DevOps-/Cloud-Engineers. Sicherer Umgang mit Docker reicht für einen Junior-Backend-Entwickler völlig aus.

      • Kubernetes (K8s)· Später

        Container-Orchestrierung, Pod-Verwaltung und Cluster-Betrieb. Niemand erwartet von einem Junior, Produktions-Cluster zu konfigurieren.

      • AWS / GCP / Azure· Später

        VPCs, IAM-Berechtigungen, Terraform, Managed Cluster ... Das lernst du mit der Firmeninfrastruktur unter Aufsicht von Seniors.

      • Fortgeschrittene CI/CD-Pipeline· Später

        Automatisierte Canary Deployments, Blue-Green-Deployment-Pipelines und fortgeschrittene GitHub-Actions-Workflows.