AWS Builder Center
Weekend Creative Challenge: Infinite Mashup Studio

Weekend Creative Challenge: Infinite Mashup Studio

What happens when impossible ideas collide? Infinite Mashup Studio transforms the unexpected into unforgettable creations. Mix anything, explore limitless imagination, and discover amazing inventions, creatures, and stories with every mashup

AI Engineer | Autonomous Systems, Quant Analysis & Neural Decoding
Welcome to Infinite Mashup Studio, where ordinary ideas transform into extraordinary creations. What happens when a phoenix meets an octopus? Or when a castle collides with a coffee cup? This isn't just another AI generator, it's a place where imagination runs wild. Every fusion creates a one-of-a-kind masterpiece complete with stunning visuals, rich storytelling, unique abilities, and a world waiting to be explored. No two mashups are ever the same, making every creation a new journey into the impossible.

Vision

I did not want another prompt box that dumps a paragraph. I wanted a studio where authorship is selection, not typing. You commit to a small set of ingredients; the system has to invent a single thing that could not exist without that collision then treat that thing as if it already had a history, a body, and a paper trail.
Constraint is the mechanism. A daily locked trio (UTC date seed, identical worldwide) makes the dare communal: the same three chips, different fusions. A catalog allow list stops the session from collapsing into whatever prompt is trending. Sandbox exists for a different kind of authorship you bring your own mix, including up to two photographs without turning the product into an unrestricted image chatbot.
The other half of the vision is integrity of the artifact. If Bedrock cannot produce a real illustration, the job fails. SVG clip-art, collage placeholders, and “success” cards with dummy art would have been a different app. Words come after pixels: Nova Pro is given the PNG and must describe that image, not a parallel fantasy. Identity is part of the vision, not a bolt-on. The daily board is public knowledge; the inventions are not. Cognito-backed private galleries, a hard ten fuses per UTC day, and sign-out back to login keep the studio from becoming a dump of everyone else’s creatures. Shared constraint, private output.


What the app does

Infinite Mashup Studio is a generative invention studio. A session is a composition of catalog ingredients animals, foods, places, tools, myths, and the rest of the allowlist optionally mixed with up to two photographs from camera or upload. Daily mode freezes three ingredients from a UTC date seed for every player on that calendar day, with at most two extra chips. Sandbox mode is two to five chips of the player’s choosing, with or without photos. Fuse is the only generative action: those inputs become one invented subject (creature, object, or concept) whose image and lore are produced on AWS, stored per account, and shown on a result page. Remix starts a new fuse from a related composition. Translate localizes an existing dossier. Gallery, quota, notifications, and mail are around that loop; they are not the product.


Creative output it produces.
Each fuse yields one mashup as a finished creative work, The centerpiece is an original illustration of that invention, a single cinematic image of the fused subject, not the ingredients sitting next to each other.
Around that image is a written world for the same invention, in several registers: an origin story; what it can do; how it behaves; short facts; a mock advertisement; a warning label; a scientific classification; a mock patent. The writing is meant to read as if the thing already existed myth, character, satire, hazard copy, taxonomy, and a fake legal claim all about the picture on screen.
The origin is also produced as spoken audio, so the piece has a voice. The writing can be translated so the same invention can be read in another language without changing the art. Remix produces a new illustration and a new body of writing, a second work rather than a tweak of the first.
That is the output the challenge is asking about: a mashup image, a multi-register story world, and a reading of the origin one invented thing, fully dressed.

(Selection, Result, Story Cards):  Users choose 2–5 ingredients, fuse them into a brand-new creation, and instantly receive AI-generated artwork, an origin story, abilities, personality, fun facts, and more, all in one immersive creative experience.


How I built it

