Build an AI Resume Analyzer with Amazon Bedrock

Learn how to build an AI-powered resume analyzer that extracts candidate information, identifies skills, compares a resume with a job description, and generates structured feedback using Amazon Bedrock and Python.

Apeksha Mulje

Published Sep 26, 2026

Last modified Sep 26, 2026

Build an AI Resume Analyzer with Amazon Bedrock

Description:
Learn how to build an AI-powered resume analyzer that extracts candidate information, identifies skills, compares a resume with a job description, and generates structured feedback using Amazon Bedrock and Python.

Introduction

Recruiters and job seekers often spend significant time reviewing resumes against job descriptions.

Generative AI can help automate parts of this process.

In this tutorial, we will build a simple AI Resume Analyzer using Amazon Bedrock, Python, and Streamlit.

The application will allow a user to provide a resume and job description, then generate structured analysis such as:

Candidate profile
Technical skills
Soft skills
Relevant experience
Matching skills
Missing or less-evidenced skills
Suggested resume improvements
Interview preparation areas

The goal is decision support, not automated hiring. AI-generated analysis can contain errors and should not be used as the sole basis for employment decisions.

What We Are Building

Our application will follow this workflow:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
Resume
   │
   ▼
Text Extraction
   │
   ├───────────────┐
   │               │
   ▼               ▼
Resume Text    Job Description
   │               │
   └───────┬───────┘
           ▼
     Prompt Creation
           │
           ▼
    Amazon Bedrock
           │
           ▼
   Structured Analysis
           │
           ▼
     Streamlit UI

Architecture

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
                  ┌──────────────────┐
                  │      User        │
                  └────────┬─────────┘
                           │
                  Upload Resume
                           │
                           ▼
                ┌─────────────────────┐
                │ Python Application  │
                │   + Streamlit       │
                └─────────┬───────────┘
                          │
                    Resume Text
                          │
                          ▼
                ┌─────────────────────┐
                │   Prompt Builder    │
                └─────────┬───────────┘
                          │
                          ▼
                ┌─────────────────────┐
                │   Amazon Bedrock    │
                │   Foundation Model  │
                └─────────┬───────────┘
                          │
                          ▼
                ┌─────────────────────┐
                │ Resume Analysis     │
                │ Structured Output   │
                └─────────────────────┘

Prerequisites

You will need:

AWS account
Amazon Bedrock access
Python 3.10+
AWS credentials configured
Boto3
Streamlit

Install the required packages:

1
pip install boto3 streamlit pypdf

Step 1: Create the Project

Create a project directory:

1
2
3
4
5
6
ai-resume-analyzer/
│
├── app.py
├── resume_analyzer.py
├── requirements.txt
└── README.md

Create requirements.txt:

1
2
3
boto3
streamlit
pypdf

Step 2: Extract Text From a Resume

If the resume is provided as a PDF, we can extract its text using pypdf.

Create resume_analyzer.py:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from pypdf import PdfReader

def extract_resume_text(file):

    reader = PdfReader(file)

    text = ""

    for page in reader.pages:
        page_text = page.extract_text()

        if page_text:
            text += page_text + "\n"

    return text

The function reads each page and combines the extracted text.

Step 3: Configure Amazon Bedrock

Add Boto3:

1
import boto3

Create a Bedrock Runtime client:

1
2
3
4
bedrock = boto3.client(
    "bedrock-runtime",
    region_name="us-east-1"
)

The region should be changed if the model you intend to use is available in another AWS Region.

Step 4: Create the Analysis Prompt

The quality of the analysis depends heavily on the information provided to the model.

We will provide:

Resume text
Job description
Clear analysis instructions

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
def create_prompt(resume_text, job_description):

    return f"""
You are an AI assistant helping a job seeker analyze
their resume against a job description.

Analyze the information carefully.

Do not invent qualifications, experience, certifications,
projects, or skills that are not present in the resume.

RESUME:
{resume_text}

JOB DESCRIPTION:
{job_description}

Provide the analysis using these sections:

1. Candidate Profile
2. Technical Skills
3. Soft Skills
4. Relevant Experience
5. Skills Clearly Supported by the Resume
6. Skills Mentioned in the Job Description but Not Clearly Evidenced
7. Resume Improvement Suggestions
8. Interview Preparation Topics

Clearly distinguish between information explicitly stated
in the resume and suggestions generated from the comparison.

Do not make hiring decisions.
"""

Step 5: Send the Request to Amazon Bedrock

