DEV Community: ERUMALLA SATHVIKA

I Built a Career Advisor That Remembers You

ERUMALLA SATHVIKA — Sat, 21 Mar 2026 17:37:51 +0000

I Built a Career Advisor That Remembers You

A Memory-Driven AI System for Personalized Career Guidance

The Problem Every Student Faces

Most AI tools today are helpful — but forgetful.

Every time you start a new session, you have to explain:

Your skills
Your projects
Your career goals

Again. And again.

This isn’t intelligence.
It’s repetition.

The core issue?
Most AI systems are stateless — they don’t retain anything about you once the session ends.

The Core Idea

We asked a simple but powerful question:

What if AI didn’t just respond — but remembered, compared, and evolved?

That idea led to building an AI Career Advisor powered by persistent memory.

What Makes This System Different

This is not just another chatbot.

It’s a system that:

Remembers user history
Tracks progress over time
Adapts responses based on past interactions

Instead of isolated conversations, it builds a continuous, evolving user journey.

The Breakthrough: Memory Changes Behavior

Before Memory

Resume feedback was generic
Suggestions were repeated
No awareness of past mistakes

After Memory

Detects missing projects from past conversations
Tracks interview performance trends
Generates highly personalized recommendations

The system started doing something unexpected:

➡️ It challenged the user’s resume
➡️ It compared past vs present performance
➡️ It adapted its feedback dynamically

Resume Analysis: Beyond Static Input

Traditional tools treat the resume as the only source of truth.

We changed that.

We combined:

Parsed resume data
Stored skills
Historical project data

Result:

No repeated suggestions
Missing information gets detected
Feedback becomes deeply personalized

Mock Interviews: From Repetition to Progress

Initially, mock interviews felt repetitive.

Because the system didn’t remember:

Previously asked questions
Weak areas
Past performance

After introducing memory:

Questions targeted weak topics
Feedback improved over time
Sessions became progressively harder and more relevant

We also added streak tracking — a simple feature that significantly improved user consistency and engagement.

The Real Challenge: Architecture, Not Models

At first, we assumed the model would be the hardest part.

It wasn’t.

The real challenge was designing how data flows through the system.

System Architecture

Frontend → React UI
Backend → Node.js API
LLM Layer → Response generation
Memory Layer → Persistent context (Hindsight)

Request Flow

const memory = await hindsight.retrieve(userId);

const response = await llm.generate({
  input: query,
  context: memory
});

await hindsight.store(userId, {
  query,
  response
});

Every interaction follows a loop:

Retrieve relevant memory
Generate a response
Store the new experience

The Most Important Design Decision

The system does NOT depend on:

UI
Prompts
APIs

It depends on:

How memory is retrieved and updated

This is what defines intelligence in a system.

What Worked

Structured memory storage
Separation of memory layers
Event-based tracking of user actions

What Didn’t Work

Large, unfiltered context injection
Stateless system design
Treating memory as simple logs

The Tradeoff Problem

Memory introduces a critical balance:

More memory → richer personalization, but more noise
Less memory → cleaner responses, but less relevance

The key is retrieving the right memory at the right time.

The Real Insight: Experience > Context

Most systems treat memory like a database.

That’s the mistake.

Memory only matters when it:

Influences decisions
Changes system behavior
Improves future responses

Lessons Learned

Architecture matters more than prompts
Memory is a system-level concern, not a feature
Data flow defines how intelligent the system feels

Why This Matters

Students today lack:

Continuous career guidance
Structured progress tracking
Personalized mentorship

This system bridges that gap.

It transforms AI from a tool into a long-term career mentor.

Future Scope

Voice-based mock interviews
Real-time evaluation systems
Adaptive difficulty based on performance

Final Thought

The hardest part of building AI systems isn’t generating responses.

It’s deciding:

What the system remembers
Why it remembers it
How that memory shapes future behavior

Because in the end:

Intelligence is not just about answers — it’s about continuity.

🔗 Project Repository

https://github.com/sathvika32427/AI-Career-Advisor-That-Remembers-You

👥 Team

Vivek Thakkuri
Sathvika Erumalla
Puttapaka Nikhil Yadav
Sangameshwar
Charmi Gajula
Nirmala Devi

🚀 Closing Note

If you're building AI agents:

Don’t just give them context.
Give them memory.
Give them experience.

AI-Career-Advisor-That-Remembers-You

ERUMALLA SATHVIKA — Sat, 21 Mar 2026 10:51:09 +0000

Mock Interviews Only Became Useful When the System Started Remembering Mistakes

The Problem with Traditional Mock Interviews

Mock interviews are designed to simulate real hiring scenarios — but in most systems, they quickly become repetitive.

The standard flow looks like this:

Ask questions → Get answers → Provide feedback

While this works initially, users often report the same issue:

“It feels repetitive.”

Why Repetition Happens

The core problem is not the questions — it's the lack of memory.

Most systems fail to retain:

Previously asked questions
Weak areas identified in earlier sessions
Past performance trends

As a result, every session resets. The system behaves like it’s meeting the user for the first time — again and again.

The First Version: Stateless Interviews

const question = generateQuestion(role);

const response = await llm.generate({
  input: question
});

This approach treats each session independently.

There is no evolution.
No personalization.
No learning curve.

Introducing Memory into Interviews

To make interviews meaningful, we integrated a memory layer using Hindsight.

const memory = await hindsight.retrieve(userId);

const weakAreas = memory.weakTopics;

const question = generateFromWeakAreas(weakAreas);

Now, instead of random questions, the system adapts.

It focuses on:

Weak concepts
Previously incorrect answers
Areas requiring reinforcement

Tracking Performance Over Time

Memory is not just about recall — it's about progress tracking.

await hindsight.store(userId, {
  type: "interview",
  topic: "system design",
  performance: "weak"
});

Each session contributes to a growing profile of the user.

Over time, this enables:

Pattern detection
Performance improvement tracking
Personalized feedback loops

The Role of Streaks

We also introduced a simple but powerful feature: streak tracking.

updateStreak(userId);

While technically straightforward, its impact is significant.

Streaks:

Encourage daily engagement
Build consistency
Turn preparation into a habit

What Changed After Adding Memory

Before

Repeated questions
No clear improvement
Static experience

After

Adaptive questioning
Focused skill development
Measurable progress

The system transformed from a tool into a mentor.

Future Scope

The current system is only the beginning.

Next steps include:

Voice-based interviews
Real-time response evaluation
Adaptive difficulty levels based on performance

Hindsight Integration

To power long-term memory, we leveraged:

This enables persistent, evolving intelligence across sessions.

Key Takeaways

Practice without feedback loops is ineffective
Memory enables true personalization
Tracking progress is essential for growth

Final Thought

Mock interviews are not about asking better questions.

They are about tracking improvement over time.

🔗 Project Repository

Explore the full implementation here:
👉 https://github.com/sathvika32427/AI-Career-Advisor-That-Remembers-You

“I Built an AI Career Advisor That Remembers You”

ERUMALLA SATHVIKA — Fri, 20 Mar 2026 09:22:12 +0000

I Built a Career Advisor That Remembers You

The Problem Every Student Knows Too Well

It is the third week of March.

Priya, a third-year Computer Science student, opens an AI chat and types:
“Can you help me with my resume for a backend internship?”

The AI replies:
“Sure! What skills do you have?”

Priya sighs.

She answered this exact question last Tuesday. And the Tuesday before that.

Every time she opens a new session, she has to reintroduce herself — her skills, her projects, her goals. The AI is helpful, but it has the memory of a goldfish.

This is the invisible tax students pay when using AI tools for career preparation.

You spend the first few minutes of every session just getting the AI up to speed — and even then, the advice is generic, not personalized.