Development process
The product was built as two planes that never mixed credentials. The studio UI (Next.js 15, TypeScript, Tailwind, Framer Motion) is composition: catalog chips, daily seed, sandbox photos, Fuse, result. The generative plane is one SAM stack in us-east-1 HTTP API, a single Python 3.12 Lambda, DynamoDB, S3 because image + vision JSON + Polly does not fit inside an API Gateway timeout. The HTTP contract is therefore a job, not a response body.
Start_job authenticates, validates catalog IDs, writes  JOB#PENDING , and invokes the same function with  InvocationType=Event . The worker is a linear pipeline: optional photo objects at  jobs/{id}/photo-N.jpg , Stability PNG, Nova Pro with that PNG in Converse, Polly on the origin, then S3 ( mashups/{id}.png|.mp3|.json ) and  MASHUP#  plus GSIs. The browser polls  /jobs/{id}  until  COMPLETE  and routes to  /m/{id} . The UI host moved Amplify → Netlify; the SAM stack did not move with it.
```text
compose (chips / photos)
|
v
Browser --POST /fuse--> API GW --> Lambda start_job
| put JOB#PENDING
| Event invoke
v
Lambda worker
+-------------+-------------+
| PNG (west) | JSON (east) |
| Polly MP3 | S3 + DDB |
+-------------+-------------+
|
Browser <--GET /jobs/{id}-- COMPLETE --+--> /m/{id}
mermaid
sequenceDiagram
participant B as Browser
participant N as Next.js proxy
participant G as API Gateway
participant S as Lambda start
participant D as DynamoDB
participant W as Lambda worker
participant I as Bedrock image west
participant T as Nova Pro east
participant P as Polly
participant O as S3
B->>N: POST /fuse JWT + ingredient IDs
N->>G: HTTPS
G->>S: start_job
S->>D: JOB#PENDING
S-->>W: Invoke Event
S-->>B: jobId
W->>I: Stability Ultra then SD3.5 then Core
I-->>W: PNG
W->>T: converse PNG + prompt
T-->>W: dossier JSON
W->>P: origin neural
P-->>W: MP3
W->>O: png mp3 json
W->>D: MASHUP# GSIs JOB COMPLETE
loop poll
B->>G: GET /jobs/id
G-->>B: PENDING or COMPLETE
end

(Sandbox feature, Dashboard, Email, Gallery):  Infinite Mashup Studio transforms impossible combinations into original creations with a polished creative workflow, from selecting ingredients to receiving your finished mashup, managing your gallery, and sharing your imagination.

Key decisions
Allowlist on the wire. The Lambda never accepts free-text ingredients. Unknown IDs 400. That is the game design and the injection boundary in one check.
Pixels before prose. The dossier is not a second imaginative pass. Nova Pro’s user message contains the PNG bytes. If the image is a frog-violin chimera, the origin cannot describe a typewriter golem. Failed image gen fails the job; there is no decorative stand-in.
UTC seed, not a config table. Daily trio is  hash(UTC date) → catalog . Same chips worldwide without an admin row.
Ownership is  sub , not “latest items.”  userId  and GSI  USER#{cognito-sub}  are the gallery and the daily cap.  DATE#ALL  is not a public feed.
Keys stay on AWS. Next.js  /api/*  is a proxy. The browser holds a Cognito JWT, not Bedrock credentials.
```text
[chips] --IDs only--> Lambda --reject unknown-->
[photos] --> S3 job prefix --> image-to-image / vision prompt
|
v
PNG ------------------+
| converse(image + text)
v
dossier JSON --> Polly origin
|
v
MASHUP# gsi3 = USER#{sub}
```mermaid
flowchart TB
subgraph decision_image [Image first]
ST[Stability PNG] --> NV[Nova Pro with PNG in Converse]
NV --> DS[Eight-register dossier]
DS --> PL[Polly origin MP3]
end
subgraph decision_own [Ownership]
CG[Cognito JWT sub] --> ROW[userId on MASHUP]
ROW --> G3[GSI USER sub]
G3 --> GAL[Gallery and daily cap]
end
subgraph decision_edge [Edge]
BR[Browser] --> NX[Next.js /api proxy]
NX --> AG[API Gateway]
AG --> LM[Lambda IAM to Bedrock]
end
```
Challenges encountered, and how they were overcome
Canvas / Titan dead on the account.  InvokeModel  for Nova Canvas and Titan Image returned EOL / unused-legacy. The worker grew a second client,  bedrock_west , and a fallback chain in us-west-2:  stability.stable-image-ultra-v1:1  →  stability.sd3-5-large-v1:0  →  stability.stable-image-core-v1:1 . Gemini image was a last resort and 429’d on depleted prepaid credits, so it is not on the live path. Nova Pro stayed in us-east-1 and still sees the PNG.
Wrong partition key hid sandbox.  gsi1pk = DATE#sandbox  meant Today could not see sandbox fuses. Index is always  DATE#{UTC date} ;  mode  is an attribute.
Gallery was a global scan. Unsigned list now returns empty; signed-in list is  byUser  only.
Quota drifted from reality. A separate  QUOTA#  counter disagreed with rows. The cap is now a count of that  sub ’s mashups whose  createdAt  is the UTC day.
SES From Gmail fails Gmail DMARC. Completion still has to land: browser Notification API. Inbox needs a domain + SPF/DKIM; that is unfinished, not faked.
Amplify dropped  FUSE_API_URL  in route handlers. UI moved to Netlify. Windows  netlify deploy  failed renaming  .next ; Linux Docker deploys are the release path.
```text
us-east-1 Lambda
| Canvas X Titan X
| Nova Pro converse (PNG in) OK
v
bedrock_west us-west-2
Ultra --fail--> SD 3.5 Large --fail--> Core --fail--> job FAILED
gsi1 DATE#sandbox X --> DATE#YYYY-MM-DD + attr mode
gallery DATE#ALL public X --> USER#{sub} or []
```