We can use the Bedrock Converse API.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
def analyze_resume(resume_text, job_description):

    prompt = create_prompt(
        resume_text,
        job_description
    )

    response = bedrock.converse(
        modelId="YOUR_MODEL_ID",
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "text": prompt
                    }
                ]
            }
        ],
        inferenceConfig={
            "maxTokens": 2000,
            "temperature": 0.2
        }
    )

    return response[
        "output"
    ][
        "message"
    ][
        "content"
    ][0]["text"]

Replace:

1
YOUR_MODEL_ID

with the model ID available to your AWS account and selected Region.

Step 6: Create the Streamlit Application

Create app.py:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
import streamlit as st

from resume_analyzer import (
    extract_resume_text,
    analyze_resume
)

st.set_page_config(
    page_title="AI Resume Analyzer",
    page_icon="📄"
)

st.title("📄 AI Resume Analyzer")

st.write(
    "Analyze a resume against a job description "
    "using Amazon Bedrock."
)

resume_file = st.file_uploader(
    "Upload your resume",
    type=["pdf"]
)

job_description = st.text_area(
    "Paste the job description",
    height=250
)

if st.button("Analyze Resume"):

    if resume_file is None:

        st.warning(
            "Please upload a resume."
        )

    elif not job_description.strip():

        st.warning(
            "Please enter a job description."
        )

    else:

        with st.spinner(
            "Analyzing resume..."
        ):

            resume_text = extract_resume_text(
                resume_file
            )

            result = analyze_resume(
                resume_text,
                job_description
            )

        st.subheader(
            "Resume Analysis"
        )

        st.write(result)

Step 7: Run the Application

Open your terminal inside the project directory.

Run:

1
streamlit run app.py

Streamlit will provide a local address such as:

1
http://localhost:8501

Open it in your browser.

Example

Suppose the job description says:

1
2
3
4
5
We are looking for a Data Scientist with experience in
Python, SQL, machine learning, statistics, and data
visualization.

Experience with AWS is preferred.

The resume might contain:

1
2
3
4
5
6
7
8
9
10
Skills:
Python
SQL
Machine Learning
Statistics
Power BI

Projects:
Customer Churn Prediction
Sales Data Analysis

The AI could organize the result as:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
Candidate Profile
Data-focused candidate with experience in Python,
SQL, machine learning and data analysis.

Clearly Supported Skills
- Python
- SQL
- Machine Learning
- Statistics
- Data Visualization

Less-Evidenced Job Requirements
- AWS experience

Relevant Projects
- Customer Churn Prediction
- Sales Data Analysis

Suggested Improvements
- Add measurable outcomes to project descriptions.
- Highlight relevant machine learning techniques.
- Include AWS experience if genuinely acquired.

Interview Preparation
- Python
- SQL
- Machine Learning
- Statistics
- Data Visualization
- AWS fundamentals

Notice that the application should not claim that the candidate has AWS experience if the resume does not provide evidence of it.

Making the Output Structured

Instead of returning plain text, we can ask the model to return JSON.

For example:

1
2
3
4
5
6
7
8
9
10
11
12
Return valid JSON using this structure:

{
  "candidate_profile": "",
  "technical_skills": [],
  "soft_skills": [],
  "relevant_experience": [],
  "supported_skills": [],
  "missing_or_unclear_skills": [],
  "resume_improvements": [],
  "interview_topics": []
}

Structured output makes it easier for the application to display each section separately.

For example:

1
2
3
4
st.subheader("Technical Skills")

for skill in result["technical_skills"]:
    st.write("•", skill)

This is more useful than displaying one large block of text.

Adding an ATS-Oriented Analysis

A useful extension is to identify important terms from the job description and determine whether the resume provides evidence for them.

For example:

1
2
3
4
5
6
7
8
Job Requirement        Resume Evidence
----------------------------------------
Python                 ✓
SQL                    ✓
Machine Learning       ✓
AWS                    ?
Power BI               ✓
Docker                 ✗

However, this should be presented as evidence matching, not as an authoritative ATS score.

Avoid creating a misleading statement such as:

1
Your resume has an 87% chance of passing ATS.

A real employer's screening system may use different rules, and an AI-generated score cannot establish actual hiring outcomes.

Improving the Application

The basic application can be extended with several useful features.

1. Resume Improvement Assistant

Add a button:

1
Improve My Resume

The model can suggest clearer bullet points while preserving factual information.

For example:

Original

1
Worked on a machine learning project.

Improved

1
2
3
Developed a machine learning project using Python
to analyze structured data and evaluate predictive
model performance.

The application should never add technologies, metrics, responsibilities, or achievements that the candidate did not actually have.

2. Job Description Analyzer

The application can extract:

Required skills
Preferred skills
Experience requirements
Education requirements
Tools and technologies
Responsibilities

This gives the user a clearer understanding of the position before applying.

3. Interview Preparation

The application could generate questions based on the actual evidence in the resume.

For example:

1
2
3
4
5
6
7
8
9
10
11
Python Questions
1. Explain list comprehension.
2. What is the difference between a list and tuple?

SQL Questions
1. Explain INNER JOIN.
2. What is GROUP BY?

Machine Learning Questions
1. Explain overfitting.
2. How would you evaluate a classification model?

4. Resume Privacy

Resume files contain personal information.

A production application should therefore carefully consider:

Data retention
Access control
Encryption
Logging
Data deletion
IAM permissions
Personally identifiable information

Avoid logging complete resumes or unnecessarily storing uploaded documents.

5. Human Review

The AI should act as an assistant, not the final decision-maker.

A useful workflow is:

1
2
3
4
5
6
7
8
9
Resume
   ↓
AI Analysis
   ↓
Evidence Review
   ↓
Candidate Verification
   ↓
Final Resume Changes

The candidate should verify every suggested change before using it.

Responsible AI Considerations

Resume analysis involves employment-related information, so responsible implementation matters.

The system should:

Avoid fabricating information

Never turn:

1
"I know basic Python"

into:

1
"Expert Python developer"

Avoid unsupported conclusions

The system should not claim:

1
"This candidate will succeed in the role."

Instead, it can say:

1
2
3
"The resume provides evidence of Python and SQL
experience relevant to requirements listed in the
job description."

Protect personal information

Resumes may contain:

Names
Email addresses
Phone numbers
Addresses
Education details
Employment history

Handle this information carefully.

Possible AWS Architecture

A more advanced production architecture could look like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
                 ┌───────────────┐
                 │     User      │
                 └───────┬───────┘
                         │
                         ▼
                ┌─────────────────┐
                │  Web Interface  │
                └────────┬────────┘
                         │
                         ▼
                ┌─────────────────┐
                │ Amazon S3       │
                │ Resume Storage  │
                └────────┬────────┘
                         │
                         ▼
                ┌─────────────────┐
                │ Processing Layer│
                └────────┬────────┘
                         │
                         ▼
                ┌─────────────────┐
                │ Amazon Bedrock  │
                └────────┬────────┘
                         │
                         ▼
                ┌─────────────────┐
                │ Structured      │
                │ Resume Analysis │
                └─────────────────┘

Additional AWS services could be introduced depending on the application's requirements.

Project Structure

1
2
3
4
5
6
ai-resume-analyzer/
│
├── app.py
├── resume_analyzer.py
├── requirements.txt
└── README.md

Future Improvements

The project can be extended to support:

DOCX resumes
Multiple resumes
Multiple job descriptions
Resume comparison
Skill-gap analysis
Interview question generation
Resume rewriting
Job-description summarization
Structured JSON output
Secure cloud storage
Authentication
Audit logging

What We Built

In this project, we created an AI-powered resume analysis workflow using:

1
2
3
4
5
6
7
8
9
Python
   +
Streamlit
   +
Amazon Bedrock
   +
Prompt Engineering
   +
PDF Processing

The application transforms a traditional resume review workflow into an interactive AI-assisted analysis tool.

Conclusion

Generative AI can help candidates understand how their resumes relate to specific job descriptions, identify skills that are clearly evidenced, and find areas where additional information or clarification may be useful.

With Amazon Bedrock, developers can integrate foundation models into applications without building a foundation model from scratch.

The key principle is simple:

Use AI to assist resume analysis, but keep factual verification and employment decisions with people.

This project can also be extended into a larger AI Career Assistant capable of analyzing resumes, job descriptions, skills, and interview preparation in one workflow.

Like comment and reply to comment.

# aws-student-builders-groups # amazon-bedrock # career

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

Builder Center

Build an AI Resume Analyzer with Amazon Bedrock

Apeksha Mulje

Build an AI Resume Analyzer with Amazon Bedrock

Introduction

What We Are Building

Architecture

Prerequisites

Step 1: Create the Project

Step 2: Extract Text From a Resume

Step 3: Configure Amazon Bedrock

Step 4: Create the Analysis Prompt

Step 5: Send the Request to Amazon Bedrock

Step 6: Create the Streamlit Application

Step 7: Run the Application

Example

Making the Output Structured

Adding an ATS-Oriented Analysis

Improving the Application

1. Resume Improvement Assistant

2. Job Description Analyzer

3. Interview Preparation

4. Resume Privacy

5. Human Review

Responsible AI Considerations

Avoid fabricating information

Avoid unsupported conclusions

Protect personal information

Possible AWS Architecture

Project Structure

Future Improvements

What We Built

Conclusion