AWS Builder Center
Weekend Creative Challenge: BriefBloom

Weekend Creative Challenge: BriefBloom

BriefBloom is a serverless generative AI app that turns a rough idea into a structured creative brief with campaign messaging, visual direction, launch steps, and a downloadable campaign card using Amazon Bedrock, AWS Lambda, and Amazon S3.

aimlops | devops engineer | aws community builder | open source contributor |

From a Rough Idea to Something Useful

Most ideas do not begin as polished plans.
They usually start as a quick note, a conversation, or a sentence like:
“We should build something around this.”
The difficult part is often not coming up with the idea. It is turning that idea into something clear enough to explain, design, share, and eventually launch.
For the AWS Weekend Creative Challenge, I built BriefBloom — a small generative AI application that transforms a rough idea into a structured and visual creative brief.
The concept is simple:
Idea → Direction → Artifact
BriefBloom is designed for students, creators, small businesses, project teams, clubs, freelancers, and community organizers who have an idea but are not yet sure how to present it.



What BriefBloom Does

A user starts by describing what they are trying to create, promote, organize, or launch.
For example:
We are organizing a beginner AWS workshop for university students who are interested in cloud computing but feel intimidated by AWS.
BriefBloom takes that description and generates:
  • A campaign or project name
  • One-line positioning
  • Target audience
  • Creative concept
  • Tagline
  • Visual color palette
  • Poster headline
  • Supporting poster copy
  • Call to action
  • Social media caption
  • Three practical launch steps
  • A short explanation of why the direction works
Instead of returning one large block of AI-generated text, the application displays the result as a visual creative workspace.
Generated HEX colors become actual palette swatches, campaign copy is organized into separate sections, and poster messaging appears inside a designed preview.
One of my favorite features is the Download Campaign Card option.
Using the browser Canvas API, BriefBloom creates a high-resolution PNG containing the campaign name, tagline, supporting copy, visual palette, and call to action.
The goal is for users to leave with something tangible that they can save, share with a team, or use as the starting point for a real project.



How I Built It

I intentionally kept the frontend lightweight.
It uses:
  • HTML
  • CSS
  • Vanilla JavaScript
The main landing page introduces BriefBloom, while the  /create/  page provides a separate creative workspace.
When a user submits an idea, the browser validates the input and sends a small JSON request to the backend.
The backend is implemented using AWS Lambda with Python.
Lambda performs several tasks:
  1. Validates the request
  1. Checks the user's idea and creative type
  1. Builds the prompt
  1. Invokes Amazon Bedrock
  1. Validates the generated output
  1. Returns structured JSON to the frontend
I wanted BriefBloom to behave like a focused creative tool rather than a generic chatbot.
Because of that, the model is instructed to act as a creative strategist and return predictable fields required by the interface.
The response includes values such as:
{
"campaign_name": "...",
"audience": "...",
"creative_concept": "...",
"tagline": "...",
"palette": [...],
"poster": {...},
"social_caption": "...",
"launch_steps": [...],
"why_it_works": "..."
}
The Lambda function treats the model response as untrusted input.
It checks required fields, validates generated HEX colors, confirms the expected number of launch steps, and handles malformed output before anything is rendered in the browser.
This made the application much more reliable than simply displaying raw AI text.



AWS Architecture

I deliberately avoided adding services that the application did not need.
The architecture is:
User Browser
|
v
Amazon S3
Static Website
|
v
Lambda Function URL
|
v
AWS Lambda
|
v
Amazon Bedrock
|
v
Amazon Nova 2 Lite
|
v
Structured Creative Response
|
v
Visual Brief + PNG Download

Amazon S3

Amazon S3 hosts the static frontend, including the landing page, builder interface, CSS, JavaScript, configuration, and other assets.

AWS Lambda

AWS Lambda handles validation, prompt construction, Bedrock invocation, response validation, and error handling.
The frontend does not contain AWS credentials. Lambda accesses Bedrock through its IAM execution role.

Amazon Bedrock

The generative layer uses Amazon Bedrock with Amazon Nova 2 Lite through the Converse API.
Nova generates the campaign direction, messaging, visual palette, poster copy, and launch plan.

Lambda Function URL

A Lambda Function URL provides the public HTTPS endpoint used by the frontend.
For a small application with one backend endpoint, this kept the architecture simple without introducing an unnecessary API Gateway layer.
I also use AWS IAM for permissions and Amazon CloudWatch for Lambda logs.



Challenges I Encountered

One challenge appeared when I attempted to configure reserved Lambda concurrency to  2 .
My AWS account had a concurrency quota that required the available executions to remain unreserved, so AWS rejected the setting.
Instead of allowing the deployment to fail, I changed the deployment script to inspect the environment and skip the reserved concurrency configuration when the account cannot support it.
I also encountered an issue while configuring CORS for the Lambda Function URL. My first configuration included  OPTIONS  in the managed method list, which was rejected. I adjusted the configuration while keeping the required request handling in the application.
Another small issue came from using:
curl ... | grep -q ...
inside a shell script using  set -euo pipefail .
 grep  could close the pipe as soon as it found a match, causing curl to report an error even when the website was healthy. I changed the verification process to save the response first and inspect it separately.
These issues were small, but they made the deployment process more reliable.



What I Learned

The biggest lesson from BriefBloom was that building a useful generative AI application requires much more than calling a model.
The model needs a clear responsibility.
The application needs:
  • Input validation
  • Structured output
  • Output validation
  • Error handling
  • IAM permissions
  • CORS configuration
  • Repeatable deployment
  • A useful interface around the generated content
I also learned that a cloud project does not need a huge architecture to demonstrate meaningful AWS engineering.
BriefBloom uses Amazon S3, AWS Lambda, Lambda Function URL, Amazon Bedrock, IAM, and CloudWatch, with each service having a clear responsibility.
There is no database because BriefBloom does not currently need persistent storage, accounts, saved projects, or prompt history.
The workflow remains intentionally simple:
Create → Generate → Download



Try BriefBloom

Live application
Creative builder
Source code
BriefBloom is intentionally not a complete marketing platform.
It focuses on one practical use of generative AI:
Take an unclear idea and give it enough shape to move forward.
That is BriefBloom:
Idea → Direction → Artifact.



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