AI Task Manager: Enterprise-Backend mit KI-Fokus

Die Anforderungen an moderne Softwareentwickler haben sich grundlegend verändert. Es reicht nicht mehr, nur Code zu schreiben – Unternehmen suchen Entwickler, die sichere, skalierbare Softwarelösungen in Java entwickeln, KI-Applikationen in bestehende Systeme integrieren und komplexe Mehrbenutzer-Anwendungen mit Enterprise-Grade Security architektieren können. Der AI Task Manager ist mein Antwort-Projekt: Eine produktionsreife Full-Stack-Webanwendung, die all diese Fähigkeiten in einem einzigen, lauffähigen System vereint.

System Context & Architektur

Backend: Java Spring Boot 3.2 mit sauberer Architektur

Das Herzstück der Anwendung ist ein Java 17 Backend auf Spring Boot 3.2. Die Architektur folgt einer strikten Schichtentrennung – ein Prinzip, das in Enterprise-Umgebungen unverzichtbar ist:

Controller  →  Validierung, HTTP-Mapping, Response-Codes
     ↓
Service     →  Geschäftslogik, AI-Orchestrierung, Aggregation
     ↓
Repository  →  JPA-Queries, Datenpersistenz (H2 als PoC)

Der TaskController implementiert eine vollständige CRUD REST API mit erweiterten Filtermöglichkeiten. Tasks können nach Status, Kategorie und Priorität gefiltert werden – alles über typsichere Enums und JPQL-Queries im Repository:

@RestController
@RequestMapping("/api/tasks")
public class TaskController {

    @GetMapping
    public ResponseEntity<List<TaskResponse>> getAllTasks(
            @RequestParam(required = false) Task.Status status,
            @RequestParam(required = false) String category,
            @RequestParam(required = false) Task.Priority priority,
            Principal principal) {
        List<Long> userIds = getEffectiveUserIds(principal);
        return ResponseEntity.ok(taskService.getTasksForUsers(userIds, status, category, priority));
    }

    @PostMapping
    public ResponseEntity<TaskResponse> createTask(
            @Valid @RequestBody TaskCreateRequest request,
            Principal principal) {
        AppUser user = getCurrentUser(principal);
        return ResponseEntity.status(HttpStatus.CREATED).body(taskService.createTask(request, user));
    }
}

Zusätzlich bietet die API einen Statistik-Endpunkt (/api/tasks/statistics), der serverseitige Aggregationen nach Status, Priorität und Kategorie über JPA-Queries liefert – ideal für Dashboard-Visualisierungen. Alle Endpunkte arbeiten user-scoped: Jeder API-Aufruf filtert automatisch nach den effektiven User-IDs des authentifizierten Benutzers.

KI-Integration: LLM-Anbindung via REST API

Das Alleinstellungsmerkmal des Projekts ist die nahtlose Integration eines Large Language Models in die Geschäftslogik. Der AiService kommuniziert mit der xAI Grok API, die ein OpenAI-kompatibles Chat-Completions-Protokoll implementiert. Das bedeutet: Der gleiche Code funktioniert mit jedem OpenAI-kompatiblen LLM-Provider.

Vier KI-Features sind direkt in die Anwendung integriert:

Die Implementierung nutzt Prompt Engineering mit deutschsprachigen System-Prompts. Jeder KI-Aufruf ist als dedizierte Methode im AiService gekapselt. Die API-Keys werden dabei pro Benutzer in der Datenbank gespeichert – jeder User kann seinen eigenen KI-Zugang konfigurieren:

public AiResponse categorize(String text, AppUser user) {
    if (!isApiKeyConfigured(user)) {
        return mockCategorize(text);  // Graceful Fallback
    }
    String prompt = "Analysiere die folgende Aufgabe und ordne " +
        "sie EINER Kategorie zu: 'Entwicklung', 'Design', " +
        "'Testing', 'DevOps', 'Bugfix' ...";
    return callGrokApi(prompt, user.getApiKey());
}

Robustes Design: Mock-Fallback ohne API-Key

