the-ats
Prem PatelBuild a production-ready full-stack AI Resume Analyzer web application. OBJECTIVE Create a complete application where users can create an account, log in, upload a PDF resume, paste a job description, and receive an AI-powered analysis comparing their resume against the job description. The application should be implemented as a real working product, not a visual prototype. Do not use hardcoded fake analysis results. CORE USER FLOW 1. User creates an account or logs in. 2. User uploads a PDF resume. 3. The application securely extracts text from the PDF. 4. User pastes a job description. 5. User starts the analysis. 6. The backend sends the relevant resume and job-description content to an LLM. 7. The application displays a structured analysis. 8. The analysis is saved to the user's account. 9. User can view previous analyses from a dashboard. 10. User can open or delete previous analyses. AI ANALYSIS The analysis must include: - Overall resume-to-job match score from 0–100 - Matching skills - Missing skills - Relevant experience - Potential weaknesses - Recommended resume improvements - Recommended skills to learn - Strengths of the candidate - Concise explanation of why the candidate matches or does not match the job - Clear evidence from the resume supporting important conclusions Do not generate fake/static analysis data. The LLM integration must use an environment variable for the API key. Never expose API keys in frontend code. TECHNICAL REQUIREMENTS Frontend: - React - TypeScript - Tailwind CSS - Responsive design - Reusable components - Clean component architecture Backend: - Backend API - Proper separation between frontend and backend responsibilities - Input validation - Error handling - Secure API key handling - Proper HTTP status codes Database: - PostgreSQL - Store users - Store uploaded resume metadata - Store extracted resume information where appropriate - Store job descriptions - Store analysis results - Maintain proper relationships between users and their analyses - Use appropriate indexes and constraints Authentication: - User registration - Login - Logout - Secure authentication - Protected dashboard and analysis routes - Users must only be able to access their own data PDF PROCESSING: - Accept PDF resume uploads - Validate file type - Validate reasonable file size - Extract actual text from the PDF - Handle invalid or unreadable PDFs gracefully - Do not simply pretend that extraction occurred AI INTEGRATION: - Use a real LLM integration - API key must come from environment variables - Do not hardcode API keys - Structure the AI response in a predictable format - Validate the AI response before displaying/storing it - Handle API failures, malformed responses, rate limits, and timeouts gracefully DASHBOARD Create a professional dashboard where users can: - See their previous resume analyses - See resume/job title information - See match scores - Open a previous analysis - Delete a previous analysis - Start a new analysis UI/UX Create a modern, professional and polished interface suitable for a real SaaS product. Include: - Landing/login experience - Authentication pages - Dashboard - Resume upload interface - Job description input - Analysis loading state - Analysis results page - Previous analysis history - Empty states - Error states - Success states - Confirmation states where appropriate - Mobile responsive layouts - Accessible forms and controls - Clear visual hierarchy The UI should not just look good. All important interactions must actually work. ANALYSIS RESULTS UI Present the analysis in a clear dashboard-style format. Include: - Match score visualization - Skills matched - Skills missing - Experience analysis - Strengths - Weaknesses - Resume improvement recommendations - Learning recommendations - Explanation/evidence Avoid overwhelming the user with one large block of text. SECURITY Implement reasonable production security practices: - Never expose API keys to the client - Validate uploaded files - Validate user input - Protect authenticated routes - Prevent users from accessing another user's analyses - Avoid trusting client-provided user IDs - Handle database errors safely - Do not expose sensitive server information in error messages - Use environment variables for secrets - Apply appropriate authorization checks to every protected resource TESTING Create meaningful tests for important functionality. At minimum test: - Authentication - Protected routes - PDF upload validation - PDF text extraction - Database operations - Analysis creation - Authorization / user isolation - AI response handling - Important API endpoints - Important frontend functionality Run the tests after implementation. If tests fail, investigate and fix the underlying issues rather than simply removing or disabling the tests. PROJECT QUALITY Use: - Clean architecture - Reusable components - Meaningful variable and function names - Type safety - Proper error handling - Separation of concerns - Maintainable code - Minimal unnecessary dependencies Do not generate unnecessary files or complexity. README Create a comprehensive README containing: - Project overview - Features - Architecture - Technology stack - Prerequisites - Installation - Environment variables - Database setup - How to run frontend - How to run backend - How to run tests - How to use the application - Deployment instructions - Troubleshooting Create a `.env.example` file showing all required environment variables without exposing real secrets. IMPLEMENTATION PROCESS Before implementation: 1. Analyze the requirements. 2. Create a clear technical architecture. 3. Identify the required frontend, backend, database and AI components. 4. Create an implementation plan. 5. Identify potential technical risks. Then implement the complete application. After implementation: 1. Install dependencies. 2. Run the application. 3. Run tests. 4. Test the important user flows. 5. Fix errors discovered during testing. 6. Verify authentication. 7. Verify PDF upload and text extraction. 8. Verify database persistence. 9. Verify AI analysis. 10. Verify previous-analysis retrieval. 11. Verify deletion. 12. Verify authorization/user isolation. 13. Verify responsive UI. 14. Verify that the application can be started using the documented instructions. Do not stop after generating code. Continue until the application has been tested and verified as far as the available environment allows. IMPORTANT: If an external API, credential, deployment service, or other resource is unavailable, do not fake the result. Clearly document what could not be verified. DO NOT USE FAKE IMPLEMENTATIONS Do not: - Use hardcoded analysis results - Create fake API responses and claim they are real - Create fake database persistence - Pretend tests passed when they were not run - Pretend deployment succeeded when it was not performed - Claim a feature is complete when it is only a placeholder - Hide errors instead of fixing them If something cannot be implemented because of an unavailable external dependency, clearly mark it as incomplete and explain what is required to finish it. FINAL REPORT REQUIREMENT After completing the implementation and testing, create a file named: FINAL_REPORT.md Place it in the project root. This file is extremely important because it will be used to independently compare this implementation against the same application generated by other AI development platforms. The FINAL_REPORT.md must contain: 1. Project Overview 2. Executive Summary 3. Features Implemented 4. Features Partially Implemented 5. Features Not Implemented 6. Technology Stack 7. System Architecture 8. Complete Project Structure 9. Database Schema 10. API Endpoints 11. Authentication Architecture 12. AI/LLM Integration 13. PDF Upload and Text Extraction Implementation 14. Security Measures 15. Testing Strategy 16. Tests Actually Run 17. Test Results 18. End-to-End Verification Results 19. Errors Encountered 20. Errors Fixed 21. Known Limitations 22. External Dependencies 23. Environment Variables 24. Setup Instructions 25. Run Instructions 26. Deployment Instructions 27. Performance Considerations 28. Future Improvements 29. Overall Completion Assessment For every major feature, clearly classify its status as one of: - IMPLEMENTED - PARTIALLY IMPLEMENTED - MOCKED - NOT IMPLEMENTED - NOT VERIFIED Accuracy is critical. Do not claim that a feature works unless you actually implemented and verified it. For testing, report only tests that were actually executed. For deployment, report only deployment that was actually performed and verified. If something was impossible to verify because credentials, external services, or infrastructure were unavailable, explicitly state: "NOT VERIFIED — [reason]" Do not hide limitations. The FINAL_REPORT.md should provide enough technical detail for another developer to understand exactly what was built, what was tested, what worked, what failed, and what remains incomplete. FINAL DELIVERABLES Before finishing, ensure the project contains: - Complete source code - Working frontend - Working backend - Database implementation - AI/LLM integration - Authentication - PDF processing - Tests - README.md - .env.example - FINAL_REPORT.md Finally, provide a concise summary of: - What was built - What was successfully verified - What remains incomplete - Where the FINAL_REPORT.md file is located Prioritize correctness, functionality, maintainability, security, and honest verification over speed or visual polish.
Comments (0)
Sign in to leave a comment
Project Tasks
12Implement Identity Access
As a developer, I want to implement user authentication and secure access control to ensure only authorized users can access protected resources. Implementation contract: - Outcome: Implement Identity Access - Requirement sources: - src-2faa74adf0b7ab24 - src-70b13335b3de4889 - src-224131d7300ac40e - src-5860816231ca3113 - src-1b4384ed26cafc29 - src-335c01198ab1e969 - Owned behavior: - As a developer, I want to implement user authentication and secure access control to ensure only authorized users can access protected resources. - User registration - User login - JWT token generation - Access control - Provide authoritative application identity, session, and current-user access state. - Interfaces: - API endpoints for authentication - JWT token management - Provide identity.access.management: Provide authoritative application identity, session, and current-user access state. - State transitions: - User session creation - User session termination - Failure and safety behavior: - Invalid credentials - Expired tokens - Unauthorized access - Use authoritative session/current-user state, enforce access server-side, and fail closed without exposing prototype identity data. - Exchange responsibilities: - auth: produce, transport, authorize, handle_failure Acceptance criteria: - The task-owned behavior is implemented and verified without undeclared mocks or downstream assumptions. - Successful user registration - Successful login - Access control enforced - Capability identity.access.management implements Provide authoritative application identity, session, and current-user access state. and is verified through its declared interfaces.
Implement Shared Footer
As a Frontend Developer, implement the shared Footer component from its approved JSX/CSS design and reuse it across all declared pages without duplicating local variants. Implementation contract: - Outcome: Implement Shared Footer - Owned behavior: - As a Frontend Developer, implement the shared Footer component from its approved JSX/CSS design and reuse it across all declared pages without duplicating local variants. - Implement shared design sections: Footer. Acceptance criteria: - The task-owned behavior is implemented and verified without undeclared mocks or downstream assumptions. - The shared Footer component renders once and is reused by every declared consuming page.
Persist user data, resume metadata, and analysis results in PostgreSQL
Implement and verify the project capability `data.persistence` required by generated downstream tasks. Expose a stable implementation contract and satisfy every linked consumer without frontend mocks. Implementation contract: - Outcome: Persist user data, resume metadata, and analysis results in PostgreSQL - Requirement sources: - src-8955add56530c401 - src-37478d08e1edf16b - src-149bc802d85b8614 - Owned behavior: - Implement and verify the project capability `data.persistence` required by generated downstream tasks. Expose a stable implementation contract and satisfy every linked consumer without frontend mocks. - Implement and expose capability data.persistence. - Persist user data, resume metadata, and analysis results in PostgreSQL. - Interfaces: - Provide data.persistence. - Provide data.persistence: Persist user data, resume metadata, and analysis results in PostgreSQL. Acceptance criteria: - The task-owned behavior is implemented and verified without undeclared mocks or downstream assumptions. - Capability data.persistence has one active implementation owner and every declared consumer can use its verified interface. - Capability data.persistence implements Persist user data, resume metadata, and analysis results in PostgreSQL. and is verified through its declared interfaces.
Develop Backend API
As a developer, I want to develop a backend API to handle resume uploads, job description inputs, and analysis requests. Implementation contract: - Outcome: Develop Backend API - Requirement sources: - src-8955add56530c401 - src-37478d08e1edf16b - src-149bc802d85b8614 - src-4a06782c2b898d83 - src-2faa74adf0b7ab24 - src-70b13335b3de4889 - src-224131d7300ac40e - src-5860816231ca3113 - src-1b4384ed26cafc29 - src-335c01198ab1e969 - Owned behavior: - As a developer, I want to develop a backend API to handle resume uploads, job description inputs, and analysis requests. - Handle resume uploads - Process job descriptions - Initiate analysis - Provide backend API for resume analysis, user management, and data handling. - Interfaces: - API endpoints for resume and analysis - Provide backend.api: Provide backend API for resume analysis, user management, and data handling. - Consume identity.access.management: Provide authoritative application identity, session, and current-user access state. - State transitions: - Resume upload - Analysis initiation - Failure and safety behavior: - Invalid input - API failure - Exchange responsibilities: - upload_resume: produce, transport, persist, handle_failure - start_analysis: produce, transport, persist, handle_failure Acceptance criteria: - The task-owned behavior is implemented and verified without undeclared mocks or downstream assumptions. - API endpoints function correctly - Data is persisted - Capability backend.api implements Provide backend API for resume analysis, user management, and data handling. and is verified through its declared interfaces. - Capability identity.access.management implements Provide authoritative application identity, session, and current-user access state. and is verified through its declared interfaces.
Implement PDF Processing
As a developer, I want to implement PDF processing to extract text from uploaded resumes for analysis. Implementation contract: - Outcome: Implement PDF Processing - Requirement sources: - src-8955add56530c401 - src-37478d08e1edf16b - src-149bc802d85b8614 - src-2faa74adf0b7ab24 - src-70b13335b3de4889 - src-224131d7300ac40e - src-5860816231ca3113 - src-1b4384ed26cafc29 - src-335c01198ab1e969 - Owned behavior: - As a developer, I want to implement PDF processing to extract text from uploaded resumes for analysis. - Validate PDF - Extract text - Process and extract text from uploaded PDF resumes. - Interfaces: - PDF processing library - Provide pdf.processing: Process and extract text from uploaded PDF resumes. - Consume identity.access.management: Provide authoritative application identity, session, and current-user access state. - State transitions: - Text extraction - Failure and safety behavior: - Invalid PDF - Extraction failure Acceptance criteria: - The task-owned behavior is implemented and verified without undeclared mocks or downstream assumptions. - PDFs are processed correctly - Text is extracted - Capability pdf.processing implements Process and extract text from uploaded PDF resumes. and is verified through its declared interfaces. - Capability identity.access.management implements Provide authoritative application identity, session, and current-user access state. and is verified through its declared interfaces.
Integrate AI Service
As a developer, I want to integrate with the AI service to perform resume analysis and return structured results. Implementation contract: - Outcome: Integrate AI Service - Requirement sources: - src-8955add56530c401 - src-37478d08e1edf16b - src-149bc802d85b8614 - src-2faa74adf0b7ab24 - src-70b13335b3de4889 - src-224131d7300ac40e - src-5860816231ca3113 - src-1b4384ed26cafc29 - src-335c01198ab1e969 - Owned behavior: - As a developer, I want to integrate with the AI service to perform resume analysis and return structured results. - Send data to AI - Receive analysis results - Integrate with external AI service for resume analysis. - Interfaces: - LLM API - Provide ai.integration: Integrate with external AI service for resume analysis. - Consume identity.access.management: Provide authoritative application identity, session, and current-user access state. - State transitions: - Analysis request - Result retrieval - Failure and safety behavior: - API failure - Invalid response - Validate provider configuration and credentials, handle provider errors explicitly, and never report an unconfirmed external action as successful. - Web research: - RESEARCH BLOCKER: current official documentation could not be confirmed during planning. Resolve authentication/scopes, contracts, limits, retry/idempotency, sandbox support, and official source links before implementation. - Exchange responsibilities: - start_analysis: produce, transport, consume, handle_failure Acceptance criteria: - The task-owned behavior is implemented and verified without undeclared mocks or downstream assumptions. - AI integration functions correctly - Results are structured - Capability ai.integration implements Integrate with external AI service for resume analysis. and is verified through its declared interfaces. - Capability identity.access.management implements Provide authoritative application identity, session, and current-user access state. and is verified through its declared interfaces.
Implement Shared Navbar
As a Frontend Developer, implement the shared Navbar component from its approved JSX/CSS design and reuse it across all declared pages without duplicating local variants. Implementation contract: - Outcome: Implement Shared Navbar - Requirement sources: - src-8955add56530c401 - src-37478d08e1edf16b - src-149bc802d85b8614 - Owned behavior: - As a Frontend Developer, implement the shared Navbar component from its approved JSX/CSS design and reuse it across all declared pages without duplicating local variants. - Implement shared design sections: Navbar. - Interfaces: - Consume ai.integration: Integrate with external AI service for resume analysis. - Failure and safety behavior: - Use neutral loading, empty, anonymous, and error states; never use prototype data as a runtime fallback. Acceptance criteria: - The task-owned behavior is implemented and verified without undeclared mocks or downstream assumptions. - The shared Navbar component renders once and is reused by every declared consuming page. - Capability ai.integration implements Integrate with external AI service for resume analysis. and is verified through its declared interfaces.
Implement Landing page
As a Frontend Developer, implement the approved Landing page design and the task-owned sections below. Implementation contract: - Outcome: Implement Landing page - Requirement sources: - src-f543414628867181 - src-b1462f7c61944eca - src-8955add56530c401 - src-37478d08e1edf16b - src-149bc802d85b8614 - src-2faa74adf0b7ab24 - src-70b13335b3de4889 - src-224131d7300ac40e - src-5860816231ca3113 - src-1b4384ed26cafc29 - src-335c01198ab1e969 - Owned behavior: - interactive grid animation - feature card animations - responsive navigation - authentication-aware links - cursor-reactive CTA - Provide responsive and accessible UI for user interaction and data presentation. - Interfaces: - localStorage for auth token - window.location for pathname - Provide frontend.ui: Provide responsive and accessible UI for user interaction and data presentation. - Consume identity.access.management: Provide authoritative application identity, session, and current-user access state. - State transitions: - toggle menu open/close - update auth state on token change - Failure and safety behavior: - handle missing auth token gracefully Acceptance criteria: - The task-owned behavior is implemented and verified without undeclared mocks or downstream assumptions. - Landing page renders with LandingHero and LandingFeatures sections - Interactive grid and typography respond to cursor movements - Feature cards animate on scroll with staggered effects - Page accessible to all personas without login restrictions - Navbar renders with correct links based on auth state - CTA animates on hover - Mobile menu toggles correctly - Capability frontend.ui implements Provide responsive and accessible UI for user interaction and data presentation. and is verified through its declared interfaces. - Capability identity.access.management implements Provide authoritative application identity, session, and current-user access state. and is verified through its declared interfaces.
Implement Login page
As a Frontend Developer, implement the approved Login page design and the task-owned sections below. Implementation contract: - Outcome: Implement Login page - Requirement sources: - src-8955add56530c401 - src-37478d08e1edf16b - src-149bc802d85b8614 - src-4a06782c2b898d83 - src-2faa74adf0b7ab24 - src-70b13335b3de4889 - src-224131d7300ac40e - src-5860816231ca3113 - src-1b4384ed26cafc29 - src-335c01198ab1e969 - Owned behavior: - Toggle login/register mode - Enter email and password - Show/hide password - Submit form with validation - Display errors and feedback - Loading state during submission - Manage user authentication, registration, and secure access control. - Interfaces: - authentication endpoint - Provide identity.access: Manage user authentication, registration, and secure access control. - Consume identity.access.management: Provide authoritative application identity, session, and current-user access state. - State transitions: - mode switch - form submission - error display - Failure and safety behavior: - validation errors - server-side authentication errors Acceptance criteria: - The task-owned behavior is implemented and verified without undeclared mocks or downstream assumptions. - observable task-owned checks - Capability identity.access implements Manage user authentication, registration, and secure access control. and is verified through its declared interfaces. - Capability identity.access.management implements Provide authoritative application identity, session, and current-user access state. and is verified through its declared interfaces.
Implement Dashboard page
As a Frontend Developer, implement the approved Dashboard page design and the task-owned sections below. Implementation contract: - Outcome: Implement Dashboard page - Requirement sources: - src-b0b713be8facf938 - src-2a7550bd9bb414b5 - src-8877f576786430c4 - src-2faa74adf0b7ab24 - src-70b13335b3de4889 - src-224131d7300ac40e - src-5860816231ca3113 - src-1b4384ed26cafc29 - src-335c01198ab1e969 - Owned behavior: - Display personalized greeting - Show aggregate statistics - Navigate to new analysis - Interfaces: - localStorage - React hooks - Consume identity.access.management: Provide authoritative application identity, session, and current-user access state. - State transitions: - Retrieve userName from localStorage - Calculate totalAnalysesCount and highestMatchScore - Failure and safety behavior: - Fallback to default userName if localStorage is unavailable Acceptance criteria: - The task-owned behavior is implemented and verified without undeclared mocks or downstream assumptions. - DashboardHeader renders once on the Dashboard page - Greeting displays userName or 'Analyst' - Statistics reflect total analyses and highest match score - 'Start New Analysis' button navigates correctly - Design adheres to creative brief - Capability identity.access.management implements Provide authoritative application identity, session, and current-user access state. and is verified through its declared interfaces.
Implement DashboardAnalysesList section
As a Frontend Developer, implement the approved Dashboard page design and the task-owned sections below. Implementation contract: - Outcome: Implement DashboardAnalysesList section - Requirement sources: - src-8955add56530c401 - src-37478d08e1edf16b - src-149bc802d85b8614 - src-4a06782c2b898d83 - src-2faa74adf0b7ab24 - src-70b13335b3de4889 - src-224131d7300ac40e - src-5860816231ca3113 - src-1b4384ed26cafc29 - src-335c01198ab1e969 - Owned behavior: - Display list of analyses - Sort and filter analyses - Row-level actions - State transitions for loading, empty, and error states - Interfaces: - backend API for fetching and deleting analyses - Consume backend.api: Provide backend API for resume analysis, user management, and data handling. - Consume data.persistence: Persist user data, resume metadata, and analysis results in PostgreSQL. - Consume identity.access.management: Provide authoritative application identity, session, and current-user access state. - State transitions: - Loading to success - Loading to error - Success to empty - Failure and safety behavior: - Error state when analyses cannot be fetched Acceptance criteria: - The task-owned behavior is implemented and verified without undeclared mocks or downstream assumptions. - Render DashboardAnalysesList once - Display analyses with correct data - Correct sorting and filtering - Navigate to analysis results - Delete confirmation and execution - Proper state handling - Capability backend.api implements Provide backend API for resume analysis, user management, and data handling. and is verified through its declared interfaces. - Capability data.persistence implements Persist user data, resume metadata, and analysis results in PostgreSQL. and is verified through its declared interfaces. - Capability identity.access.management implements Provide authoritative application identity, session, and current-user access state. and is verified through its declared interfaces.
Implement New Analysis page
As a Frontend Developer, implement the approved New Analysis page design and the task-owned sections below. Implementation contract: - Outcome: Implement New Analysis page - Requirement sources: - src-ad16caaf05164512 - src-fdf5cd2d59771022 - src-8955add56530c401 - src-37478d08e1edf16b - src-149bc802d85b8614 - src-2faa74adf0b7ab24 - src-70b13335b3de4889 - src-224131d7300ac40e - src-5860816231ca3113 - src-1b4384ed26cafc29 - src-335c01198ab1e969 - Owned behavior: - visible and interactive behavior owned by these sections - Interfaces: - Consume pdf.processing: Process and extract text from uploaded PDF resumes. - Consume identity.access.management: Provide authoritative application identity, session, and current-user access state. Acceptance criteria: - The task-owned behavior is implemented and verified without undeclared mocks or downstream assumptions. - The 'New Analysis' page must render exactly once with the AnalysisPageHeader section visible. - The header must include the title 'NEW ANALYSIS', a descriptive subtitle, and guidance text as per the design contract. - The cursor-reactive glow must respond to mouse movements within the header. - The section must be accessible to authenticated 'Resume analyst user' personas only. - Capability pdf.processing implements Process and extract text from uploaded PDF resumes. and is verified through its declared interfaces. - Capability identity.access.management implements Provide authoritative application identity, session, and current-user access state. and is verified through its declared interfaces.
MEETTHE-ATS
Upload your resume, paste the job description, and let AI show you exactly where you match — and where you don’t.
PDF resume · Instant AI match score · Skills gap analysis
Everything Needed To Read Between The Lines
From upload to insight, the-ats handles the whole comparison pipeline so you can focus on what to fix.
Resume Upload & Processing
Drop in a PDF resume and the-ats securely extracts the raw text on the server, preparing it for structured comparison against any job description.
AI-Powered Analysis
An LLM reads the extracted resume text alongside the pasted job description, identifying overlaps and gaps a keyword scanner would miss.
Match Scoring & Insights
Every analysis returns a structured 0–100 match score plus matched skills, missing skills, and concrete resume improvements you can act on.
Secure & Private
Every account is isolated behind authenticated routes. Resumes, job descriptions, and analysis history stay tied to your login and no one else’s.
MEETTHE-ATS
Upload your resume, paste the job description, and let AI show you exactly where you match — and where you don’t.
PDF resume · Instant AI match score · Skills gap analysis
Everything Needed To Read Between The Lines
From upload to insight, the-ats handles the whole comparison pipeline so you can focus on what to fix.
Resume Upload & Processing
Drop in a PDF resume and the-ats securely extracts the raw text on the server, preparing it for structured comparison against any job description.
AI-Powered Analysis
An LLM reads the extracted resume text alongside the pasted job description, identifying overlaps and gaps a keyword scanner would miss.
Match Scoring & Insights
Every analysis returns a structured 0–100 match score plus matched skills, missing skills, and concrete resume improvements you can act on.
Secure & Private
Every account is isolated behind authenticated routes. Resumes, job descriptions, and analysis history stay tied to your login and no one else’s.
No comments yet. Be the first!