The Problem: Why Job Seekers Struggle to Show Their Impact
Let me be honest. I've reviewed hundreds of resumes, and I see the same problem over and over again.
Job seekers have real experience. They've built things, solved problems, led teams. But when they sit down to write their resume, something breaks. They write generic bullet points like:
- Responsible for developing features
- Worked with a team on projects
- Improved system performance
These bullets don't tell the story. They don't show impact. Recruiters want to know: What changed? Who benefited? Why did it matter?
The real problem isn't that job seekers lack experience. It's that they don't know how to articulate their impact in a way that resonates with hiring managers.
This is where Vaani comes in.
What is Vaani? Your AI Resume Copilot
Vaani is an AI resume copilot I built to solve this exact problem. It's not just another resume builder. It's a conversational AI system that:
- Parses your resume – Extracts your experience, skills, education, and background into structured data
- Classifies your seniority – Calculates total years of experience to understand your career level
- Analyzes your work experiences – Identifies which experiences have strong impact signals and which are missing them
- Asks the right questions – Guides you through a conversation to uncover real business impact from your work
- Refines your impact stories – Transforms generic bullets into compelling achievement statements
- Maintains context – Remembers everything across the entire conversation using persistent memory
The key insight? Impact isn't invented. It's uncovered. Most job seekers have amazing stories buried in their experience. They just need someone (or something) to ask the right questions to bring them out.
How I Architected Vaani: The Three Pillars
Vaani is built on three core pillars: Agentic Workflow, Memory System, and Interactive State Management.
Pillar 1: Agentic Workflow
An agentic workflow means Vaani doesn't just respond to user input. It orchestrates multiple AI agents that work together to guide you through a structured review process.
Here's how it works:
Agent 1: Seniority Classifier
- Analyzes your work experience to calculate total years of experience
- Classifies you as Junior, Mid, or Senior level
- This context helps all other agents understand your career stage
Agent 2: Impact Analysis Agent
- Reviews each of your work experiences
- Identifies which experiences have strong impact signals (outcomes, metrics, business value)
- Flags experiences that are missing impact details
- Provides reflection prompts to help you recall impact
Agent 3: Experience Selector Agent
- Orchestrates which experience to focus on next
- Prioritizes most recent experiences with missing impact
- Ensures you work through experiences systematically
Agent 4: Impact Analysing Agent
- This is where the magic happens
- Asks targeted, conversational questions about your work
- Focuses on outcomes: What changed? Who benefited? Why did it matter?
- Helps you articulate real business impact
Agent 5: Impact Refinement Agent
- Takes your free-text impact description
- Translates it into clear, business-relevant language
- Produces resume-ready bullet points
- Ensures accuracy and authenticity
Pillar 2: Memory System (Redis-Backed)
Here's the problem with most AI tools: they forget context. You tell them something in message 1, and by message 10, they've lost track.
Vaani uses a persistent memory system backed by Redis. Every conversation is stored with:
- Resume sections – Your parsed resume data (name, skills, experience, education)
- Metadata – Total years of experience, seniority level
- Impact analysis results – Which experiences have strong impact, which need work
- Conversation history – Every message exchanged
- Current state – Which experience you're working on, what stage you're in
- Rewritten resume – The improved version being built
This memory persists for 24 hours, so you can close the browser and come back later. Vaani remembers everything.
The memory structure looks like this:
{
"resume_sections": {
"name": "John Doe",
"hard_skills": ["Python", "React", "AWS"],
"work_experiences": [...]
},
"metadata": {
"total_years_experience": 5,
"seniority_level": "Mid"
},
"current_state": {
"current_experience_index": 0,
"current_experience_processed": false,
"current_step": "impact_analysing",
"state": "processing"
},
"rewritten_resume": {...}
}
Pillar 3: Interactive State Management
Vaani doesn't process everything at once. It moves through discrete stages, each with a clear purpose:
- Seniority Classification → Calculate years of experience
- Impact Analysis → Analyse all work experiences for impact signals
- Experience Selection → Choose which experience to focus on next
- Impact Elicitation → Ask targeted questions about that experience
- Impact Refinement → Transform answers into resume-ready bullets
- Iteration → Move to next experience and repeat
Each stage has a current state that tracks:
- Which experience you're working on
- Whether that experience has been processed
- What step you're currently in
- Overall processing status
This prevents confusion and ensures the workflow guides you systematically through your resume.
The Agentic Workflow in Action: A Real Example
Let me walk you through how Vaani works with a real job seeker.
You: Upload your resume (PDF)
Vaani: Parses it and says: "Got it! I see you're a Software Engineer with 5 years of experience at three companies. You have Python, React, and AWS skills. Let me analyze your experiences..."
Vaani: (Analyzing) "Calculating your seniority level... You have 5 years of experience, so you're at a Mid level. Now let me review each of your work experiences to see where you have strong impact stories and where we can dig deeper."
Vaani: "I've analysed your experiences. Your most recent role at TechCorp has some impact signals, but it's missing details. Let's start there. Tell me about your biggest achievement in that role. What did you build or improve? What changed because of your work?"
You: "Well, I built a microservices architecture that improved performance."
Vaani: "Great! Let's dig deeper. How much did performance improve? Who benefited from this? Why did it matter to the business?"
You: "Oh! We reduced API latency by 60%, which meant our mobile app users had a much faster experience. That led to a 15% increase in daily active users."
Vaani: "Perfect! That's real impact. Here's how I'd write that as a resume bullet:
Architected microservices migration reducing API latency by 60%, enabling 15% increase in daily active users and improving experience for users.
Does that feel accurate?"
You: "Yes! That's so much better than what I had."
Vaani: "Great. Let's move to your next role at PreviousCorp. Tell me about your biggest impact there..."
And so on. By the end, you have a completely rewritten resume with impact-driven bullets for each experience.
The Architecture Diagram
Here's how all the pieces fit together:
┌─────────────────────────────────────────────────────────────┐
│ VAANI ARCHITECTURE │
└─────────────────────────────────────────────────────────────┘
┌──────────────────┐
│ User Interface │
│ (Web/Mobile) │
└────────┬─────────┘
│
▼
┌──────────────────────────────────────────────────────────────┐
│ WebSocket Connection (Real-time) │
└────────┬─────────────────────────────────────────────────────┘
│
▼
┌──────────────────────────────────────────────────────────────┐
│ Vaani Backend (Go + Genkit) │
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Message Router │ │
│ │ - Routes messages to appropriate agent │ │
│ │ - Manages conversation flow │ │
│ │ - Tracks current state │ │
│ └────────────────┬────────────────────────────────────┘ │
│ │ │
│ ┌─────────────┼──────────────┬──────────────┐ │
│ ▼ ▼ ▼ ▼ │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │Seniority │ │Impact │ │Experience│ │Impact │ │
│ │Classifier│ │Analysis │ │Selector │ │Analysis │ │
│ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │
│ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ Impact Refinement Agent │ │
│ │ - Transforms user answers into resume bullets │ │
│ │ - Maintains accuracy and authenticity │ │
│ └──────────────────────────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────────────┘
│
▼
┌──────────────────────────────────────────────────────────────┐
│ Memory Layer (Redis) │
│ │
│ Key: memory:{chat_id} │
│ Value: { │
│ resume_sections, │
│ metadata (seniority, experience), │
│ impact_analysis_results, │
│ conversation_history, │
│ current_state, │
│ rewritten_resume │
│ } │
│ TTL: 24 hours │
└──────────────────────────────────────────────────────────────┘
│
▼
┌──────────────────────────────────────────────────────────────┐
│ LLM Layer │
│ │
│ - Structured outputs for parsing │
│ - Prompt engineering for each agent │
│ - JSON schema validation │
└──────────────────────────────────────────────────────────────┘
The Memory Flow: How Context Persists
Here's how memory works across a conversation:
User uploads resume
│
▼
Parse resume → Store in Redis memory
│
▼
Classify seniority level
│
▼
Retrieve memory → Add seniority data → Update Redis
│
▼
Analyze all work experiences for impact
│
▼
Retrieve memory → Add impact analysis → Update Redis
│
▼
Select first experience to work on
│
▼
Ask impact questions about that experience
│
▼
Retrieve memory → Add conversation → Update Redis
│
▼
Refine impact into resume bullet
│
▼
Retrieve memory → Add refined bullet → Update Redis
│
▼
Move to next experience (repeat)
│
▼
User closes browser (memory persists for 24 hours)
│
▼
User returns next day
│
▼
Retrieve memory → Continue from where they left off
This is powerful because it means Vaani never loses context. You can have a conversation over multiple days, and it remembers everything. You can close the browser mid-conversation and come back later to continue exactly where you left off.
Why This Architecture Matters
Most AI resume tools are stateless. They don't remember context. You tell them something, they respond, and that's it. If you want to refine something, you have to re-explain everything.
Vaani is stateful and agentic. It:
- Remembers everything – Via Redis memory that persists for 24 hours
- Orchestrates multiple agents – Each with a specific job (seniority classification, impact analysis, elicitation, refinement)
- Maintains workflow state – Knows exactly which experience you're working on and what stage you're in
- Asks intelligent questions – Based on your specific resume and career level
- Never fabricates – Only enhances what you confirm as true
- Guides systematically – Works through your experiences one by one, ensuring nothing is missed
This is why Vaani produces better results than generic AI tools. It's not just generating text. It's guiding you through a structured conversation to uncover and articulate your real impact.
The Results: What Users Get
After going through Vaani, users get:
- Impact-driven resume bullets – Focused on outcomes, not tasks
- Deeper self-awareness – You understand your own impact better
- Confidence in your story – You can articulate your value clearly
- A repeatable process – You know how to uncover impact for any role
- Better resume quality – Each bullet is specific, measurable, and authentic
Users report that their resume bullets are significantly stronger after Vaani. Instead of generic statements like "Improved system performance," they have specific, impact-driven bullets like "Architected microservices migration reducing API latency by 60%, enabling 15% increase in daily active users."
Building Vaani: Key Lessons
If you're building AI systems, here are the key lessons I learned:
- State matters – Stateless AI is limited. Persistent memory changes everything. Users can close the browser and come back later.
- Agents are powerful – Multiple specialized agents beat one general-purpose model. Each agent does one thing well.
- Accuracy over polish – Never fabricate. Users trust systems that maintain fidelity. It's better to ask a clarifying question than to guess.
- Conversation > generation – Asking the right questions is more powerful than generating answers. The user has the knowledge; you just need to help them articulate it.
- Workflow design – Clear stages and state management prevent confusion. Users should always know where they are in the process.
- Systematic over random – Guide users through experiences systematically. Don't jump around randomly.
Try Vaani Today
If you're struggling to tailor your resume, or if you want to uncover the real impact in your experience, try Vaani. It's free to start, and it works for any role in software, AI, ML, and data.
Visit try-vaani to get started.
Your resume has more power than you think. Vaani helps you unlock it.
Top comments (0)