Skip to content
BranchesTags

Latest commit

 

History

263 Commits

Folders and files

NameName
Last commit message
Last commit date
.github/workflows
.github/workflows
 
 
.mvn/wrapper
.mvn/wrapper
 
 
documentation
documentation
 
 
installer
installer
 
 
src
src
 
 
tests/performance
tests/performance
 
 
uploads/resumes
uploads/resumes
 
 
.dockerignore
.dockerignore
 
 
.env.example
.env.example
 
 
.gitignore
.gitignore
 
 
.gitpod.Dockerfile
.gitpod.Dockerfile
 
 
.gitpod.yml
.gitpod.yml
 
 
.prettierrc.json
.prettierrc.json
 
 
Dockerfile
Dockerfile
 
 
Jenkinsfile
Jenkinsfile
 
 
LICENSE.md
LICENSE.md
 
 
README.md
README.md
 
 
dev_instructions.md
dev_instructions.md
 
 
docker-compose.test.yml
docker-compose.test.yml
 
 
docker-compose.yml
docker-compose.yml
 
 
eclipse-formatter.xml
eclipse-formatter.xml
 
 
mvnw
mvnw
 
 
mvnw.cmd
mvnw.cmd
 
 
package.json
package.json
 
 
pom.xml
pom.xml
 
 
test.docx
test.docx
 
 
tsconfig.json
tsconfig.json
 
 
types.d.ts
types.d.ts
 
 
vite.config.ts
vite.config.ts
 
 

Repository files navigation

CL Booster - AI-Powered Cover Letter Generator

Java Spring Boot Vaadin License: MIT

Table of Contents

1. Project Overview

CL Booster is an intelligent cover letter generation tool that leverages AI to create personalized, professional cover letters tailored to each job application. The system solves the "lose-lose" dilemma faced by job seekers: manual writing is incredibly time-consuming, but generic AI output is often low-quality, robotic, or fails to address specific job nuances. Built for global job seekers looking to increase their interview conversion rates, the application is powered by Java 21+, Spring Boot 3.5+, Vaadin Flow 24.9+, and Google Gemini AI. The project was developed over 8 sprints × 2 weeks using Agile/Scrum methodology.

2. Product Vision

  • Vision statement: "Our vision is to make the job application process more dynamic and high-quality. By providing software that facilitates the creation of tailored cover letters for diverse positions, we aim to empower users to apply more effectively and efficiently using specialized AI functionalities."
  • Main goals: Increase hiring success rate by 30%, streamline the cover letter creation process for efficiency, and increase job application volume by 15% through smart automation.
  • Key features:
    • Profile Management — Create, view, and update a comprehensive user profile
    • Resume Vault — Upload and manage different versions of resumes tailored to various industries or roles
    • AI Context Scanner — Use advanced AI to scan resumes and target job descriptions to extract key selling points
    • Application History — A timestamped log of generated cover letters paired with their respective job positions
    • LinkedIn Integration — Sync the app profile directly with a user's LinkedIn profile for seamless data entry
  • Definition of success: Balancing speed with bespoke quality to save time while increasing the quality of job applications.

3. Project Plan & Sprint Structure

  • Development methodology: Agile / Scrum
  • Sprint length: 2 weeks
  • Overview of all 8 sprints:
Sprint Focus Area
Sprint 1 Project Planning & Vision — foundational planning artifacts, backlog creation, vision validation, risk/scope definition
Sprint 2 Requirements & Database — data design, ER diagram, database implementation, unit testing strategy
Sprint 3 UI Implementation & CI — Vaadin UI framework, JaCoCo coverage goals, CI/CD pipeline (Build, Test, Coverage)
Sprint 4 Docker Containerization — containerized services, Docker Hub deployment, installer creation
Sprint 5 UI Localization & Kubernetes — multilingual support (6 languages), RTL/LTR layout handling
Sprint 6 Database Localization — schema updates for multilingual content, code review and refactoring
Sprint 7 Quality Assurance — SonarQube analysis, heuristic evaluation, UAT, performance testing
Sprint 8 Documentation & Finalization — polishing documentation, finalizing repository structure

Sprint 1 – Project Planning & Vision

