DEV Community: Amelia Dutta

Create a Mock Interviewer Bot with Amazon Lex V2

Amelia Dutta — Fri, 21 Aug 2026 10:02:23 +0000

Introduction

Getting a job interview call is a positive sign, but the limited time to prepare can be nerve-wracking. It's said that

"Prepare for the unknown by studying how others in the past have coped with the unforeseeable and the unpredictable."

So having a job interview in front of a bunch of strangers or only one person is indeed unpredictable and overwhelming. But with a bit of preparation—googling common patterns, practicing mock interviews with friends or family—you can confidently face any scenario.

But what if there's insufficient time for extensive research or scheduling conflicts for mock drills? Imagine having a tiny friend with you 24x7 who gathers mock questions and practices with you! Sounds like that popular Japanese blue robot cat, isn't it?

In this article, I will explain how you can build your own Mock Interviewer Bot with the help of Amazon Lex.

What is a Bot?

Before creating the bot let me explain what a bot is. So according to the standard definition of bot —

"A bot is an automated software application that performs repetitive tasks over a network. It follows specific instructions to imitate human behavior but is faster and more accurate. A bot can also run independently without human intervention." Click to read more about bots

In simple words, you have an application that performs the predefined task(for example: paying electricity bills on 1st day of the month, giving reminders for medication on time, creating/arranging meetings according to the user's schedule, or helping you in doing your homework 😜) without the user's intervention. It's like having your personal secretary. Isn't it a bit exciting?

Okay! But what is Lex?

We will create our bot using Amazon Lex. Let's take a look at what it is!

"Amazon Lex is a fully managed artificial intelligence (AI) service with advanced natural language models to design, build, test, and deploy conversational interfaces in applications." Click to read more about Lex

Let's understand what it means. Lex is a service introduced by Amazon Web Services(AWS) that is created using natural language processing (NLP) and automatic speech recognition (ASR). You can create a lifelike bot using pre-built templates by defining the type or create from scratch, then build and test it on your console; after that publish the bot publicly. Example: Amazon Alexa.

Let's Start!

Excited to dive in? Great! Now that we have a clear picture of what we're aiming for, let's roll up our sleeves and bring our mock interviewer bot to life. Follow these simple steps, and you'll have your very own interactive chatbot ready to tackle job interview questions. Ready? Let's get started!

Account Creation :

Visit https://aws.amazon.com/free/ to create your free-tier AWS account. (Remember, your free-tier account is valid for 12 months from your account creation date.)
After creating your AWS account, log in using your "root user" credentials.

Creating a Lambda Function:

In your AWS management console search for Lambda and click on the Lambda option that appears in the search results.
Once the Lambda console opens, locate and click on the "create function" button.

Now in the create function console:

Step 1: Click on the "Author from Scratch" option.
Step 2: Give a function name, for example: JobInterviewerProcessor
Step 3: Choose the current NodeJs version and leave all other settings as default.
Step 4: Click on the Create a new role from AWS policy templates option and assign a role name, such as JobInterviewerProcrsssorRole
Step 5: Now click on "Create function" to finalize and create the Lambda function.

After successfully creating the JobInterviewerProcessor function navigate to the code tab below and replace the existing code in index.mjs either copy the code provided below or write your own.

//needed to interact with Amazon Lex
import { LexModelsV2Client, PutBotCommand } from "@aws-sdk/client-lex-models-v2";

//creates a new instance of the LexModelsV2Client,change "YOUR REGION" before running the code
const client = new LexModelsV2Client({ region: "YOUR REGION" });

//exports a Lambda function named "handler"
export const handler = async (event) => {
  try {
    //parses the incoming event data from Lex
    const lexEvent = JSON.parse(event.body);

    //different cases for various intents (BehavioralInterview, TechnicalInterview etc.)
    //each case handles specific types of questions and provides responses or tips.
    switch (lexEvent.request.intent.name) {
      case "BehavioralInterview":
        //handle behavioral interview questions
        //provide responses, tips, etc.
        break;

      case "TechnicalInterview":
        //handle technical interview questions
        break;
        //you can add any different types of interviews as cases
      default:
        //handle unrecognized intents
        return {
          statusCode: 200,
          body: JSON.stringify({ message: "Intent not recognized" }),
        };
    }

    //you can customize the response
    const response = {
      statusCode: 200,
      body: JSON.stringify({ message: "Success" }),
    };

    return response;
  } catch (error) {
    //handle errors
    return {
      statusCode: 500,
      body: JSON.stringify({ error: error.message }),
    };
  }
};

Delete those comments before saving the code then click "Save".
Switch to the "Test" tab and perform the following steps to verify the functionality of your Lambda function:
- Click on Create new event
- Give your Event a name, for example: BehavioralInterview
- Keep all other settings as default but update the Event JSON with the provided code.

    {
      "body": "{\"request\":{\"type\":\"IntentRequest\",\"intent\":{\"name\":\"BehavioralInterview\"}}}"
    }

Now "Save" the test event and click on "Test" to check your function.

Create The Bot!

Now that we've configured our Lambda function, let's create our bot. Follow these steps:

Navigate to the Amazon Lex console(Here we're using Lex V2) in your AWS Management console.
Locate and click on the "create bot" button. Note: If you are using Lex V1, the user interface may differ slightly from Lex V2, but the overall process remains the same.

You can create a bot using AWS templates or start from scratch. To begin from scratch, select the "Create a blank bot" option.

Name your bot, such as "JobInterviewerBot"and provide a suitable description.
If it's your first time creating a bot in Lex, opt for "Create a role with basic Amazon Lex permission" or use an existing role.
Choose "Children’s Online Privacy Protection Act (COPPA)" based on your subject (I choose no).
Set Session Timeout to 5 minutes and click "Next".
Select language as "English(US)" or your preferred language and choose a voice interaction like "Sallie."
Leave everything as default and click "Create" to complete the bot creation.

Click on Intents in the left navigation and select "Add empty intent". Give it a name based on the bot's topic, such as "BehavioralInterview". Click on "Add."

In the "Utterance" section, add relevant phrases users might use to initiate the conversation with the bot, like "Start interview" or "I want to practice some tech interview." etc.
Move to the Response tab and write some suitable responses corresponding to the utterances, such as "Let's start by introducing yourself."

Navigate to the "Slots" section and click on "Add slot." Slots are user-provided values to fulfill the intent.

For the "BehavioralInterview" intent, consider adding questions or prompts based on "Challenge" or "Outcome" slot types. For technical intents, create slots like "Programming Language" or "Database." etc.

For Slot type, you can use in-built or customized slots and click Add.

Build The Bot

Now we have everything to need to create the bot so click on _"Save Intent" _and run the "Build" process to integrate your changes into the bot's functionality. Building the bot is crucial to reflect and implement the latest modifications.

Test The Bot

Now it's time for the most interesting and long-awaited part - testing the bot! Click on "Test" and a demo chat-bot interface will appear on the screen. Write or speak any utterance that you've added to initiate the conversation and let the practice begin! Congratulations, you have successfully created your Mock Interviewer bot.🎉🎉

Publish bot in Amazon Lex V2

Remember until now we're chatting with the draft version of the Lex bot. If you want to publish the bot in amazon lex V2 follow these steps:

In your management console, go to Lex and click on the name of your bot.
In the Left Navigation menu select Bot version and choose Create version.
Name your version, for example, v1.0.0.

Under Deployment, click on "Alias" and create an alias with a suitable name like "production_1." Associate the alias with the version you just created.

Ta-da! 🎈 Give yourself a pat on the back—you've successfully published your bot.

Conclusion

Finally, I hope this article has helped you with a brief understanding of how bots work and guided you through the process of creating and publishing a chatbot in Amazon Lex V2. Happy coding! 🤖

[Boost]

Amelia Dutta — Fri, 14 Aug 2026 18:14:42 +0000

J3ffJessie

Aug 14

Interviewing doesn't have to be scary. Practice just got easier!!

#ai #discord

6 min read

Revisiting DSA Through Mini Projects #2: HTML Syntax Validator

Amelia Dutta — Thu, 05 Feb 2026 15:43:26 +0000

I am back with another mini project on revisiting DSA and today's topic is Stack! And how I built a simple HTML syntax checker app applying the Stack.

What is a Stack?

A stack is a collection of objects that are inserted and removed according to the Last-In,First-Out(LIFO) principle.

For example: Our Browser's Search history is an example of a stack where each time you visit a new web address, it will be pushed onto the stack of web addresses and by returning you are actually popping back the last searched address to the previously visited site!

Second Project of This Series: A HTML Syntax Checker
Before diving deeper into the project and the logic, check the app here: syntax-validator

Let's See How It Works

To check if HTML tags are balanced, we can use the LIFO property of a Stack. The logic is as follows:

Scan the Code: We read the HTML string from left to right.
Push Open Tags: Whenever we encounter an opening tag (like <div> or <p>) we push it onto our stack.
Pop Closing Tags: When we find a closing tag (like </div> or </p>) we check the top of our stack.
- If the stack matches the current closing tag (e.g. top is div and current is /div) we pop it off. This means the tag was correctly closed!
- If the stack is empty or the tags don't match, we know the syntax is invalid.
After reading the whole string if the stack is completely empty it means every opening tag had a matching closing tag and our html code is valid!

Implementation

I kept the implementation simple using vanilla JavaScript. Here is the snippet where the magic happens:

while(i != -1){
    // If it is an opening tag that means doesn't start with '/'
    if(!tag.startsWith("/")){
        stack.push(tag);
    }
    // If it is a Cclosing tag
    else{
        // Check if we have anything to close
        if(stack.length == 0){
            output.innerText = "Invalid Syntax";
            return;
        }
        // Check if it matches the last opened tag
        // Here tag.slice(1) removes the '/' so we compare "div" with "div"
        if(tag.slice(1) !== stack.pop()){
            output.innerText = "Invalid Syntax";
            return;
        }
    }
}

The key methods here are stack.push(tag) to add to our history of open tags and stack.pop() to match them when we close a tag.

Limitation

As I was revising stack and wanted to make a simple project on that topic so this project has some limitations:

Strict Matching: This code checks for exact string matches. That means <div class="hero-section"> wouldn't match </div> because the strings are different!
Empty Tags: HTML has "empty/void" tags like <img>, <br> and <hr> that don't need a closing tag. Which is why this code will return this as an Invalid Tag!

This project made me realize that finding the right data structure is only half the battle. While the stack was the perfect tool for the core logic, I realized that a real-world solution must handle more complex issues, such as attributes and empty tags.

Revisiting DSA Through Mini Projects #1: Optimizing a Phonebook with HashMap

Amelia Dutta — Mon, 02 Feb 2026 10:24:27 +0000

I am starting to revise the DSA topics when an idea popped in; how about starting to create one mini project based on each topic while revisiting them? This way it can give me insights into how data structures and algorithms are applied in the real world and also I can have something to showcase.

First Project of This Series: A Phonebook App

Without further ado, here is the first project of my learning series: a Phonebook App. Check the app here: https://hashphonebook.netlify.app/

I made this app some years ago but at that time I used the logic of linear searching. Which is good because it was a demo project and there is no need to store thousands of numbers, so the search can check all the possibilities and then return the desired result.

Initially I stored my contacts in a simple JavaScript Array:

let userArray = [
    { userName: "Jane", number: "1237893457" },
    { userName: "Oscar", number: "4562317895" }
];

And to find a contact I used .find() which loops through the array one by one:

// Time Complexity: O(n) Linear Time
const result = userArray.find(contact => contact.userName === "Oscar");

But Why Is Linear Search Not Enough?

In the real world, the scenario is different. We need to store many numbers in our contact list. For example: we store 100000 numbers and in an emergency case, taking the worst scenario if our phonebook takes O(100000) time to show the result then it is too much in this fast-paced world.

This is where performance actually matters not just whether the app works or not!

Optimizing the Search Logic

So the solution is using something that can give results in a shorter time. I changed the array to a HashMap and searched through the map using the key (username).

This way, the lookup time is much faster (O(1)) and more suitable for real-world use cases. Because A Hashmap acts like a real-world dictionary. You don't read every word to find "Strawberry" you flip straight to S.

let contactMap = {
    "Jane": "1237893457",
    "Oscar": "4562317895"
};

// Time Complexity: O(1) Constant Time
const number = contactMap["Jane"];

It doesn't matter if I have 5 contacts or 5 billion. The lookup speed is constant.

The Code Refactor

Here is the actual code I changed in my project:

Before (Array.push):

userArray.push({ userName, contactNumber });

After (Map Key-Value):

// Storing as a key-value pair and making the search case-insensitive
contactMap[userName.toLowerCase()] = { 
    originalName: userName, 
    number: contactNumber 
};

This project made me realize that a "working code" is not always "good code". Linear search was enough for a demo but it doesn't scale and real-world applications demand better solutions.

This is just the first step in my DSA revision journey and I plan to keep building small projects like this!

Step Into Mystic Falls: A Halloween Story Telling Game

Amelia Dutta — Mon, 10 Nov 2025 06:06:07 +0000

> “There is no such thing as a bad idea. Only poorly executed awesome ones,”
Damon once said and I couldn't stop thinking about that while building this Halloween project.

When I stumbled upon the Frontend Challenge - Halloween Edition, Perfect Landing_, I thought why not revisit some old JavaScript fundamentals and create a landing page that truly captures the Halloween spirit?

The Founder's Day and the Lockwood Masquerade Ball have always been my favorite events from The Vampire Diaries so while planning this project I thought, "Let's merge them together!"

That's how The Founder's Ball was born: an interactive storytelling game that lets users step into a dark ballroom, pick a partner, and uncover their supernatural identity.

The Experience

The entire app is built with HTML, CSS, and Vanilla JavaScript (ES6).

Key Technical Features:

Modular JavaScript with ES6 imports/exports for cleaner code organization
CSS Keyframes for smooth fade-in transitions between sections
Responsive Design optimized for mobile, tablet, and desktop (5 breakpoints)
Dark Gothic UI with gradients, animations, and elegant typography

The user journey flows through 6 distinct sections:

Landing → Enter the mysterious ballroom
Attire Selection → Choose your formal wear
Outfit Choice → Pick from 4 elegant designs
Partner Selection → Meet your mysterious companion
Identity Reveal → Discover your supernatural nature
Your Story → Read your personalized tale

My goal was to create a user journey that felt like navigating through a storybook, where each choice transitions seamlessly into the next moment.

My Learnings

This challenge gave me the perfect push to revisit my Vanilla JavaScript foundations and dust off some forgotten concepts.

Here's what I brushed up on:

Array Methods: join(), find(), map()
State Management
DOM Manipulation
ES6+ Features: arrow functions, modules, destructuring

Play The Founder's Ball

View Source Code

Halloween doesn't always have to be scary. Sometimes it's about mystery, elegance, and the thrill of becoming something supernatural for a night.

So… if you've ever wondered what your story will be in Mystic Falls, come find out. The Founder's Ball awaits you at the Lockwood Mansion from sunset to midnight. 🦇

All images used in this project are credited to their original owners.

How Being Part of a Community Took Me from Hesitant to 5 PRs Merged

Amelia Dutta — Sun, 02 Nov 2025 18:26:26 +0000

Ding-dong! The ghouls are gone and the season of Christmas begins; the month long Hacktoberfest wraps up, filled with learning, debugging and late night commits! 🎃
This year, I learned so much more through contributing to Open Source which I never got from just reading tutorials or doing personal projects. and honestly a big chunk of that credit goes to the Torc community.
(Before diving into my journey, check out Torc)

At the beginning of the month, my feed was full of posts from people on LinkedIn and Twitter buzzing about Hacktoberfest. Everyone seemed so ready and excited. And me? I was like, "Umm, nice... but where do I even start?" My calendar was already packed with other events so I didn't really have time to plan my contributions.
And that's where the magic of a good tech community kicks in. Around the second week of October, right when Hacktoberfest was in full swing I finally got a break and logged back in. That's when I discovered that Torc discord have a dedicated hacktoberfest channel, shout out to Jason Torres for creating the torctoberfest repo. And I got a place to start! My interest was back, but then came the real question: what do I contribute to?

The Beginning of torcReads

While scrolling through the channels I suddenly remembered, I hadn't even read the book we picked for our book club! That's when the idea hit me. Huge thanks to Angelos Katrantzis for starting the Torc Book Club; otherwise I might never have thought of this project in the first place!
The initial plan was simple: build a website to log the books we read each month in the club. But then my brain went "Wait, why not add more?" So I started adding features like study guides and monthly voting options. The frontend came out beautifully; Responsive, Clean and Minimalist. And guess what? My first two PRs got merged! Cool, right? 😎

After hosting it for testing, I realized something... Oops it is storing all the data locally! Which meant once deployed, everyone would see their own data. Total chaos incoming!
And here's the twist: I never worked with any backend before. So laptop on, a little googling, some brainstorming with Claude and a few Stack Overflow tabs later; BAM! I discovered Supabase! It lets you store data globally and even offers generous free storage. But of course... I had zero experience integrating a database with frontend.

Still I told myself "we've got a week and a half before 31st October! Why not learn something new?"

My Learnings in the Process

While setting up the database with the frontend I learned a few cool things:

Row Level Security (RLS)
Access control that defines who can read, insert, update, or delete specific rows based on policies.
Migration Files
Version controlled SQL scripts that track and apply database schema changes over time, allowing teams to sync database structures across environments.
CRUD Operations (Create, Read, Update, Delete)
The four fundamental database operations: Create adds new data, Read retrieves it, Update modifies it, and Delete removes it.
Uploading files to cloud
Cloud file storage service that uploads files to remote servers and returns public URLs, allowing applications to store and retrieve uploaded content without managing server infrastructure.
Organizing files
Containers that group and organize related files in cloud storage.
Public vs Private buckets
Access control for file storage; public buckets allow anyone with the URL to download files while private buckets require authentication.

Check out the Torctoberfest Repo here: https://github.com/jasonetorres/torctoberfest

Building torcReads taught me far more than just coding. Before this, I thought backend and database were way out of my league. But once hit a real problem, I had no choice but to figure it out! Kudos to Pat Clark for reviewing and giving thoughtful feedback on each of my pull requests.

I realized open source isn't about being an expert in everything and you don't need to know all to get started. It's about showing up, trying things and learning in public. Even a small idea can turn into something valuable when you have a great community guiding you!

Happy Hacking! 🕸️👻