AWS services used

Service
Role
Amazon API Gateway HTTP API
 /fuse ,  /jobs/{id} ,  /mashups/{id} ,  /gallery ,  /quota ,  /translate 
AWS Lambda
Start job + ~180s worker (image, JSON, audio, persistence, mail)
Amazon DynamoDB
Jobs, mashups, TTL rate keys, profiles; GSIs  byDate ,  byAll ,  byUser 
Amazon S3
 mashups/{id}.png ,  .mp3 ,  .json ; job photos
Amazon Bedrock
Stability image (us-west-2); Nova Pro vision JSON (us-east-1)
Amazon Polly
Origin narration (Ruth, neural)
Amazon Translate
Dossier localization
Amazon Cognito
Email pool,  USER_PASSWORD_AUTH 
Amazon SES
Ready-mail, digest
Amazon EventBridge
 cron(55 23 * * ? *)  digest
AWS SAM / CloudFormation
Stack  infinite-mashup-studio 
IAM
Bedrock, Polly, Translate, SES, Cognito GetUser, S3, DynamoDB,  lambda:InvokeFunction 

Architecture overview

```text
Browser (Cognito JWT)
-> Netlify Next.js /api/*
-> API Gateway HTTP API
-> Lambda (sync start, async worker)
-> Bedrock us-west-2 Stability (PNG)
-> Bedrock us-east-1 Nova Pro (PNG -> JSON)
-> Polly, S3, DynamoDB, SES
EventBridge 23:55 UTC -> Lambda digest
```
```mermaid
flowchart LR
U[Browser] -->|JWT + Fuse POST| N[Netlify Next.js]
N -->|HTTPS| AG[API Gateway HTTP API]
AG --> L[Lambda]
L -->|async invoke| L
L -->|Stability image| BW[Bedrock us-west-2]
L -->|Nova Pro vision JSON| BE[Bedrock us-east-1]
L --> P[Polly]
L --> S3[S3]
L --> DDB[DynamoDB]
L --> SES[SES]
EB[EventBridge 23:55 UTC] -->|digest| L
C[Cognito] -.-> U
```

```python
for model_id in (
"stability.stable-image-ultra-v1:1",
"stability.sd3-5-large-v1:0",
"stability.stable-image-core-v1:1",
):
response = bedrock_west.invoke_model(
modelId=model_id,
body=stability_body,
accept="application/json",
contentType="application/json",
)
```
```python
result = bedrock.converse(
modelId=TEXT_MODEL,
system=[{"text": SYSTEM}],
messages=[{
"role": "user",
"content": [
{"image": {"format": "png", "source": {"bytes": png}}},
{"text": prompt},
],
}],
)
```

What I learned

  • The useful lessons were about where generative work actually lives in an AWS system, not about wiring a hello-world Lambda.
  • Bedrock is a capability surface with regional and product gaps, not a single “generate” switch. Image and language are different contracts ( InvokeModel  vs  converse ), different regions, and different failure modes. Grounding language in the PNG is an architectural choice: the creative object is one invention, so vision-conditioned JSON is how you keep lore and pixels as the same work. Fallback chains (Ultra → SD 3.5 → Core) are product reliability, not a model bake-off.
  • Long-running synthesis does not belong on a synchronous HTTP deadline. Treating Fuse as a job persist pending, async self-invoke, poll to complete is how you tell the truth about generation time and still use API Gateway. The UI is a client of that state machine, not a place that waits on Bedrock.
  • Access patterns are the product. Partition keys decide whether Today, sandbox, and a private gallery even exist. A GSI that encodes mode instead of calendar date hides work. A GSI that encodes “everyone” is a different application than one that encodes sub. A quota that is not derived from the same rows as the gallery will disagree with the user.
  • Allowlist on the wire The Lambda never accepts free-text ingredients. Unknown IDs 400. That is the game design and the injection boundary in one check.
  • Pixels before prose The dossier is not a second imaginative pass. Nova Pro’s user message contains the PNG bytes. If the image is a frog-violin chimera, the origin cannot describe a typewriter golem. Failed image gen fails the job; there is no decorative stand-in.

Link to app or repo

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