The first sprint focused on establishing the foundational planning artifacts and defining the project's direction. Key activities included:

  • Project plan summary: Defined the overall project scope, timeline, and resource allocation for the 16-week development cycle
  • Backlog creation: Created the initial product backlog in Jira with user stories covering resume scanning, cover letter generation, profile management, LinkedIn integration, export functionality, ATS compliance, history management, and quality requirements
  • Vision validation: Developed and validated the product vision statement through team collaboration
  • Risk and scope definition: Identified key risks, defined project boundaries, and established success criteria
  • Technology selection: Chose the technology stack (Java, Spring Boot, Vaadin, MariaDB, Google Gemini AI)
  • Use case diagram: Designed the high-level use case diagram capturing system actors and their interactions

📄 Sprint 1 Review Report | Project Vision

Sprint 2 – Requirements & Database

This sprint focused on defining system requirements, data design, and establishing the database foundation.

  • Functional requirements summary: Captured core requirements including resume parsing, information extraction, LLM-based cover letter generation, form auto-filling, PDF/DOCX export, and user authentication (register/login)
  • Use Case Diagram: Designed to illustrate system actors and their interactions with the system
  • ER Diagram: Developed the Entity-Relationship model for Users, Profiles, Cover Letters, and Settings
  • Database technology: MariaDB selected as the primary database with JDBC connectivity
  • Database implementation overview: Schema created, migrated, and tested with DAO and service layers
  • Unit testing strategy: JUnit test framework integrated with JaCoCo for code coverage reporting

📄 Sprint 2 Planning Report | Sprint 2 Review Report

Diagrams:

Sprint 3 – UI Implementation & CI

This sprint focused on implementing the user interface and setting up continuous integration automation.

  • UI framework and design approach: Built a complete graphical user interface using Vaadin Flow framework with server-side Java UI components and database interaction
  • Screens implemented: Registration/Login, Dashboard, Profile Management, Resume Upload/Scanning, Cover Letter Generation Wizard, History
  • Code coverage goals and tools: Integrated JaCoCo HTML coverage reports with a target of comprehensive code coverage across all layers
  • Jenkins pipeline description:
    • Build: Automatic Maven build triggered on code commits to the main branch
    • Test: JUnit test execution with detailed reporting
    • Coverage: JaCoCo coverage report generation and publishing
  • Docker preparation: Dockerfile created and Docker Compose configured for local development testing

Diagrams:

📄 Sprint 3 Review Report

Sprint 4 – Docker Containerization

This sprint focused on containerizing the application services to ensure reproducible environments and easy deployment.

  • Purpose of Docker in the project: Ensured consistent environments across development, testing, and production, eliminated "works on my machine" issues, and simplified deployment
  • Services containerized: Web Application (Spring Boot + Vaadin) and MariaDB database
  • Dockerfile and compose overview: Multi-stage Dockerfile for optimized image size; Docker Compose configuration for local development with both services
  • How containers are used: Docker image built and tested locally, pushed to Docker Hub (timo2233/clboost), and shared with classmates for feedback; app setup installer created for Windows distribution
  • Additional features: History access functionality implemented for viewing and managing previously generated cover letters; resume text extraction library integrated for improved parsing

📄 Sprint 4 Planning Report | Sprint 4 Review Report

Sprint 5 – UI Localization & Kubernetes

This sprint focused on making the application globally accessible through multilingual support.

  • Supported UI languages: English (en), Finnish (fi), Portuguese (pt), Chinese (zh), Urdu (ur), Persian (fa)
  • Localization approach: Java ResourceBundle-based localization system integrated with Vaadin's I18NProvider interface; all static UI text externalized to .properties resource files; dynamic locale switching with session-based locale persistence
  • RTL/LTR layout support: Right-to-left (RTL) layout support implemented for Urdu and Persian using dir="rtl" attribute on <html> element; Vaadin auto-flips AppLayout drawer position, navbar order, and component flow direction; custom CSS overrides for cards, forms, navigation items, and toggle switches
  • Kubernetes usage (prepared but not fully deployed): Application structure prepared for scalable container orchestration; deployment strategy documented for future scaling

📄 Sprint 5 Planning Report | Sprint 5 Review Report

Sprint 6 – Database Localization

