
Weekend Creative Challenge: VibePlaylist AI
VibePlaylist AI turns everyday feelings, memories, and situations into personalized themed playlists using generative AI. Built with Groq and a serverless AWS architecture, it explores how AI can transform a simple mood into a creative musical experience.
The Idea Behind VibePlaylist AI
Have you ever had a very specific mood but couldn't find the right music for it?
Maybe it's a late-night drive after a long day, a quiet evening when you are feeling nostalgic, a study session that needs some focus, or simply a moment that feels impossible to describe with a normal playlist.
That is where VibePlaylist AI comes in.
VibePlaylist AI is a small generative AI application that turns a user's situation, feeling, memory, place, or activity into a themed playlist. Instead of searching through hundreds of songs manually, users can simply describe what they are experiencing and let AI curate a soundtrack around that idea.
The experience is intentionally simple. A user enters something such as:
"Late night drive through Islamabad after a long and exhausting day."
They then select a vibe such as Chill, Romantic, Sad, Energetic, Dreamy, Nostalgic, or Focus and press Create Playlist.

VibePlaylist AI generates a playlist name, a short description, and eight song recommendations that match the requested atmosphere.
For example, the result could become "Midnight Miles", accompanied by a description about quiet roads, city lights, and reflective thoughts, followed by a collection of songs that fit the mood.
The application isn't intended to replace music streaming platforms. There is no Spotify integration or music playback inside the application. Instead, the creative part is the curation itself: taking an ordinary sentence from the user and turning it into a complete musical concept that they can explore on their preferred streaming platform.
Building the Experience
Since this was a weekend challenge, I deliberately kept the scope small. The application has one primary purpose, and almost every part of the interface supports that purpose.
The frontend uses HTML5, CSS3, and Vanilla JavaScript. I chose a lightweight frontend rather than introducing a large framework because the application did not need complex state management or a complicated component system.
The visual design uses a cinematic black-and-gold theme with clean typography and simple interactive elements. The main screen contains a text input, vibe selection buttons, and a single action to generate the playlist. Once the response arrives, the playlist is presented as a dedicated result card containing the playlist name, description, vibe, and track list.
The AI layer is powered by the Groq API. The backend sends two important pieces of information to the model: what the user is experiencing and the vibe they selected.
I designed the prompt so that the model behaves like a music curator rather than simply returning random song names. It is instructed to produce exactly eight tracks, avoid duplicates, match the requested mood, create a suitable playlist title, and return the result in a predictable JSON structure.
One of the practical challenges was making sure the AI response could be reliably consumed by the frontend. Rather than expecting the browser to interpret a large block of generated text, the backend requests structured JSON containing the playlist title, description, vibe, and individual tracks. This makes the result much easier for the JavaScript frontend to display.
Another important consideration was API security. The Groq API key is never placed inside the frontend code. The browser communicates with my AWS API instead, while the serverless backend handles the communication with Groq.
AWS Architecture
The application uses a serverless architecture so there is no traditional server that needs to remain running continuously.
The AWS services used are:
- Amazon S3 — Stores the static frontend files.
- Amazon CloudFront — Delivers the frontend through a global CDN and HTTPS.
- Amazon API Gateway — Exposes the
POST /generateAPI endpoint.
- AWS Lambda — Runs the Node.js backend whenever a playlist generation request is received.
- AWS IAM — Handles the permissions required by the AWS resources.
- AWS CloudFormation — Defines the infrastructure in YAML and provisions the resources.
The request flow looks like this:
┌─────────────┐ │ USER │ └──────┬──────┘ │ ▼ ┌───────────────┐ │ CloudFront │ └───────┬───────┘ │ ▼ ┌───────────────┐ │ S3 │ │ Frontend │ └───────────────┘
"Create Playlist" request │ ▼ ┌─────────────┐ │ API Gateway │ └──────┬──────┘ │ ▼ ┌─────────────┐ │ Lambda │ │ Node.js │ └──────┬──────┘ │ ▼ ┌─────────────┐ │ Groq API │ └──────┬──────┘ │ ▼ Playlist JSON
One of my goals was also to avoid manually building the AWS environment through the console. The infrastructure is therefore described in an AWS CloudFormation YAML template. This includes the required AWS resources, permissions, connections, and stack outputs.
For deployment, I used a dedicated AWS CLI profile named
account2 . The deployment process explicitly verifies the AWS identity before creating resources and uses that profile for the AWS operations. This was particularly useful because multiple AWS accounts were configured on the development machine.What I Learned
The project gave me practical experience with the complete lifecycle of a small AI application rather than just experimenting with an AI API in isolation.
I learned more about designing an API between a frontend and a serverless backend, including sending JSON requests, handling asynchronous responses, validating generated data, and displaying errors gracefully.
Working with AWS API Gateway and Lambda also helped me understand the serverless model better. Instead of having a Node.js server running continuously, the backend function is invoked when the application actually needs it.
CloudFormation was another major learning point. Defining the AWS environment as YAML changed the way I thought about deployment. Instead of treating the AWS Console as the place where the application is built, the infrastructure itself becomes part of the project and can be recreated from a template.
The challenge also highlighted an important lesson about AI applications: the prompt is only one part of the system. A good application needs to think about the format of the AI response, how that response is validated, how errors are handled, and how the result is presented to the user.
Most importantly, VibePlaylist AI showed me that a creative AI application doesn't need dozens of features. A simple idea, a well-designed interface, and a useful AI interaction can be enough to create an enjoyable experience.
Try VibePlaylist AI
VibePlaylist AI is a small experiment in turning everyday moments into musical ideas using generative AI and AWS serverless technologies.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article