AWS Builder Center

Weekend Creative Challenge: VentBot — The Cubicle Confessional & Jargon Exorcist

What if your worst workday could talk back? Meet VentBot, an AI-powered creative companion that turns workplace frustration into empathy and corporate jargon into something humans can actually understand. Built with AWS serverless services and Gemini, VentBot detects whether you're venting or decoding corporate nonsense, then responds with empathy, humor, 5-year-old explanations, and pirate translations.

Weekend Creative Challenge: VentBot

Turning workplace frustration and corporate jargon into something people can actually laugh about.

The Idea

Every IT employee has experienced at least one of these situations:
“Let's circle back.”
“We need to leverage our bandwidth.”
“The deployment failed again.”
One is confusing. The other is frustrating.
So I built VentBot — The Cubicle Confessional & Jargon Exorcist, a small AI-powered creative application that turns workplace chaos into something understandable, supportive, and occasionally hilarious.
The idea is intentionally simple: type what is ruining your workday and let VentBot decide what kind of response is appropriate.
What you type
VentBot mode
What you get
“I have been debugging this for four hours.”
Vent Mode
Empathy and an optional funny reframe
“Let's leverage our bandwidth and circle back.”
Jargon Mode
Real meaning, 5-year-old version, and pirate version
A message indicating a heavier situation
Support response
Empathy without humor
The goal was not to create another generic chatbot. I wanted to build a small, personality-driven experience that makes people smile while solving a recognizable workplace problem.

What Makes VentBot Different?

Most AI applications follow a simple pattern:
Type → Loading → Response
VentBot tries to make the waiting experience part of the product.
Instead of displaying a generic “Loading...” message, the application cycles through personality-driven messages such as:
“Extracting corporate demons...”
“Summoning HR-approved pirate...”
“Consulting the 5-year-old on retainer...”
“Burning sage over the synergy...”
“Translating ‘circle back’ into human...”
For Vent Mode, the personality changes:
“Making space for this...”
“Actually reading what you wrote...”
“Sitting with it for a second...”
This small interaction makes the application feel more like a product and less like a technical demonstration.

How VentBot Works

The application uses a lightweight serverless architecture.
USER
|
v
+------------+
| Netlify |
| Frontend |
+------+-----+
|
POST /chat
|
v
+------------+
| API Gateway|
+------+-----+
|
v
+------------+
| Lambda |
| VentBot AI |
+------+-----+
|
+--------+--------+
| |
v v
+-------------+ +------------+
| Gemini API | | DynamoDB |
| Generative | | Mood / |
| AI | | Sessions |
+-------------+ +------------+


The request lifecycle

Step
What happens
1
The user enters a workplace message or frustration
2
The frontend sends a POST /chat request
3
AWS API Gateway receives the request
4
AWS Lambda processes the request
5
Gemini generates the structured creative response
6
DynamoDB stores session and mood information
7
Lambda returns the response to the frontend
8
VentBot renders the result in the appropriate mode

AWS Services Used

AWS provides the core backend infrastructure for VentBot.
Service
Purpose
AWS API Gateway
Exposes the POST /chat endpoint
AWS Lambda
Handles backend logic and AI orchestration
Amazon DynamoDB
Stores session history, inputs, responses, timestamps, modes, and mood scores
AWS Free Tier resources
Supports the serverless deployment for the project
The generative AI layer is provided by the Gemini API, while the application backend and data layer remain on AWS.
The Gemini API key is stored on the backend in Lambda rather than being exposed in the frontend.

Why Two Modes?

I wanted VentBot to recognize that not every bad workday needs the same response.

Vent Mode

When the user is expressing frustration, VentBot responds with empathy first.
Example input:
“I've been debugging the same deployment issue for four hours.”
A response could be:
“That sounds genuinely exhausting. Spending hours chasing one issue can make an entire workday feel like it disappeared.”
When appropriate, VentBot can then provide a short humorous reframe.

Jargon Mode

When the input looks like corporate communication, VentBot acts as a translator.
Input:
“Let's leverage our bandwidth, align with stakeholders and circle back.”
Version
Translation
Real meaning
Let's discuss this later when everyone is available.
5-year-old
Let's talk about it later.
Pirate
Arrr, we'll talk about it later!
This combination of usefulness and humor is what gives VentBot its creative identity.

The Safety Decision

Another important design decision was knowing when not to joke.
VentBot generates a  concern_flag  along with the response.
Situation
Response style
Normal workplace frustration
Empathy with optional humor
Mild stress
Empathy with a light reframe
Heavier emotional language
Supportive response
concern_flag = true
No humor
The goal is simple:
Humor should be an option, not a default.

