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.

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 Database)

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 Enterprise-Grade Software nicht Monate braucht. Er ist eine lauffähige, deployte Webanwendung mit 29 Java-Klassen, 5 Vue-Komponenten und einem durchdachten Sicherheitskonzept – entstanden in 3 Stunden. Von der BCrypt-gesicherten Authentifizierung über rollenbasierte Zugriffskontrolle bis zur Multi-Tenant-Datenisolierung: Jede Architekturentscheidung orientiert sich an realen Enterprise-Anforderungen.

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.