Employee_Feedback_Analyzer: The HR AI Stack That Fits in One Monolith
A Java 21 and SQLite system that turns raw employee complaints into structured signals, then grounds HR answers in policy text without needing a vector database.
- This repo uses a deliberately small stack to solve a problem that usually attracts heavy infrastructure.
- Feedback is converted into structured metadata at ingestion time, which makes HR triage faster and less dependent on manual reading.
- Privacy is treated as a design constraint, not a marketing slogan, so anonymity and accountability stay in tension throughout the system.
- The assistant is strongest when it answers from policy text, not from generic model memory.
The strange part is what it does not use
Most enterprise AI tools arrive with the same baggage: a database cluster, a vector store, a separate inference service, and a lot of operational ceremony. This project cuts that stack down to the essentials. It runs on Java 21, Spring Boot, SQLite, and a Java-native retrieval layer, yet still turns workplace feedback into structured signals and policy-grounded responses.
That restraint is the point. The repo is not trying to prove that HR needs more software. It is trying to prove that sensitive internal AI can work with less infrastructure, fewer moving parts, and a narrower blast radius.
Why workplace feedback is a hard AI problem
Workplace feedback is not ordinary support text. It can describe harassment, burnout, compensation anger, manager conflict, or plain confusion, often in language that is emotionally charged and easy to misread. A useful system has to preserve trust for employees while still giving HR enough structure to act quickly.
The repository’s design acknowledges that tension directly. It does not treat anonymity as a cosmetic UI setting. It treats it as part of the data model, alongside the kinds of metadata HR actually needs to separate noise from escalation.
The feedback pipeline, from submission to structured signal
The heart of the system is simple to describe and easy to underestimate. An employee submits feedback. Gemini analyzes it for sentiment, emotion, intent, topic, and urgency. The result is stored in SQLite as structured data, not just as a raw string.
// Conceptual flow in the repository
Feedback feedback = feedbackService.submit(employeeText, isAnonymous);
AnalysisResultDto analysis = geminiService.analyze(employeeText);
feedback.setSentimentScore(analysis.sentimentScore());
feedback.setEmotion(analysis.emotion());
feedback.setIntent(analysis.intent());
feedback.setTopic(analysis.topic());
feedback.setUrgency(analysis.urgency());
feedbackRepository.save(feedback);That order matters. The project does not wait for humans to classify the message later. It front-loads the interpretation so downstream tools can filter by urgency, group by theme, and spot organizational patterns without rereading every complaint.
Privacy by design, but not privacy by default
The anonymous flag gives the system its ethical edge, but it also exposes the hardest tradeoff in the product. HR needs enough context to investigate. Employees need enough protection to speak honestly. A system that is too opaque loses accountability. A system that is too transparent loses trust.
This is why the implementation matters more than the slogan. The data can remain relational behind the scenes, while the HR-facing view masks identity details. That lets the organization preserve continuity in its records without turning the dashboard into a surveillance tool.
| Dimension | Local-first design | Conventional enterprise AI stack |
|---|---|---|
| Persistence | SQLite in-process | PostgreSQL or managed database cluster |
| Retrieval | Java-native TF-IDF over policy text | Dedicated vector database and retrieval service |
| Auth | Stateless JWT plus RBAC | Broader auth stack with more integration layers |
| Feedback handling | Structured metadata at ingestion | Raw text inbox with later manual triage |
| Operations | One monolith, fewer dependencies | More services, more coordination overhead |
The HR Assistant is really a grounded policy lookup machine
The assistant is not trying to be a universal workplace oracle. It is a retrieval system with a conversational layer on top. The knowledge base lives in text files under the backend resources directory, and the retrieval logic uses Java-side similarity scoring to select relevant policy context before generating an answer.
That design keeps the assistant anchored to the organization’s own documents. When someone asks about leave policy, conduct issues, or escalation rules, the answer is shaped by the policy corpus rather than by the model’s generic memory. In a workplace setting, that distinction is the whole game.
Why the stack feels enterprise-grade without enterprise sprawl
The combination of Java 21, Spring Security, JWT, Hibernate, SQLite, and TF-IDF looks almost understated. It is not flashy. It is durable. The system has clear boundaries, a transactional backend, and a small operational footprint, which is exactly what an internal tool handling sensitive feedback needs.
That compactness is also strategic. A smaller stack is easier to audit, easier to deploy, and easier to keep consistent across environments. In a domain where trust is part of the product, operational simplicity is not a bonus. It is part of the UX.
| What this repo optimizes for | What it avoids |
|---|---|
| Low operational overhead | A sprawling services mesh |
| Policy-grounded answers | Free-form LLM guesswork |
| Structured triage | Manual reading of every message |
| Portable deployment | Heavy infrastructure dependency |
What this project is really a model for
Employee_Feedback_Analyzer is less a finished product than a pattern worth copying. It shows how to build small-footprint internal AI tools that are privacy-aware, policy-grounded, and useful before they become complicated. That combination is rare because most teams solve one of those goals at the expense of the others.
The lesson is not that every HR system should be Java plus SQLite. The lesson is that sensitive workflows often benefit from the least dramatic architecture that still respects the problem. Here, the monolith is the feature.