An AI-augmented backend system with asynchronous LLM processing that enhances task management with intelligent summarization, classification, and tagging using LLM APIs. The backend is designed to handle core operations securely while integrating JWT Authentication for stateless user sessions. Data is persisted in PostgreSQL, with Redis used as a distributed cache for frequently accessed dashboard metrics (with auto-TTL of 10 minutes). File attachments are stored securely in Amazon S3 with a local storage fallback. AI processing is fully asynchronous using a bounded ThreadPoolTaskExecutor to ensure zero latency impact on user operations. The application is containerized using Docker with Docker Compose orchestrating PostgreSQL, Redis, and the application. A React frontend with a glassmorphism dark-mode UI provides an interview-ready demo experience.

This project is built as a fully decoupled frontend-backend architecture (service-oriented).

• Frontend Application (Live): https://taskflow-ui-two.vercel.app/
• Frontend Source Code: https://github.com/Kushan-shah/TaskFlow-UI
• Primary Backend API (AWS EC2): http://65.2.191.152:8080/swagger-ui/index.html#/
• Fallback Backend API (Render): https://task-manager-api-live.onrender.com/swagger-ui/index.html#/
• Backend Source Code: https://github.com/Kushan-shah/TaskFlow-AI

• JWT Authentication: Secure, stateless endpoint protection using JSON Web Tokens.
• Role-Based Access Control (RBAC): Granular authorization mechanisms supporting USER and ADMIN roles via @PreAuthorize.
• Task CRUD Operations: Complete lifecycle management for task entities with soft deletion.
• Filtering & Pagination: Dynamic query execution using Spring Data JPA Specifications.
• Soft Delete: Logical record deletion to preserve data integrity and analytics.
• Redis Caching: Distributed caching layer (via RedisCacheManager with JSON serialization and 10-min TTL) to optimize the dashboard analytics endpoint. Falls back to in-memory cache in dev profile.
• AWS S3 Integration: Secure multipart file uploads for task attachments, with local filesystem fallback.
• Automated Scheduler: Spring @Scheduled cron jobs to identify and log overdue tasks asynchronously.
• Global Exception Handling: Centralized @RestControllerAdvice to format error responses system-wide.
• AI Task Summarization: Automatic intelligent summarization of tasks using Google Gemini LLM API.
• AI Priority Prediction: LLM-driven classification of task priority (HIGH / MEDIUM / LOW).
• AI Tag Extraction: Auto-detection of relevant tags from task descriptions.
• Async AI Processing: Spring @Async with bounded ThreadPoolTaskExecutor — AI calls never block the API response.
• React Frontend: Dark-mode glassmorphism UI with dashboard charts (Recharts), AI insight panels, shimmer loading states, and RBAC-aware sidebar.

• Integrated with Google Gemini API (LLM inference via REST)
• Designed prompts to enforce strict JSON output, ensuring deterministic parsing and minimizing hallucination risks
• Implemented defensive JSON parsing with validation to prevent malformed AI responses
• Asynchronous processing using bounded ThreadPoolTaskExecutor
• AI processing is fully isolated from core transactional flow, preventing cascading failures or thread blocking under slow LLM responses
• Fail-fast timeout handling (10s) with graceful degradation
• Structured output parsing (summary, priority, tags)
• Retry mechanism via manual re-trigger endpoint

• AI endpoints can be rate-limited to prevent abuse and control external API cost spikes
• Stateless JWT authorization scales horizontally across multiple servers without sticky sessions

• AI processing failures do not impact core task creation flow
• Errors captured in aiErrorMessage field for observability
• Timeout protection ensures API responsiveness under slow LLM responses
• Manual retry endpoint allows reprocessing failed tasks

Input from User:

• Title: "Fix slow database queries"
• Description: "Dashboard API is taking 3 seconds due to unoptimized queries"

Output from Google Gemini (Structured JSON):

{
  "summary": "Optimize database queries to improve dashboard performance",
  "priority": "HIGH",
  "tags": ["database", "performance", "optimization"]
}

The application strictly adheres to a layered architecture pattern. This design enforces strong separation of concerns, which makes the codebase highly maintainable, testable, and naturally scalable:

• Controller Layer: Intercepts HTTP requests, validates incoming DTO payloads, and routes them to the business logic layer.
• Service Layer: Houses the core business logic, transaction management, and coordinates external service calls (e.g., AWS S3, Gemini AI).
• Repository Layer: Interfaces with PostgreSQL using Spring Data JPA for persistence and querying.
• Caching Layer: Redis-backed distributed cache for hot-path analytics (dashboard). Uses Spring Cache abstraction — swappable with zero code changes.
• Database Layer: The underlying persistent data store (PostgreSQL for production, H2 in-memory for development).

• Chose async processing over synchronous LLM calls to eliminate user-facing latency.
• Async design reduces unnecessary repeated LLM calls, optimizing API usage cost.
• Used bounded thread pool to prevent resource exhaustion under high load (Queue size capped at 50).
• Leveraged Redis caching for read-heavy dashboard endpoints with tenant-isolated eviction.
• Maintained stateless authentication for seamless horizontal scalability.
• Defaulted to @Version JPA Optimistic Locking to prevent "Lost Updates" in high-concurrency environments.
• Trade-off: AI insights are eventually consistent (not real-time) due to async processing tradeoffs.

This API utilizes a stateless JWT scheme:

1. Login: The client submits credentials to /api/auth/login. Upon successful authentication, the server generates and issues a signed JWT.
2. Token Passing: Subsequent requests must include the JWT in the Authorization: Bearer <token> HTTP header.
3. Validation: A custom Spring Security filter intercepts requests to protected endpoints, extracting and validating the token signature and expiration.
4. Stateless Operation: No session data is stored on the server. This statelessness significantly improves horizontal scalability, as any server instance can validate requests independently without relying on a shared session store.

Automated load tests are run using k6 to validate API performance under concurrent user traffic.

✅ http_req_duration p(95) < 2000ms → PASSED (actual: 8.12ms)
✅ error_rate < 10%                 → PASSED (actual: 2.57%)

k6 run k6-load-test.js

src/main/java/com/taskmanager/
├── controller/     # REST API controllers (Auth, Task, Admin)
├── service/        # Business logic and transactions
├── repository/     # Data access layer (Spring Data JPA)
├── entity/         # JPA entities and enums
├── dto/            # Request and Response mapping objects
├── security/       # JWT filters and authorization logic
├── config/         # Security, Redis Cache, Swagger, CORS, Async configurations
├── exception/      # Global exception handlers
├── scheduler/      # Scheduled CRON jobs (Overdue task detection)
└── util/           # Helper classes and mappers

Copy the sample environment file and insert your credentials:

cp .env.example .env

No PostgreSQL or Redis needed for development:

mvn clean install
mvn spring-boot:run -Dspring-boot.run.profiles=dev

To easily spin up the API, PostgreSQL database, and Redis simultaneously:

docker-compose up --build

docker-compose -f docker-compose.prod.yml up --build -d

cd ../task-manager-ui
npm install
npm run dev

The React app runs on http://localhost:5173 and connects to the Spring Boot API.