This sprint extended localization down to the database level.

  • Language- or region-specific data handling: Designed and implemented a localization strategy for database content to store multilingual data entries
  • Migration or schema changes: Updated ER diagram to accommodate multilingual content; configured UTF-8 encoding and locale settings for proper character support across all languages
  • Validation approach: Validated data retrieval and display across all supported languages (Portuguese, Chinese, Urdu, Persian, English)
  • Code quality improvements: Conducted static code analysis using SonarQube; identified and resolved code violations, complexity issues, redundant logic, and potential bugs; code clean-up and refactoring for improved readability and maintainability
  • Acceptance test planning: Defined functional requirements, performance expectations, and usability standards for the acceptance phase
  • Architecture documentation: Updated ER Diagram, Sequence Diagram, and UML diagrams

Diagrams:

📄 Sprint 6 Planning Report | Sprint 6 Review Report

Reports:

Sprint 7 – Quality Assurance

This sprint ensured project robustness through comprehensive testing and quality analysis.

  • SonarQube usage and metrics: Configured Jenkins integration with SonarQube static code analysis; achieved Grade A across all quality metrics including cyclomatic complexity, code smells, duplications, and security hotspots
  • Code quality goals: All code quality gates passed with Grade A (minimum Grade B required); successful build and Docker deployment through Jenkins pipeline
  • JMeter test scenarios: Performance test plan created at tests/performance/clboost_performance.jmx simulating 10 concurrent users performing typical navigation (landing, login, dashboard, editor, history) with 5 iterations and 2-second think times
  • Functional and non-functional testing:
    • Functional testing: Comprehensive test plan with unit tests, integration tests, and regression tests for all user stories; detailed bug tracking table with resolution status
    • Heuristic evaluation: Usability assessment conducted following lecture instructions
    • User Acceptance Testing (UAT): Conducted based on Sprint 6 acceptance criteria with results documented

📄 Sprint 7 Planning Report | Sprint 7 Review Report

Reports:

Sprint 8 – Documentation & Finalization

This final sprint focused on polishing all project documentation and finalizing the system.

  • Technical documentation: Maintained and updated repository structure with accurate documentation across all modules; finalized developer setup instructions
  • User documentation: Updated README with comprehensive setup, usage, and testing guides; created localization documentation with language spreadsheets
  • API documentation: Documented backend service interfaces, DAO patterns, and AI pipeline integration
  • Final system architecture: Complete architecture encompassing all implemented features including AI pipeline, localization framework, CI/CD pipeline, and database layer

4. How to Run the Project

Prerequisites

  • Java 21+
  • Maven 3.6+
  • Docker & Docker Compose
  • Google Gemini API key (get one here) or Google cloud project ID

Environment Setup

  1. Clone the repository: 
    git clone https://github.com/Lion504/CLboost
cd cl-booster
  2. Copy the environment template and fill in your API key: 
    cp .env.example .env
# Edit .env — add your GEMINI_API_KEY and GOOGLE_PROJECT_ID

Docker Commands

Option A - Docker Compose (recommended):

docker-compose up -d

Option B - Pull from Docker Hub:

docker pull timo2233/clboost:latest
docker run -d -p 8080:8080 --name clboost-app \
  -e GEMINI_API_KEY=your_api_key \
  -e DB_HOST=db \
  -e DB_PORT=3306 \
  -e DB_NAME=CL_generator \
  -e DB_USERNAME=root \
  -e DB_PASSWORD=password \
  timo2233/clboost:v1.0.4

Option C - Build and run locally:

docker build -t clboost-app .
docker run -d -p 8080:8080 --name clboost-app \
  -e GEMINI_API_KEY=your_api_key \
  -e DB_HOST=db \
  -e DB_PORT=3306 \
  -e DB_NAME=CL_generator \
  -e DB_USERNAME=root \
  -e DB_PASSWORD=password \
  clboost-app

How to Access the Application

Open your browser and navigate to http://localhost:8080. The application will load the landing page where you can register a new account or log in.

5. Testing Instructions

How to Run Unit Tests

Execute the following command to run all unit tests:

mvn clean test

Test Coverage Access

Run the full verification to generate JaCoCo coverage reports:

mvn clean verify

The HTML coverage report is then accessible at target/site/jacoco/index.html.

