AWS Builder Center
Weekend Creative Challenge: JobLens AI — From Resume to Interview-Ready

Weekend Creative Challenge: JobLens AI — From Resume to Interview-Ready

JobLens AI is an AI-powered career intelligence and interview preparation platform that analyzes a resume against a target job description, identifies verified strengths and skill gaps, creates a personalized preparation roadmap, generates role-specific interview questions, and provides real-time AI feedback through an interactive interview coach. Built with React, FastAPI, Amazon Bedrock, Amazon Nova 2 Lite, AWS Lambda, API Gateway, and AWS Amplify.

ECE Student | AI, IoT & Software Developer
“The goal is not to tell candidates whether they are qualified. The goal is to show them how they can become better prepared.”
Job searching often creates a frustrating gap between a candidate's understanding of their own experience and the requirements of a specific role. A resume may contain strong technical skills, but it can still be difficult to determine how closely those skills align with a particular job description, which requirements need more preparation, and whether the candidate is ready for the interview that follows.
That gap inspired me to build JobLens AI, an AI-powered career intelligence and interview preparation platform developed as part of the AWS Weekend Creative Challenge.
The application takes a candidate's resume and a target job description and transforms them into a structured, actionable preparation plan. Rather than providing only a generic resume summary or a simple match percentage, JobLens AI helps candidates understand their current position, identify areas requiring preparation, and practice role-specific interview questions with AI-generated feedback.



The Vision

The central idea behind JobLens AI is straightforward:
Turn job-search uncertainty into an actionable preparation journey.
A candidate begins with two pieces of information:
  • Their resume
  • The job description they are targeting
JobLens AI analyzes these inputs and produces a structured career intelligence report containing:
  • Compatibility score
  • Match category
  • Executive summary
  • Matching skills
  • Skill gaps
  • Strengths and weaknesses
  • Important job requirements
  • Priority gaps
  • Five-day preparation roadmap
  • Technical interview questions
  • Resume-based interview questions
  • Behavioral questions
  • Job-specific questions
This creates a progression from analysis to preparation:
Resume + Job Description ↓ Job Fit Analysis ↓ Skill Gaps ↓ Priority Preparation ↓ 5-Day Roadmap ↓ Interview Questions ↓ AI Interview Coach ↓ Personalized Feedback
The objective is not simply to answer “Do I match this job?”
It is to answer the more useful question:
“What should I do next to become better prepared for this opportunity?”



From Career Analysis to Interview Preparation

One of the key features of JobLens AI is its interactive AI Interview Coach.
After the initial job analysis, the application generates interview questions based on the target role and the candidate's resume.
Candidates can select a question, submit their own answer, and receive an AI evaluation.
The answer is evaluated across four dimensions:

Relevance

Does the response directly address the interviewer's question?

Technical Depth

Does the candidate demonstrate accurate technical knowledge and an appropriate understanding of the subject?

Clarity and Structure

Is the response organized, understandable, and concise?

Completeness

Does the answer cover important considerations such as trade-offs, security, scalability, edge cases, and practical implementation?
The candidate receives:
  • Overall score
  • Detailed score breakdown
  • What was done well
  • What was missing
  • How to improve
  • An exemplary model answer
This creates an important feedback loop.
Instead of simply reading interview questions, candidates can practice, receive feedback, and try again.
“Knowing what to improve is valuable. Knowing how to improve it is even more valuable.”



Development Journey

I intentionally developed JobLens AI in phases so that every major component could be validated before adding the next layer.

Phase 1: Product Foundation and User Experience

The first phase focused on creating the application experience using React, Vite, TypeScript, and modern CSS.
I built the initial interface around the candidate workflow, including resume upload, job-description input, analysis results, skill visualization, preparation roadmap, and interview questions.
The objective was to create an experience that felt like a career intelligence dashboard rather than a conventional form-based application.



Phase 2: Document Processing and Backend