A Major Development Challenge: Bedrock

The original implementation of VentBot was designed around Amazon Bedrock and an Amazon Nova model.
During development, I encountered a problem with Bedrock inference. My AWS account returned:
ValidationException: Operation not allowed

The problem was not limited to my Lambda function. I also received the same error when testing the model directly through the Amazon Bedrock Playground.
I verified the Lambda execution role and confirmed that the role had broad Bedrock permissions, including the ability to invoke Bedrock models. Since the error continued even in the Bedrock Playground, it became clear that changing application code alone would not solve the problem.
Instead of stopping the project, I redesigned the AI layer so that it could be replaced without rebuilding the rest of the application.
I switched the generative AI component to the Gemini API while keeping the AWS backend architecture intact.
The resulting architecture remained:
API Gateway → Lambda → DynamoDB
with Gemini providing the generative AI capability.
This became one of the most valuable lessons from the project:
A good architecture should make individual components replaceable.
A blocked AI service did not require rebuilding the entire application.

A Second Deployment Challenge: Amplify Hosting Limit

After completing the application, I initially planned to use AWS Amplify for frontend hosting.
However, I reached my available Amplify application limit in my AWS account and could not create another Amplify-hosted application.
Instead of abandoning the deployment, I separated frontend hosting from the AWS backend.
I deployed the static frontend using Netlify, while keeping the application backend on AWS:
Netlify → API Gateway → Lambda → Gemini API + DynamoDB
This allowed me to keep the core AWS architecture running while using an alternative static hosting platform for the frontend.
The experience reinforced another important lesson: cloud applications should be designed so that individual infrastructure components can be replaced when practical constraints arise.

VentBot at a Glance

Feature
Status
Vent Mode
Complete
Corporate Jargon Mode
Complete
Pirate Translation
Complete
5-Year-Old Translation
Complete
Mood Score
Complete
Session Logging
Complete
Personality Loading States
Complete
Safety Flag
Complete
AWS Serverless Backend
Complete
Public Web Deployment
Complete

What I Learned

This project taught me much more than simply connecting an AI API.
I learned how to build a serverless backend using AWS Lambda and API Gateway, store application data using DynamoDB, handle browser-to-backend communication with HTTP APIs and CORS, and keep API credentials out of client-side code.
I also learned how important structured AI output is. VentBot depends on predictable fields such as  mode ,  moodScore ,  empathy ,  real_meaning , and  concern_flag , so I designed the AI layer to return structured JSON rather than unpredictable free-form responses.
Another major lesson was adaptability. I initially designed the application around Bedrock and Nova, but encountered an account-level inference problem. Later, I reached an Amplify application limit while preparing the deployment. In both situations, I changed only the affected component rather than rebuilding the entire system.
That made me realize that cloud architecture is not just about selecting services. It is also about designing systems that can evolve when real-world constraints appear.
Most importantly, I learned that small details can make an AI application memorable. The rotating loading messages, pirate translations, mood score, and empathy-first response design are simple features individually. Together, they give VentBot a distinct personality.

What's Next?

VentBot can be extended beyond the current version.
Future feature
What it could do
Mood History
Visualize stress scores over time
Corporate Demon Counter
Track how much corporate jargon has been translated
Shareable Results
Allow users to copy and share creative translations
Themes
Provide different visual personalities for different modes
Team Mode
Show anonymous team-level mood trends
Weekly Recap
Generate a playful summary of the user's workweek

Challenge Timeline

Milestone
Date
Challenge opens
August 14, 2026 — 12:00 AM PT
Build and publish
August 14–17, 2026
Challenge deadline
August 17, 2026 — 1:00 PM PT
Evaluation
Within 2 weeks of the deadline
Winner notification
Via email and updated Builder Center article

What I Wanted to Build

I didn't want VentBot to solve a huge enterprise problem.
I wanted it to solve something much smaller:
Make a frustrating workday slightly less frustrating.
If someone can paste an unreadable corporate message and finally understand what it means, or vent about a terrible deployment and get a response that makes them laugh, then VentBot has done its job.
Sometimes the most useful AI application isn't the one that automates your entire workflow.
Sometimes it just helps you survive the workflow.

Try VentBot

Live Application:  https://ventbot.netlify.app/ 

Final Architecture

Netlify → API Gateway → Lambda → Gemini API + DynamoDB
Built during the AWS Builder Center Weekend Challenge: Build a Creative App.
#creative-expression
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article