Hey there! 👋 Are you tired of the usual job application process—filling out endless forms, uploading resumes, and waiting for weeks to hear back? Well, I was too, so I decided to build a chatbot that makes the job application process feel like chatting with a friend. Let’s dive into how I created Quick Apply, a conversational job application bot, step by step!

What’s the Deal With Quick Apply?

Quick Apply is an interactive, chat-based job application tool. The idea is simple: instead of filling out boring forms, you chat with a bot that collects all the necessary information (name, email, answers to screening questions, and your CV). The best part? It actually feels like you're talking to a human—no more dry, robotic forms.

You can explore the project on GitHub or deploy it directly to your own Vercel account.

I used a mix of technologies to make this bot work smoothly. Here’s what went into building it:

Next.js: Handles all the backend logic through API routes.

OpenAI API: Powers the conversation, making it feel real and personalized.

Upstash Redis: This is where the bot stores the chat history so it can remember your responses throughout the conversation.

Upstash Vector: A semantic search tool that helps the bot answer your questions about the job or company based on internal documents.

Google Sheets API: Stores all the application data, so recruiters can easily access your info.

Google Drive API: Lets the bot upload your CV into Google Drive.

How Does It Work?
Quick Apply’s workflow is designed to be smooth, intuitive, and very human-like. Here’s a quick breakdown of how it goes down:

Greeting: When you start, the bot greets you with a friendly message and asks for your name and email. Simple, right?

Pre-Screening Questions: The bot asks you a set of custom screening questions. You answer one at a time, just like chatting with a recruiter. If the bot feels your answer is a bit unclear, it’ll politely ask you to clarify.

CV Upload: After answering questions, the bot prompts you to upload your resume (in PDF format). Your resume is then uploaded to a Google Drive folder for HR to review.

Q&A with Company Info: Once your resume is uploaded, you can ask the bot questions about the company, the job, or anything else you’re curious about. The bot pulls answers directly from the company’s documents (so it never guesses!).

Wrap-Up: After the Q&A session, the bot says goodbye and saves your data (answers, score, resume) to Google Sheets for the recruiter’s review.

Making the Conversation Feel Real

A big part of Quick Apply is making the conversation feel authentic. We use LangChain with OpenAI’s API to generate prompts that guide the bot through the conversation. The bot isn’t just asking random questions; it follows a specific flow: welcoming you, collecting your details, asking the screening questions, and so on.

Here’s a quick peek at the code that makes the bot feel natural:

const welcomemessage = jsonData["welcome-message"];
const questions = jsonData.questions;  // e.g. ["Why do you want this job?", "Describe your experience with X", ...]

const systemInstructions = `
  You are a helpful job application chatbot. Start by greeting the candidate with: "${welcomemessage}"
  and ask for their name, then their email.
  After that, ask each of the following pre-screening questions one by one...
  If an answer is unclear, ask again politely.
  Once all questions are answered, ask the user to upload a PDF resume.
  Lastly, let them ask questions about the job.
`;

This keeps the conversation on track and ensures that the bot doesn’t miss any steps!

Keeping the Chat History with Upstash Redis

A key part of making this chatbot work smoothly is remembering the conversation. So, I use Upstash Redis for memory. Every time the bot receives or sends a message, it’s saved to Redis, so the bot knows exactly where it left off. For example:

const memory = new BufferMemory({
  returnMessages: true,
  chatHistory: new UpstashRedisChatMessageHistory({
    sessionId: sessionId,  // unique ID for each user
    config: {
      url: process.env.UPSTASH_REDIS_REST_URL,
      token: process.env.UPSTASH_REDIS_REST_TOKEN
    }
  })
});

This way, even if you take a break in the middle of the application, the bot will remember everything when you come back!

Answering Your Questions About the Job

Once the bot has your resume, it switches gears and lets you ask questions about the job. The cool part? It doesn’t just guess the answers. The bot pulls answers from real documents (like the company’s job description or FAQ) stored in Upstash Vector.

Here’s how it works behind the scenes:

const [queryVector] = await embeddings.embedDocuments([userQuestion]);
const results = await index.query({
  vector: queryVector,
  topK: 5,
  includeMetadata: true
});
const context = results.map(r => r.metadata.content).join("\n");

It looks for the most relevant info and uses it to answer your question. If it doesn’t know something, it simply tells you and offers to follow up with HR.

Storing Your Data

Once the chat is complete, all your answers and your CV are stored in Google Sheets and Google Drive. Recruiters can easily access everything in one place. Here’s the code that stores the answers:

await sheets.spreadsheets.values.update({
  spreadsheetId,
  range: `Sheet1!A${emptyRow}`,
  valueInputOption: 'USER_ENTERED',
  resource: { values: [[uuid, answer1, answer2, score, …]] }
});

And for your CV:

await drive.files.create({
  media: {
    mimeType: 'application/pdf',
    body: stream.PassThrough().end(buffer)
  },
  requestBody: {
    name: `${uuid}.pdf`,
    parents: [process.env.GOOGLE_DRIVE_ID],
    fields: 'id'
  },
});

Wrapping Up

In the end, Quick Apply turns the job application process into a chat that feels less like filling out forms and more like a conversation with a helpful assistant. By combining AI, Redis, vector search, and cloud storage, I’ve made an app that’s easy to scale, easy to maintain, and gives candidates a much more human-like experience.

So, whether you're looking to streamline your hiring process or just explore chat-based workflows, I hope this project shows you how a few well-chosen tools can make a big difference. Happy coding! 🚀