ResumeGenAI: AI-Powered Resume Generation with Semantic Search

Introduction:

ResumeGenAI is an innovative web application that leverages artificial intelligence to generate personalized, professionally formatted resumes tailored to specific job roles. The system employs advanced semantic search technology powered by Sentence Transformers and FAISS (Facebook AI Similarity Search) to intelligently match user qualifications with the most appropriate resume templates.

 Users begin by entering a job title, after which the application presents three distinct resume design options: creative, minimal, and modern. The platform then guides users through a comprehensive multi-step form to collect personal details, educational background, and work experience. Using dynamic document processing capabilities, the system automatically populates selected resume templates with user information, replacing placeholders with actual data. 

The application supports both DOCX and PDF output formats, allowing users to preview their resumes before final generation. Built with a Flask-based Python backend for robust API handling and document processing, the frontend utilizes static HTML pages served through Nginx for optimal performance. The entire application is containerized using Docker for consistent deployment across different environments, with docker-compose orchestrating multi-container services for seamless operation.


Objectives of Part 1 (DA1):

Primary Objectives:

  • Implement FAISS-based semantic search for matching job titles with appropriate resume templates
  • Develop a Flask-based backend to handle API endpoints and document processing
  • Build static HTML frontend pages for user interaction and resume building workflow
  • Create Docker containerization for backend and frontend services
  • Learn Docker fundamentals and deploy containers using Docker Desktop

Objectives of Part 2 (DA2):

  • Integrate frontend and backend components into a cohesive, fully functional resume generation system
  • Implement healthcare domain-specific resume templates and categorization
  • Enhance Docker configuration with multi-container orchestration using docker-compose
  • Add advanced document processing capabilities for dynamic resume customization
  • Improve UI/UX for better user experience in the resume building process

Objectives of Part 3 (DA3):

Primary Objectives:

  • Implement AI-powered resume editing with OpenAI integration
  • Develop fallback mechanisms for AI services when unavailable
  • Containerize backend application using Docker
  • Push containerized applications to Docker Hub
  • Implement document generation capabilities (PDF/Word)
  • Enhance user experience with intelligent suggestions

System Architecture and Working:

ResumeGenAI follows a microservices architecture with a clear separation between frontend and backend components. The system uses Docker containers for deployment, with each service running in its own isolated environment.

Backend Architecture:

Core Components:

  • Flask Application (main.py): Central API server handling all HTTP requests
  • Semantic Search Engine: FAISS-based similarity search with Sentence-BERT embeddings
  • Document Processing Module: Handles DOCX template processing and PDF conversion
  • Template Management System: Organizes resume templates by category (creative, minimal, modern)

Key Backend Services:

API Endpoints:

  • /get_resumes: Matches job titles with appropriate templates using semantic search
  • /generate_resume: Processes user data and generates final resume documents
  • File serving endpoints for templates and generated resumes
AI Processing Pipeline:
  • Text extraction from DOCX templates
  • Semantic embedding generation using all-MiniLM-L6-v2 model
  • FAISS index building for efficient similarity search
  • Smart content replacement in templates
Data Management:
  • In-memory caching for embeddings to optimize performance
  • Temporary file storage for generated resumes
  • Template categorization system
  • Backend Technology Stack
  • Python with Flask framework
  • Sentence Transformers for NLP processing
  • FAISS for similarity search
  • python-docx for DOCX manipulation
  • docx2pdf for document conversion

Frontend Architecture:

Core Components:

  • Static HTML Pages: Multi-step wizard interface
  • CSS Styling: Responsive design for all device sizes
  • JavaScript Logic: Client-side form handling and API communication

Key Frontend Pages:

  • Landing Page (index.html): Entry point with project introduction
  • Template Builder (builder.html): Job title input and template selection
  • Personal Details Form (details.html): Contact information collection
  • Education Form (education.html): Academic history input
  • Experience Form (experience.html): Work experience details
  • Summary Preview (summary.html): Data verification before generation
  • Final Output (final.html): Resume preview and download options

Frontend Features:

  • Progressive form wizard guiding users through resume creation
  • Real-time template preview functionality
  • Local storage for temporary data persistence
  • Responsive design for desktop and mobile devices
  • Frontend Technology Stack
  • Pure HTML/CSS/JavaScript (no frameworks)
  • Fetch API for backend communication
  • localStorage for client-side data storage
System Workflow:

1. Template Matching Process:

  • User enters job title in frontend
  • Frontend sends request to /get_resumes endpoint
  • Backend processes job title through semantic search:
  • Converts job title to embeddings
  • Searches FAISS indexes for best template matches
  • Returns one template from each category (creative, minimal, modern)
  • Frontend displays matching templates for user selection

2. Resume Generation Process:

  • User completes multi-step form (details, education, experience)
  • Data submitted to /generate_resume endpoint
  • Backend processes generation:
  • Loads selected template
  • Performs smart content replacement (names, emails, phone numbers)
  • Replaces placeholders with user data
  • Saves as DOCX file
  • Converts to PDF if possible
  • Generated resume sent back to frontend for preview/download