Performance Testing

CLboost includes an Apache JMeter test plan for load testing the web application.

Test plan location: tests/performance/clboost_performance.jmx

Test scenarios: Simulates 10 concurrent users performing typical navigation (landing, login, dashboard, editor, history, etc.) with 5 iterations and 2-second think times.

Running performance tests locally:

  1. Install JMeter 5.6.3+ (download)
  2. Start the application (Docker or mvn spring-boot:run) on port 8080
  3. Execute the test: 
    jmeter -n -t tests/performance/clboost_performance.jmx -l result.jtl -Jport=8080 -e -o report/
  4. View the report: Open report/index.html in a browser

CI integration: Performance tests are part of the Jenkins pipeline (Jenkinsfile), running automatically on every build.

6. Repository Structure

cl-booster/
├── src/
│   └── main/
│       ├── frontend/                       # Frontend assets (themes, styles)
│       ├── java/com/clbooster/
│       │   ├── aiservice/                  # AIService, Exporter, Parser
│       │   └── app/
│       │       ├── backend/                # DAO, services, security, i18n
│       │       └── views/                  # All Vaadin UI views
│       └── resources/                      # application.properties, translations
├── tests/                                  # Performance test plans (JMeter)
├── installer/                              # Windows installer and setup scripts
├── documentation/                          # Sprint reports, diagrams, localization docs
├── uploads/                                # Runtime file storage (resumes, cover letters)
├── docker-compose.yml                      # Docker Compose configuration
├── Dockerfile                              # Multi-stage Docker build
├── Jenkinsfile                             # CI/CD pipeline definition
└── pom.xml                                 # Maven build configuration

7. Features

  • 5-step wizard — job details → resume import → skills → summary → inline editor
  • AI generation — Google Gemini writes personalized cover letters using your profile + resume
  • 3 tone styles — Professional, Creative, Storyteller
  • Resume manager — upload, preview, download, delete resumes
  • History — browse, re-edit, and export past cover letters
  • Multi-language UI — English, Finnish, Chinese, Urdu, Persian, Portuguese
  • Export — DOCX and PDF from the editor

8. Architecture

Backend

  • Spring Boot 3.5+ — application framework
  • Vaadin Flow 24.9+ — server-side Java UI
  • Spring AI — Google Gemini integration
  • MariaDB — database infrastructure prepared (uncomment in application.properties to activate)
  • File storage — uploads/ directory for resumes and cover letters

AI Pipeline

  1. User profile fetched from ProfileDAO
  2. Latest uploaded resume parsed by Parser
  3. Combined context sent to AIService → Gemini API
  4. Result rendered in inline step-5 editor
  5. Auto-saved as .docx to uploads/coverletters/

DevOps

  • Docker — containerization
  • GitHub Actions — CI/CD pipeline
  • Maven — build automation
  • spring-dotenv — .env file support

9. Localization Framework

CL Booster uses a Java ResourceBundle-based localization system integrated with Vaadin's I18NProvider interface for seamless server-side UI translation.

Architecture

UI Views (DashboardView, HistoryView, etc.)
         │ translate("key", params)
         ▼
TranslationService.java (implements I18NProvider)
  - Resolves locale: session → user settings → default
  - Loads ResourceBundle for the active locale
  - Falls back to English if a key is missing
  - Formats {0}, {1} placeholders via MessageFormat
         │ ResourceBundle.getBundle()
         ▼
messages*.properties  (en, fi, zh, ur, fa, pt)

Supported Languages

Language Code File Script Direction
English en messages.properties Latin LTR
Finnish fi messages_fi.properties Latin LTR
Portuguese pt messages_pt.properties Latin LTR
Chinese zh messages_zh.properties Han (CJK) LTR
Urdu ur messages_ur.properties Arabic RTL
Persian fa messages_fa.properties Arabic RTL

10. RTL Support

Urdu (اردو) and Persian (فارسی) use right-to-left (RTL) text direction. The application handles RTL through three layers:

How RTL Works

  1. dir attribute — TranslationService.setCurrentLocale() sets dir="rtl" on the <html> element whenever an RTL language (fa, ur, ar, he) is selected
  2. Vaadin auto-flip — Vaadin Flow 24.9+ reads dir="rtl" and automatically flips AppLayout drawer position, navbar order, and component flow direction
  3. Custom CSS overrides — styles.css adds RTL-specific rules for cards, forms, navigation items, toggle switches, and animations