Ein besonderes Architektur-Detail: Bei fehlendem API-Key fallen alle KI-Funktionen automatisch auf einen regelbasierten Mock-Modus zurück. Keyword-basierte Heuristiken liefern realistische Antworten, sodass die gesamte Anwendung auch ohne externen API-Zugang voll funktionsfähig ist. Das ist entscheidend für Demos und Präsentationen – die App funktioniert immer.

private AiResponse mockPrioritize(String text) {
    String lowerText = text.toLowerCase();
    if (lowerText.contains("kritisch") || lowerText.contains("crash")) {
        return AiResponse.mock("CRITICAL - Sofortige Aufmerksamkeit");
    }
    if (lowerText.contains("sicherheit") || lowerText.contains("deadline")) {
        return AiResponse.mock("HIGH - Hohe Priorität");
    }
    return AiResponse.mock("MEDIUM - Standardpriorität");
}

Modernes Frontend: Vue 3 mit Composition API

Das Frontend ist mit Vue 3 und der Composition API (<script setup>-Syntax) implementiert. Pinia übernimmt das State Management, Vue Router das Routing mit Lazy Loading. Die API-Kommunikation ist in einer eigenen Service-Schicht gekapselt – eine saubere Trennung, die auch bei wachsender Komplexität wartbar bleibt.

Besonders elegant: Der Vite Production-Build wird direkt in das src/main/resources/static/-Verzeichnis des Spring-Boot-Projekts ausgegeben. Das Ergebnis ist ein einzelnes WAR-Artefakt, das Frontend und Backend enthält – bereit für das Deployment auf jedem Servlet-Container.

Spring Security: Authentifizierung & Rollenbasierte Zugriffskontrolle

Eine Webanwendung ohne Sicherheitskonzept ist in der Enterprise-Welt undenkbar. Der AI Task Manager implementiert ein vollständiges Authentifizierungs- und Autorisierungssystem auf Basis von Spring Security 6.x – dem De-facto-Standard in der Java-Welt.

Das Sicherheitsmodell basiert auf drei klar definierten Rollen mit abgestuften Berechtigungen:

Die Architektur-Entscheidung fiel bewusst auf session-basierte Authentifizierung statt JWT – für eine serverseitig gerenderte Enterprise-Anwendung die robustere Wahl: Sessions können serverseitig invalidiert werden, es gibt kein Token-Expiry-Management im Frontend, und die Integration mit Spring Security ist nahtlos.

@Configuration
@EnableWebSecurity
@EnableMethodSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) {
        http.authorizeHttpRequests(auth -> auth
            .requestMatchers("/api/auth/login", "/api/auth/demo-login").permitAll()
            .requestMatchers("/api/admin/**").hasRole("ADMIN")
            .requestMatchers("/api/**").hasAnyRole("ADMIN", "USER", "DEMO")
            .anyRequest().permitAll()
        )
        .exceptionHandling(ex -> ex
            .authenticationEntryPoint(new HttpStatusEntryPoint(UNAUTHORIZED))
        );
        return http.build();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder(); // Industry-Standard Hashing
    }
}

Die Autorisierung arbeitet auf Method-Level mit @PreAuthorize-Annotationen. Der AdminController ist komplett mit @PreAuthorize("hasRole('ADMIN')") gesichert – feingranulare Zugriffskontrolle ohne manuelles if/else in der Geschäftslogik. Passwörter werden ausschließlich als BCrypt-Hashes in der Datenbank gespeichert.

Multi-Tenancy: Datenisolierung & Gruppenkonzept

In einer Mehrbenutzer-Umgebung ist Datenisolierung eine der anspruchsvollsten Architektur-Anforderungen. Der AI Task Manager löst dieses Problem durch ein durchdachtes Ownership- und Gruppenmodell:

Jede Task gehört einem Benutzer (@ManyToOne-Relation). Die Sichtbarkeit wird dynamisch über UserGroup-Zugehörigkeit erweitert – Teammitglieder sehen die Tasks aller Gruppenmitglieder:

// User-scoped Task Resolution mit Gruppen-Erweiterung
public List<Long> getEffectiveUserIds(AppUser user) {
    if (user.getGroup() != null) {
        // Alle Gruppen-Mitglieder → gemeinsame Task-Sichtbarkeit
        return userRepository.findByGroupId(user.getGroup().getId())
                .stream().map(AppUser::getId).collect(Collectors.toList());
    }
    return List.of(user.getId()); // Nur eigene Tasks
}