The next step was creating the application backend using Python and FastAPI.
The backend handles document processing, validation, text extraction, and communication with the frontend.
For PDF resumes, I used  pypdf  to extract text in memory.
The backend exposes three primary endpoints:
GET /api/healthPOST /api/analyzePOST /api/interview/evaluate
Input validation and structured responses were introduced at this stage to provide a reliable foundation for the AI layer.



Phase 3: Amazon Bedrock and Structured AI Analysis

The third phase introduced the intelligence behind JobLens AI.
I integrated Amazon Bedrock using Boto3 and the Bedrock Converse API, with Amazon Nova 2 Lite as the foundation model.
The production inference profile is:
us.amazon.nova-2-lite-v1:0
The application runs the Bedrock integration in the  us-east-1  AWS Region.
A major engineering decision was to avoid treating generative AI output as arbitrary text.
Instead, the application defines structured Pydantic schemas for the expected AI response.
The model generates structured information that the backend validates before sending it to the React frontend.
This makes the AI layer considerably more reliable for a production-style application because the frontend can work with predictable fields instead of attempting to interpret free-form model responses.



Evidence-Based AI Design

Another important part of the implementation was prompt design.
JobLens AI is instructed to distinguish between:
skills explicitly demonstrated by the resume
and
skills that are not evidenced in the resume.
For example, if a resume does not mention Docker, the system should not automatically conclude that the candidate does not know Docker.
Instead, it reports that Docker experience was not evidenced in the provided resume.
This distinction is important because a resume is not a complete representation of everything a person knows.
The system prompt also instructs the model not to evaluate candidates using protected characteristics such as age, gender, ethnicity, religion, or disability.
The goal is to keep the analysis focused on the relationship between the candidate's documented experience and the requirements of the role.
“A missing keyword is not necessarily a missing ability.”



Phase 4: Building the AI Interview Coach

Once the career analysis pipeline was stable, I extended the system into an interactive interview experience.
The new interview endpoint receives the candidate's question and answer, sends the relevant information to Amazon Bedrock, and returns structured evaluation results.
The frontend presents the feedback through an interactive coaching interface.
Candidates can:
  1. Read the role-specific question.
  1. Review the optional hint.
  1. Write their answer.
  1. Submit it for evaluation.
  1. Review the score breakdown.
  1. Understand what they did well.
  1. Identify missing points.
  1. Read improvement recommendations.
  1. Compare their response with an exemplary answer.
  1. Continue to the next question.
This changed JobLens AI from a static analysis application into an interactive preparation platform.



Phase 5: Deploying the Application on AWS

The final stage focused on taking the application from local development to a production AWS environment.
The resulting architecture is:
USER | | HTTPS v +--------------------+ | AWS Amplify | | React + Vite | +---------+----------+ | | HTTPS API v +--------------------+ | Amazon API | | Gateway | +---------+----------+ | v +--------------------+ | AWS Lambda | | FastAPI + Mangum | +---------+----------+ | | Boto3 | Converse API v +--------------------+ | Amazon Bedrock | | Amazon Nova 2 Lite | +--------------------+

AWS Amplify

The React/Vite frontend is hosted using AWS Amplify.
Amplify connects to the GitHub repository and builds the frontend application for production.
The deployed application is available at:



Amazon API Gateway

The backend is exposed through Amazon API Gateway using an HTTPS endpoint.
Production API:
The frontend communicates with this API using the  VITE_API_BASE_URL  environment variable.
This keeps the API configuration separate from the application source code.



AWS Lambda

The FastAPI backend runs inside AWS Lambda.
I used Mangum to adapt the FastAPI ASGI application to Lambda.
The deployed function is:
joblens-ai-backend
The Lambda function uses its execution role to access AWS services rather than storing AWS access keys inside the application.
This means there are no AWS credentials embedded in the frontend or source code.



Amazon Bedrock