What Flips Automatically

  • Sidebar drawer position (left ↔ right)
  • Form label/input alignment
  • Navigation menu order
  • Table column order
  • Button group ordering
  • Toggle switch thumb position (uses CSS inset-inline-start/end)

RTL Font Fallbacks

RTL languages use Arabic-script fonts with cascading fallbacks: Noto Sans Arabic → Noto Nastaliq Urdu → Vazirmatn → system defaults.

Testing RTL

  1. Launch the application
  2. Open Settings → Language
  3. Select فارسی (Persian) or اردو (Urdu)
  4. Verify: sidebar moves right, all text aligns right, toggle switches flip, no overlapping or clipped content
  5. Switch back to English — verify everything flips back to LTR

11. Development

Unit and Coverage Testing

  • How to run unit tests: Run mvn clean test
  • Test coverage access: Run mvn clean verify to generate the JaCoCo coverage report, accessible at target/site/jacoco/index.html.

SonarQube (Static Code Analysis)

SonarQube provides continuous inspection of code quality, security, and maintainability.

Quick Start with Docker

# Start SonarQube container (runs on http://localhost:9000)
docker run -d --name sonarqube \
  -p 9000:9000 \
  sonarqube:lts-community

# Wait ~2 minutes for startup, then access:
# http://localhost:9000 | admin / admin

Run Analysis

# Full build with tests + coverage + Sonar analysis
mvn clean verify sonar:sonar

# Or run analysis only (skip tests)
mvn compile sonar:sonar

12. Performance Testing

CLboost includes an Apache JMeter test plan for load testing the web application, helping evaluate responsiveness and stability under concurrent user load.

Test Plan Location

tests/performance/clboost_performance.jmx

Test Scenarios

  • Simulates 10 concurrent users performing typical navigation (landing, login, dashboard, editor, history, etc.)
  • Each user performs 5 iterations with a 2-second think time between requests.
  • Both public and protected pages are tested; protected pages return redirects for anonymous users (expected).

Running Locally

  1. Install JMeter 5.6.3+ and ensure jmeter is on your PATH.
    Download: https://jmeter.apache.org/download_jmeter.cgi

  2. Start the application (Docker or mvn spring-boot:run) on port 8080 (or adjust).

  3. Execute the test:

jmeter -n -t tests/performance/clboost_performance.jmx -l result.jtl -Jport=8080 -e -o report/
  1. View the report: Open report/index.html in a browser.

CI Integration

Performance tests are part of the Jenkins pipeline (Jenkinsfile). The Performance Test stage runs automatically on every build against a running test environment. Results are archived as build artifacts.

Interpreting Results

  • Avg – average response time (ms). Aim for < 2000ms.
  • Err % – error rate. Should be ≤ 5% (5xx responses or assertion failures).
  • Throughput – requests/second; higher is better.

See dev_instructions.md for full setup, CLI usage, Docker, and deployment details.

13. Authors

  • Wang Yongzhi — Frontend & DevOps Lead (Vaadin UI, Docker, CI/CD, Localization)
  • Taysa Abinader — Project Manager & QA Lead (Scrum Master, Documentation, Testing, Heuristic Evaluation)
  • Tamseela Mahmood — Backend & QA (Authentication, Database, Code Coverage, UAT)
  • Kiavash Montazeri — Integration & Testing (Docker, LinkedIn API, PDF Libraries, Functional Testing)
  • Course: Software Engineering Project 1 (TX00EY27-3011) & Software Engineering Project 2 (TX00EY30-3011), Spring 2026

License

This project is licensed under the MIT License — see LICENSE.md for details.

Acknowledgments

Made with ❤️ using Vaadin + Spring Boot

About

AI-powered cover letter generator built with Java, Spring Boot & Vaadin — Gemini AI integration, 6-language i18n with RTL support, Docker + Jenkins CI/CD, JMeter load testing.

Topics

ci-cddockergemini-aii18njavajenkinsspring-bootvaadin

Resources

Readme
Unlicense
Activity

Stars

1 star

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages