
Building a Graph-Grounded Career Agent with Amazon Bedrock and AWS
Learn how we built an evidence-grounded career agent using Amazon Bedrock, FalkorDB, AWS services, and LaTeX to match job descriptions, tailor resumes, detect skill gaps, and trace generated claims back to real candidate evidence.
Building a Graph-Grounded Career Agent with Amazon Bedrock and AWS
How we use a knowledge graph, evidence retrieval, and grounded generation to turn a GitHub profile and job description into an explainable, job-specific resume.
The Problem
If you have used an AI coding agent in the last few years, you have probably seen how quickly it can turn an idea into working code.
We wanted to apply the same principle to another developer workflow: understanding whether a candidate actually fits a job, and tailoring their resume accordingly.
The challenge is that resume generation is not simply a writing problem.
A job description may ask for Python, AWS, Kubernetes, SQL, and machine learning. A candidate may have strong evidence for Python, AWS, and machine learning, but no evidence for Kubernetes.
A conventional keyword-based system can identify the overlap. A generative AI system can rewrite the resume.
But there is a more important question:
What evidence supports each claim in the generated resume?
That question led us to build Graph-Grounded Career Agent.
The core idea is straightforward:
Let AI decide how to communicate the candidate's experience, but never let AI decide what the candidate has experienced.
The candidate's knowledge graph is the source of truth.
What We Built
Graph-Grounded Career Agent is an AI-powered career intelligence system that connects:
- Candidate profiles and GitHub projects
- A structured career knowledge graph
- Real job descriptions
- Skill normalization and matching
- Evidence retrieval
- Amazon Bedrock
- Grounded resume generation
- Validation
- Deterministic LaTeX rendering
The user-facing experience starts with a simple interaction: provide a GitHub profile or username and ingest the candidate's profile.
From there, the system builds an evidence-backed representation of the candidate and uses it to evaluate job requirements.
The high-level flow is:
Candidate Profile / GitHub
│
▼
Profile Ingestion
│
▼
Career Knowledge Graph
│
│
Job Description ────────┐
│ │
▼ ▼
Job Analyzer → Skill Matching
│
▼
Evidence Retrieval
│
▼
Resume Tailoring
Amazon Bedrock
│
▼
Grounding Validator
│
▼
Resume JSON
│
▼
LaTeX Renderer
│
▼
PDF ResumeThis separation is important because each component has a different responsibility.
How It Works
1. Ingest the Candidate
The first step is to create a structured representation of the candidate.
The system can use information such as:
- GitHub repositories
- Projects
- Technologies
- Experience
- Education
- Existing resume information
- Other verified technical evidence
Rather than storing everything as a flat list, we connect the information through a knowledge graph.
For example:
Candidate
│
├── HAS_SKILL ──→ Python
│
├── BUILT ──────→ ML API
│ │
│ ├── USES → Python
│ ├── USES → AWS
│ └── USES → FastAPI
│
└── BUILT ──────→ Computer Vision Project
│
└── USES → OpenCVThis gives us more context than simply storing:
Python
AWS
FastAPI
OpenCVThe graph tells us where and how those skills were demonstrated.
2. Analyze the Job Description
The next step is to understand what the target role actually requires.
We use an AI-powered Job Analyzer to convert an unstructured job description into structured information.
For example:
Machine Learning Engineer
Required:
- Python
- Machine Learning
- SQL
- AWS
Preferred:
- Kubernetes
- DockerThe analyzer produces structured job data containing:
- Job title
- Required skills
- Preferred skills
- Responsibilities
- Technologies
- Skill importance
This structured representation becomes the input to the matching layer.
3. Normalize Skills Before Matching
Skill names are rarely consistent.
A job description may say:
Amazon Web Services
AWS
AWS Cloudwhile a GitHub repository might mention:
boto3
Lambda
S3We therefore normalize skills into canonical concepts before matching.
The goal is not to treat every related technology as automatically equivalent.
Instead, normalization gives the system a consistent vocabulary so that relationships can be evaluated correctly.
The result might look like:
Job Requirements
│
├── Python → MATCH
├── Machine Learning→ MATCH
├── AWS → MATCH
├── SQL → MATCH
└── Kubernetes → GAPAt this point, we know what matches.
We still need to know why it matches.
4. Retrieve Evidence from the Knowledge Graph
This is where the graph becomes more important than simple keyword matching.
Suppose the job requires AWS.
Instead of telling the model:
Candidate has AWSwe retrieve the evidence behind that statement.
For example:
{
"evidence_id": "EV001",
"skill": "AWS",
"project_id": "P004",
"project_name": "Cloud ML API",
"source_type": "github",
"description": "AWS Lambda used for backend deployment",
"source_url": "https://github.com/example/project"
}Now the generation model has a factual boundary.
It knows:
AWS
↓
Cloud ML API
↓
AWS Lambda
↓
GitHub evidenceWe do not need to send the entire candidate graph to the model.
Instead, we retrieve a job-specific evidence context containing the information relevant to the current application.
This reduces unnecessary context and makes the grounding boundary explicit.
5. Tailor the Resume with Amazon Bedrock
Once the relevant evidence has been retrieved, the Resume Tailoring Agent receives:
- Candidate information
- Job information
- Matched skills
- Skill gaps
- Relevant projects
- Relevant experience
- Evidence identifiers
The model can then make presentation decisions.
For example, it can:
- Prioritize skills required by the job
- Reorder projects
- Rewrite project bullets
- Improve wording
- Highlight relevant experience
- Remove less relevant content
But there is an important restriction:
The model can rewrite facts. It cannot create facts.
For example, if the candidate has evidence for Python and AWS, the model can write:
Built a machine learning API using Python and AWS Lambda.
But if the job also requires Kubernetes and the candidate has no Kubernetes evidence, the model must not write:
Deployed the application using Kubernetes.
Instead:
Kubernetes → Skill GapThis distinction is the core of the system.
6. Every Generated Claim Has Evidence
We wanted generated content to be traceable.
Therefore, the internal resume representation associates generated bullets with evidence identifiers.
For example:
{
"text": "Built a machine learning API using Python and AWS Lambda.",
"evidence_ids": [
"EV001",
"EV004"
]
}This allows the application to answer:
Resume Bullet
↓
Evidence ID
↓
Project
↓
Skill
↓
SourceInstead of asking users to simply trust an AI-generated statement, the system can show where that statement came from.
7. Validate Before Generating the PDF
We do not send generated content directly to the document renderer.
There is an intermediate validation step.
The workflow is:
Resume JSON
│
▼
Grounding Validator
│
├── Valid ──────→ Render
│
└── Invalid ────→ Regenerate / RejectThe validator checks whether claims are supported by the candidate context.
For example:
Generated claim:
"Kubernetes-based deployment on AWS"
Available evidence:
✓ AWS
✓ Machine Learning
✗ KubernetesThe claim should fail validation.
This is especially important because job descriptions contain strong signals that can influence a language model's generation.
A technology being required by the job does not mean the candidate has that technology.
Our design therefore follows:
Retrieve → Generate → Validate → Render
8. Why We Generate JSON Before LaTeX
Another important architectural decision was to separate content generation from document formatting.
We do not ask the LLM to generate the final LaTeX document.
Instead, the model produces structured Resume JSON.
For example:
{
"project": "Cloud ML API",
"technologies": [
"Python",
"AWS"
],
"bullets": [
{
"text": "Built a machine learning API using Python and AWS.",
"evidence_ids": [
"EV001",
"EV004"
]
}
]
}A deterministic renderer then converts this structure into our LaTeX template.
This gives us:
- Consistent formatting
- Easier debugging
- Stable document structure
- Better validation
- Separation of concerns
- Multiple template possibilities in the future
The division of responsibility becomes:
Knowledge Graph
↓
Facts
Amazon Bedrock
↓
Communication
LaTeX Renderer
↓
Presentation
9. The Rendering Pipeline
The resume template remains controlled by the application.
For example:
\section{Education}
{{EDUCATION}}
\section{Experience}
{{EXPERIENCE}}
\section{Projects}
{{PROJECTS}}
\section{Technical Skills}
{{SKILLS}}
\section{Achievements}
{{ACHIEVEMENTS}}The renderer fills these sections using validated Resume JSON.
The
.tex document is then compiled into a PDF.This means the model decides what should be included, while the renderer decides how it should look.
That separation also makes it easier to change the visual design without changing the AI generation pipeline.
10. AWS Architecture
AWS services provide the infrastructure for the different stages of the application.
A simplified architecture looks like this:
┌─────────────────────┐
│ Candidate / GitHub │
└──────────┬──────────┘
│
▼
Profile Ingestion
│
▼
┌─────────────────────┐
│ Career Knowledge │
│ Graph │
└──────────┬──────────┘
│
│ Evidence
▼
Job Sources ──→ Job Analyzer Agent
│
▼
Skill Matching
│
▼
Evidence Retrieval
│
▼
Resume Tailoring Agent
Amazon Bedrock
│
▼
Grounding Validator
│
▼
Resume JSON
│
▼
LaTeX Renderer
│
▼
PDFThe broader AWS architecture can include:
- Amazon Bedrock for generative AI
- AWS Lambda for serverless processing
- AWS Step Functions for workflow orchestration
- Amazon S3 for documents and generated artifacts
- Amazon Textract for extracting resume content
- Amazon SQS for decoupling ingestion workloads
- Amazon API Gateway for application APIs
- Amazon Cognito for authentication
- Amazon CloudWatch for logging and observability
- AWS Amplify Hosting for the frontend
The important point is not simply the number of AWS services.
Each service has a specific responsibility in the pipeline.
11. Orchestrating the Workflow
The pipeline contains several dependent stages.
For a production-oriented implementation, AWS Step Functions can coordinate the workflow:
Ingest
↓
Extract
↓
Normalize
↓
Write Graph
↓
Analyze Job
↓
Match Skills
↓
Retrieve Evidence
↓
Generate Resume
↓
Validate
↓
Render PDFThis structure gives individual stages clear boundaries and provides a natural place for retries and failure handling.
12. An End-to-End Example
Consider a candidate with:
Python
Machine Learning
AWS
SQL
ReactThe target job requires:
Python
Machine Learning
AWS
SQL
KubernetesThe system produces:
Matched Skills
✓ Python
✓ Machine Learning
✓ AWS
✓ SQL
Skill Gap
✗ KubernetesThe graph then retrieves projects demonstrating the matched skills.
The Resume Tailoring Agent can prioritize those projects and rewrite their descriptions for the target role.
It can produce:
Built a machine learning application using Python and AWS.
But it cannot add:
Deployed the application using Kubernetes.
unless Kubernetes is supported by candidate evidence.
The job requirement influences relevance.
The knowledge graph determines truth.
13. Making the Resume Explainable
One of the design goals was to make the generated resume inspectable.
Imagine a user sees:
Built a machine learning API using Python and AWS Lambda.
The application can trace that statement to:
Resume Bullet
↓
EV001
↓
Cloud ML API
↓
AWS Lambda
↓
GitHub EvidenceThis creates a useful feedback loop between the generated document and the underlying candidate profile.
It also gives us a foundation for features such as:
- "Why was this project selected?"
- "Why was this skill included?"
- "Show the evidence for this bullet."
- "Which job requirement does this project satisfy?"
14. From Resume Tailoring to Skill Gaps
The same matching pipeline can identify what is missing.
For example:
Job requires:
Python
AWS
Machine Learning
Kubernetes
Candidate evidence:
Python
AWS
Machine Learning
Detected gap:
KubernetesThis information can be surfaced separately from the resume.
A future version could use these gaps to recommend small, realistic projects.
For example:
Existing skills:
Python + AWS + Machine Learning
Potential project:
Containerize an ML API and deploy it
using Kubernetes.The important distinction is that this is a learning recommendation, not a claim about existing experience.
15. Engineering Challenges
Skill normalization
The same technology can appear under different names across job descriptions, resumes, and repositories.
Canonical skill normalization is therefore important for reliable matching.
Evidence granularity
A candidate having "AWS" in a skill list tells us very little.
Knowing that AWS Lambda was used in a specific project gives us much stronger evidence.
Grounding
The target job can strongly influence the language model.
Without explicit constraints, a model may turn a job requirement into an unsupported candidate claim.
Graph retrieval, evidence identifiers, strict generation rules, and validation address this problem together.
Document generation
Letting a language model control the entire LaTeX document creates unnecessary variability.
A deterministic renderer gives the application control over formatting and layout.
16. Design Principles
The architecture is built around three principles.
Retrieve Before Generating
Relevant candidate evidence is retrieved before the model generates resume content.
Separate Facts from Language
The knowledge graph stores facts.
The model determines how those facts should be communicated.
Validate Before Publishing
Generated content must pass grounding validation before it becomes the final resume.
Together:
Retrieve
↓
Generate
↓
Validate
↓
RenderThis is the foundation of the system.
17. What We Would Build Next
The current architecture provides a foundation for a broader career intelligence system.
Living Career Graph
The candidate graph could continuously incorporate:
- New GitHub repositories
- Projects
- Certifications
- Internships
- Hackathons
- Coursework
- Technical achievements
Instead of treating the resume as the primary profile, the graph becomes the continuously updated source of candidate evidence.
Multi-Job Intelligence
The same graph could be matched against many job descriptions to identify:
- Frequently requested skills
- Repeated skill gaps
- Projects relevant to multiple roles
- Technologies worth learning next
Personalized Skill Development
Detected gaps could be connected to targeted micro-project recommendations based on skills the candidate already has.
Evidence-Aware Cover Letters
The same retrieval and validation architecture can be extended to cover letters so that major claims remain connected to candidate evidence.
Conclusion
Graph-Grounded Career Agent started with a simple question:
Can we use generative AI to tailor a resume without allowing it to invent the candidate?
Our approach is to put the knowledge graph between the job description and the generation model.
The resulting architecture is:
Job Description
↓
Analyze
↓
Normalize
↓
Match
↓
Retrieve Evidence
↓
Generate
↓
Validate
↓
Render
↓
Grounded ResumeAmazon Bedrock provides the intelligence layer.
The knowledge graph provides the factual context.
The validation layer enforces the grounding boundary.
And the deterministic renderer turns the validated structure into the final document.
The key principle is:
Generation should be flexible. Facts should be constrained.
That principle is what turns a generic AI resume generator into an evidence-backed career intelligence system.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article