AWS Builder Center
Weekend Creative Challenge: Whimsy Scraps

Weekend Creative Challenge: Whimsy Scraps

Whimsy Scraps turns everyday keepsakes into whimsical art-journal prompts, helping creators find a story in the small things they cannot throw away

Technical Product Consultant

A tiny story for the scraps you cannot throw away

Whimsy Scraps was built for the AWS Builder Center Creative App Weekend Challenge, inspired by a small creative problem I often have myself.
I keep little things: a dried flower, an old ticket, a postage stamp, a ribbon, a torn book page. They feel too meaningful to throw away, but they often stay in a drawer because I do not know what to make with them.
Whimsy Scraps is my answer to that problem: a small creative companion for art journalers, scrapbookers, and anyone who needs a spark of inspiration. Instead of generating a finished piece of art, it helps people see a possible story in the materials already sitting on their desk.

What the app does

The experience is deliberately simple:
  1. Enter the scraps or items you have.
  1. Choose a mood:
  • Dreamy
  • Nostalgic
  • Playful
  • Mysterious
  • Surprise me
  1. Select Create My Journal Idea.
  1. Receive one complete creative direction.
Each result includes:
  • A whimsical page title
  • A creative theme
  • A writing or drawing prompt
  • A suggested use for every scrap
  • One playful creative rule
For example, a dried flower might become a forgotten keepsake. A vintage stamp might become a clue in an imaginary letter. An old book page might become the background for a tiny world.
The app gives the creator a starting point, but the page remains handmade and personal. That was important to me: AI should provide the spark, not replace the creative process.

Building the experience

I wanted Whimsy Scraps to feel more like opening a small art journal than opening another AI tool.
The frontend is built with React and Vite. I used a warm paper-like background, handwritten-style accents, collage-inspired cards, tape details, and playful copy to make the interface feel tactile and whimsical.
I also kept the product intentionally focused. The complete product is one useful loop:
Scraps → creative prompt → handmade journal page
Keeping that scope small helped me spend time on the actual experience rather than extra features.

Making the AI response reliable

The backend returns a structured response rather than a long block of AI text.
Every generated idea contains the same core fields:
title
theme
prompt
scrapIdeas
whimsicalRule
This keeps the frontend predictable while letting the creative output stay varied.
The app can respond differently to the same scraps depending on the mood selected. A dried flower and blue ribbon might become part of a dreamy lost-letter story one time, then become props for a playful tiny picnic another time.

AWS architecture

Whimsy Scraps uses three AWS services:
  • AWS Amplify Hosting hosts the public React frontend.
  • AWS Lambda receives the scraps and mood, validates the request, and returns the result.
  • Amazon Bedrock, using Amazon Nova Lite, generates the creative journal direction.
The architecture is intentionally small:
Creator enters scraps + mood
↓
React / Vite app on AWS Amplify
↓
AWS Lambda Function URL
↓
Amazon Bedrock — Amazon Nova Lite
↓
Whimsical journal idea appears in the browser
AWS Amplify deploys the frontend directly from my GitHub repository. Lambda keeps the Bedrock logic away from the browser, so the frontend never needs AWS credentials.

What I learned

The most valuable lesson came during testing.
The Lambda Function URL worked when called directly, but the browser initially could not load the result. Instead of changing everything at once, I tested each layer separately:
  1. I ran a Lambda test execution.
  1. I used a direct  curl  request against the Function URL.
  1. I confirmed that Lambda could call Bedrock correctly.
  1. I narrowed the issue to the frontend configuration and CORS settings.
The fix was updating the Vite Function URL configuration and allowing the deployed frontend origin in Lambda CORS.
That process reinforced a simple lesson: when a serverless application fails, test the frontend, endpoint, Lambda function, and model response independently. It makes the real problem much easier to find.
Try Whimsy Scraps
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