Amazon Bedrock provides the generative AI capability for JobLens AI.
The same AI infrastructure powers both major intelligence workflows:
Career Analysis +Interview Evaluation ↓Amazon Bedrock ↓Amazon Nova 2 Lite
This allowed me to build both features around a consistent AI architecture.



Testing and Validation

A major part of the project was making sure that the application worked beyond the visual interface.
The backend test suite reached:
12/12 tests passing
The tests covered:
  • Text cleaning
  • Health endpoint
  • Prompt generation
  • JSON extraction
  • Pydantic schema validation
  • Analysis endpoint
  • Interview evaluation
  • Input validation
  • Bedrock mocking
  • Lambda handler integration
The frontend production build completed with:
0 TypeScript compilation errors
I also performed live verification of the deployed architecture.
The API Gateway endpoint successfully reached Lambda, Lambda successfully executed the FastAPI application, and the backend was able to communicate with Amazon Bedrock.
Finally, the React frontend was deployed through AWS Amplify and connected to the production API.



Challenges and How I Solved Them

Building the application locally was only one part of the challenge.
Moving it into a cloud environment introduced several new considerations.

Challenge 1: Running Python dependencies inside Lambda

The development environment was Windows, while AWS Lambda runs on a Linux execution environment.
Simply uploading the local Windows virtual environment would not be reliable.
To solve this, I created a Lambda deployment package with dependencies built specifically for the target Python 3.12 Linux x86_64 environment.

Challenge 2: Handling unpredictable AI responses

Generative AI models can return different textual structures.
Instead of depending on exact natural-language formatting, I designed structured output schemas and validated the AI response using Pydantic.

Challenge 3: Separating development and production configuration

The local frontend needs to communicate with the local FastAPI server, while the production frontend needs to communicate with API Gateway.
I solved this using environment-based configuration:
VITE_API_BASE_URL
This allowed the same application codebase to support both environments.

Challenge 4: Secure AWS authentication

Rather than putting AWS access keys into the project, the Lambda function uses its AWS execution role to communicate with Bedrock.
This keeps credentials outside the application code.



What I Learned

The most valuable lesson from this challenge was understanding how individual technologies combine into a complete application.
I started with a React interface and gradually transformed it into a cloud-hosted AI application.
Along the way, I gained practical experience with:
  • React and TypeScript
  • Python and FastAPI
  • PDF document processing
  • Pydantic validation
  • Boto3
  • Amazon Bedrock
  • Amazon Nova 2 Lite
  • Bedrock Converse API
  • AWS Lambda
  • Amazon API Gateway
  • AWS Amplify
  • GitHub-based deployment
  • Environment-based configuration
  • Serverless architecture
I also learned that building AI applications requires more than simply calling a model.
The surrounding engineering matters just as much:
input validation, structured outputs, error handling, security, deployment, testing, and user experience all contribute to the final product.



The Result

What started as a simple idea evolved into a complete career preparation workflow.
CANDIDATE | v Resume + Job Description | v JobLens AI Analysis | +--------+--------+ | | v v Skill Gaps Strengths | | +--------+--------+ | v 5-Day Preparation Plan | v Role-Specific Questions | v AI Interview Coach | v Answer Evaluation | v Personalized Feedback | v IMPROVEMENT
The application is now publicly available and running on AWS.

Try the Application

Live Application
GitHub Repository
GitHub Profile



Final Reflection

The AWS Weekend Creative Challenge gave me an opportunity to take an everyday problem and approach it as a complete engineering problem.
The project was not simply about generating AI text.
It was about designing a useful experience around AI.
It was about turning unstructured information into structured insight, turning that insight into a preparation plan, and then giving the candidate a way to practice and improve.
The final journey is simple:
Understand your fit. Identify your gaps. Prepare strategically. Practice deliberately. Improve continuously.
That is the idea behind JobLens AI.
And after moving through development, testing, AWS integration, and deployment, the project has gone from an idea on a development machine to a live application running on AWS.
“The best career advice is not simply knowing where you stand. It is knowing what to do next.”
JobLens AI is built to help with that next step.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article