3. Docker Orchestration

  • Backend Service: Flask application in Python container
  • Frontend Service: Nginx server for static files
  • Volume Mounts: Shared storage for resume templates and generated files
  • Networking: Internal communication between services


Procedure:

Part 1: Frontend Development & Containerization:

Steps Involved in the Process

Step 1: Project Initialization:

  • Create static HTML/CSS/JavaScript frontend structure
  • Set up project directories:
  • Landing Page/ for frontend pages
  • resumes-project/ for resume templates
  • Implement multi-step form wizard interface
  • Configure responsive design with CSS

Step 2: Component Development:

  • Create main landing page (index.html) with project introduction
  • Develop template builder interface (builder.html) for job title input
  • Implement personal details form (details.html)
  • Build education history form (education.html)
  • Create work experience form (experience.html)
  • Add summary preview page (summary.html)
  • Implement final resume display (final.html)
  • Add JavaScript form handling and API communication

Step 3: Docker Containerization:

  • Create frontend/Dockerfile for Nginx-based frontend container
  • Configure multi-stage build for optimization
  • Set up static file serving with Nginx
  • Test container build and run



Part 2: Backend API Development & AI Integration: 

Steps Involved in the Process

Step 1: Backend Service Setup:

  • Initialize Flask application in backend/main.py
  • Configure routing for API endpoints
  • Set up project structure with proper directory organization
  • Install Python dependencies from backend/requirements.txt

Step 2: AI Integration:

  • Integrate Sentence Transformers for natural language processing
  • Implement FAISS-based semantic search for template matching
  • Configure all-MiniLM-L6-v2 model for embedding generation
  • Set up template categorization system (creative, minimal, modern)

Step 3: Document Processing:

  • Implement DOCX template processing with python-docx
  • Add smart content replacement algorithms
  • Configure PDF conversion with docx2pdf
  • Set up temporary file handling for generated resumes

Step 4: API Endpoint Development:

  • Create /get_resumes endpoint for template matching
  • Implement /generate_resume endpoint for document generation
  • Add file serving endpoints for templates and generated files
  • Set up health check endpoint

Step 5: Docker Containerization:

  • Create backend/Dockerfile for Python backend container
  • Configure health checks and startup scripts
  • Set up environment variables
  • Test container functionality

Step 6: Integration & Orchestration Enhancement:

  • Connect frontend forms to backend API endpoints
  • Implement template preview functionality
  • Configure cross-service communication
  • Test integrated workflow


Part 3: Infrastructure Orchestration & Finalization:

Steps Involved in the Process

Step 1: Docker Compose Configuration:

  • Create docker-compose.yml file
  • Configure service dependencies (frontend, backend)
  • Set up volume mounting for resume templates
  • Configure networking between services

Step 2: Code Quality & UI Finalization:

  • Perform final UI/UX refinements
  • Optimize frontend responsiveness
  • Ensure cross-browser compatibility
  • Conduct final code review and cleanup

Step 3: Documentation Preparation:

  • Create comprehensive user guides
  • Document API endpoints and usage
  • Prepare deployment instructions
  • Compile technical documentation

Step 4: Production Readiness:

  • Implement error handling and logging
  • Add performance optimizations
  • Configure security settings
  • Conduct final testing

Step 5: Pushing Images to Docker Hub:

  • Tag and push both frontend and backend images to Docker Hub:



Step 6: Final Deployment & Demonstration

  • Pull and start services:



Services Running Status:

  • Frontend service: Running on port 80
  • Backend service: Running on port 5000
  • Resume templates: Mounted via volumes



Output:







No modifications were done to containers after downloading.


Docker Hub link of containers:
  • Docker Hub Link: 
   Backend: https://hub.docker.com/repository/docker/madhavan23bce1811/resume-gen-backend/general
                            Frontend: https://hub.docker.com/repository/docker/madhavan23bce1811/resume-gen-frontend/general

Conclusion:

ResumeGenAI successfully combines artificial intelligence with web technologies to create an intelligent resume generation system. Using FAISS-based semantic search with Sentence-BERT embeddings, the system provides accurate template recommendations by understanding the contextual meaning of job titles.

The project features a microservices architecture with Docker containerization, separating the Flask backend for AI processing from the Nginx frontend for responsive user interfaces. The multi-step wizard guides users through job title input, template selection, personal details collection, and final resume generation in both DOCX and PDF formats.

Key achievements include smart placeholder replacement algorithms, performance optimization through lazy loading of FAISS indexes, and cross-platform PDF conversion compatibility. This system reduces resume creation time from hours to minutes while ensuring professional quality and ATS-friendly formatting.


References:


Acknowledgment:

I thank Dr. T. Subbulakshmi for her precise guidance and academic support during the development of this Digital Assignment.

 I acknowledge VIT SCOPE for structuring the Cloud Computing course in a manner that enabled practical exposure to containerization and deployment workflows. 

The official documentation of Docker provided essential technical references during implementation. I also recognize the steady support offered by my family, peers, and course instructor throughout the project.




-Written by S.Madhavan

Comments

Post a Comment