Diese Architektur-Entscheidung hat weitreichende Konsequenzen: Jeder API-Endpunkt – von der Task-Liste über Statistiken bis zur Kategorie-Abfrage – arbeitet mit den effektiven User-IDs. Es gibt keine „Hintertür", über die ein Benutzer auf fremde Daten zugreifen kann. Die Datenisolierung ist auf Service-Layer-Ebene implementiert, nicht als nachträglicher Filter.

Admin-Panel: Zentrale Benutzer- & Gruppenverwaltung

Enterprise-Anwendungen benötigen ein dediziertes Administrations-Interface. Der AI Task Manager bietet ein vollständiges Admin-Panel – geschützt durch @PreAuthorize("hasRole('ADMIN')") auf jedem Endpunkt:

Das Frontend setzt das Admin-Panel als eigene Vue-Komponente (AdminView.vue) mit Modal-Dialogen für User-Erstellung, Passwort-Reset und Gruppenverwaltung um. Eine tabellarische Übersicht zeigt alle Benutzer mit Rolle, Gruppenzugehörigkeit und API-Key-Status auf einen Blick. Der Demo-Zugang mit vorkonfigurierten Seed-Daten (10 realistische Beispiel-Tasks via DataInitializer) ermöglicht potenziellen Auftraggebern und Fachbesuchern, die Anwendung sofort und ohne Registrierung zu erleben.

Stellenanforderungen im Praxischeck

Moderne Stellenausschreibungen für Backend Developer mit AI-Fokus fordern typischerweise eine Kombination aus klassischer Softwareentwicklung und KI-Kompetenz. Hier zeigt der AI Task Manager, wie diese Anforderungen konkret erfüllt werden:

Entwicklungsgeschwindigkeit: Enterprise-Software in Stunden, nicht Monaten

Die vielleicht beeindruckendste Eigenschaft dieses Projekts liegt nicht im Code selbst – sondern in der Geschwindigkeit, mit der es entstanden ist. Durch den gezielten Einsatz von KI-gestützten Entwicklungswerkzeugen wurde der erste lauffähige Prototyp in einer einzigen Stunde realisiert – inklusive Linux-Server-Installation, WildFly-Konfiguration und erstem Deployment.

Nicht 6 Monate. Nicht 2 Monate. Nicht einmal einen Monat. Drei Stunden von der ersten Zeile Code bis zur deployte Enterprise-Anwendung mit Spring Security, RBAC und Multi-Tenancy. Das ist kein Wunschdenken – das ist die Realität, wenn ein erfahrener Entwickler KI-gestützte Werkzeuge nicht als Spielzeug betrachtet, sondern als Kraftmultiplikator auf 25 Jahre Systemerfahrung einsetzt.

Ist die Software nach 3 Stunden fehlerfrei? Keine Software ist fehlerfrei. Aber die Architektur ist sauber, die Sicherheitskonzepte sind korrekt implementiert, und die Grundlage steht produktionsreif. 3 Stunden Entwicklung + 20 Stunden Testing und Härtung – und das Ergebnis ist eine Anwendung, die sich vor keiner Enterprise-Lösung verstecken muss. Das ist der Unterschied, den KI-Kompetenz ausmacht.

Fazit: Die Zukunft der Softwareentwicklung ist jetzt

Der AI Task Manager ist der Beweis, dass komplexe Enterprise Proof of Concepts nicht Monate brauchen. Er ist eine lauffähige, deployte Webanwendung mit 29 Java-Klassen, 5 Vue-Komponenten und einem durchdachten Sicherheitskonzept – entstanden in 3 Stunden. Jede Architekturentscheidung orientiert sich an realen Enterprise-Anforderungen, wobei die explizite Security-Härtung (Audit, Penetration Testing) als folgender manueller Prozess vorausgesetzt ist.

Das Projekt zeigt, dass die Verbindung von 25 Jahren Systemerfahrung, Security-Best-Practices und KI-gestützter Entwicklung eine neue Dimension der Produktivität eröffnet. Nicht als Zukunftsvision – sondern hier und jetzt, nachweisbar und live abrufbar. Die Demo mit integriertem One-Click-Login ist der beste Beweis dafür.