So I asked a simple question:

What if the AI actually remembered you?

Introducing the AI Internship & Career Advisor

I built an AI Career Advisor that doesn’t reset every time you open it.

Instead of treating each conversation as new, it uses persistent memory to track:

Skills you’ve learned
Projects you’ve built
Internships you’ve applied to
Interview outcomes
Career goals

This is powered by a memory system called Hindsight, which allows AI agents to remember, recall, and improve over time.

Instead of acting like a chatbot, the system behaves like a mentor who has been following your journey for weeks.

A Day in Priya’s Life — With Memory

Session 1: Onboarding

Priya shares her profile:

Python, SQL, learning React
Built a finance dashboard
Wants a backend internship
Applied to Zepto

The system stores this in memory.

It will never ask again.

Session 2: Resume Help

Three days later, she returns:

“I have an interview at Meesho. Update my resume.”

No repeated questions.

The system already knows her background and responds:

“For a backend role, your finance dashboard project should be highlighted more — it shows API design and data handling.”

This is not generic advice. It is built from her actual history.

Session 3: A Rejection

Priya says:

“I got rejected from Meesho.”

The system remembers she was also rejected from Zepto earlier.

It responds:

“That’s two HR-round rejections. This might not be a technical issue — let’s practice your introduction.”

This kind of pattern recognition is only possible with memory.

Session 4: Skill Gap Analysis

She shares a job description from Razorpay.

The system compares it with her stored skills:

“You’re strong in Python and SQL, but missing API development experience. Here’s a 3-week plan to fix that.”

This is targeted, actionable guidance.

Session 5: Progress Tracking

Weeks later, Priya sees:

5 applications
2 interviews
1 in progress

The system reminds her:

“Your PhonePe application is 12 days old. Want to send a follow-up email?”

Nothing is forgotten.

How Memory Makes This Possible

This system runs on a simple loop:

Step 1 — Recall

Fetch user history from memory

Step 2 — Reason

Use that context to generate personalized responses

Step 3 — Store

Save new updates back into memory

This loop allows the system to evolve with the user.

This is powered by:

Hindsight GitHub: https://github.com/vectorize-io/hindsight
Documentation: https://hindsight.vectorize.io/
Agent Memory: https://vectorize.io/features/agent-memory

How Memory is Stored (Conceptually)

Each interaction is stored in structured form:

{
  "user": "Priya",
  "skills": ["Python", "SQL"],
  "projects": ["Finance Dashboard"],
  "applications": ["Meesho", "Zepto"],
  "outcomes": ["HR rejection"]
}

Before generating a response, the system retrieves this memory and uses it as context.

This is what makes responses personalized.

Before vs After Memory

Without memory:
“Tell me your skills again.”

With memory:
“Since you’ve worked with Python and built a finance dashboard, here’s how you can improve your backend profile…”

That difference is everything.

Core Features

1. Resume Feedback

Personalized suggestions based on real projects

2. Skill Gap Analysis

Identifies missing skills and creates learning paths

3. Internship Recommendations

Suggests relevant roles based on history

4. Progress Tracker

Tracks applications, interviews, and outcomes

Why This Matters

Most students don’t lack effort — they lack guidance.

AI tools today are powerful, but they forget everything.

By adding memory, we move from:

generic answers → personalized mentorship

This can level the playing field.

A student without mentors can now have an AI that grows with them.

Built With

Hindsight (memory layer)
Groq (LLM inference)
React (frontend)
Node.js (backend)

Try It Yourself

The project is open source and available on GitHub.

You can run it using Hindsight Cloud and a free API key.

Because the best career advisor is one that never forgets you.

Final Thoughts

This project taught me something simple:

AI doesn’t become useful just by becoming smarter.

It becomes useful when it starts remembering.

And once it remembers — it starts understanding.

Built for the AI Agents That Learn Using Hindsight Hackathon.