
Weekend Creative Challenge: Flux Studio
I am a painter who spent the weekend building a machine that paints: a browser-based generative poster studio with four drawing modes, reproducible seeds, and print-resolution export. It is my first project deployed on AWS.
I am an artist by passion and a junior software developer by trade. I have
spent years with paints, brushes and canvas. This weekend I tried something
that turned that around: instead of painting, I built a machine that paints.
It is called Flux Studio, and it runs entirely in a browser tab.
Live app: https://main.d2y0qenbuka0ju.amplifyapp.com
Source: https://github.com/zainabAntri/-creative-app

Vision and what the app does
Flux Studio turns a short seed — something like
4X7Q-B2NM — into a poster.
You push six sliders around, pick a palette, and it draws. Then you download it
as a PNG big enough to actually print.The rule I set for myself was simple: the output has to be something I would
put on a wall. A lot of generative art toys make pretty noise on a screen. I
wanted an artifact.
There are four modes, and each one behaves like a different medium:
- Flow sends thousands of particles through an invisible field and draws each one as a tapered ribbon. It looks like smoke or ink in water.
- Strata builds a layered landscape around a horizon, one ridge overlapping the next, like cut paper.
- Bloom grows filaments outward from a single point.
- Lattice lays out a grid of geometric shapes — much closer to Swiss poster design than to anything organic.
Two decisions shaped everything else.
The same seed always gives the same poster. Nothing in the drawing code is
allowed to use plain randomness. Every choice — where a particle starts, what
colour it takes, even the shape of the noise field itself — comes from a seeded
random number generator. So a seed is not a suggestion. It is the whole poster,
written down. If you make something you love, you can get it back.
There is no backend. Because the entire composition fits into a few dozen
characters, I put it in the URL. Share the link and the other person's browser
rebuilds your exact poster. No database, no login, no server. The URL is the
save file. The first time that worked I sat there grinning at it.
How I built it
I paired with Claude Code for this. I picked the concept, I made the design
calls, and I made it explain every single step to me in my own language — I was
not willing to publish code I could not explain. That turned out to be the real
work. Not typing. Judging.
The first version I got back was bad. Not broken — bad. Flow looked like
spaghetti. Lattice looked like confetti someone had spilled. Every poster used
all five palette colours in equal amounts, which reliably produces mud. I have
mixed enough paint to know exactly what that looks like.
So I sent it back. Three changes fixed it, and none of them were really
programming problems:
One colour has to lead. Instead of picking evenly from the palette, each
poster now chooses one dominant colour used about 60% of the time, a supporting
colour at 25%, and an accent that shows up in maybe 3% of the marks. This is
basic painting. I do not know why I expected the code to know it.
Empty space is part of the picture. Marks now cluster around a focal point
placed on a rule-of-thirds intersection, and each mark fades based on how far it
is from that point. Before this change, every poster filled the frame corner to
corner and the eye had nowhere to rest.
Ink behaves like ink. The main marks are drawn in a blend mode that
multiplies over pale backgrounds and screens over dark ones — roughly how real
ink and light actually work. That one change did more for the look than
anything else.
Two bugs I want to tell you about
The Strata mode produced a beautiful sunset landscape whose bottom third was
solid black. Each ridge was being filled all the way down to the bottom
edge so that nearer ridges would cover farther ones — but they were
semi-transparent. Twenty transparent layers stacked on the foreground and
crushed it to black. The fix was to make the ridges nearly opaque and get the
depth from a colour ramp instead. Cut paper, not watercolour.
The second one is my favourite. My text code picked black or white lettering
based on whether the palette was a dark one. That sounds reasonable and it is
wrong. The palette describes the paper. But the artwork sits on top of the
paper, and a pale palette whose foreground ridges stacked up dark swallowed my
black title completely. The title was invisible, and I only caught it because I
was looking at a screenshot.
The fix was to stop assuming and start measuring. Before drawing any text, the
app now samples twelve small patches of the canvas underneath where the text
will go, averages how bright they are, and picks the ink from that measurement.

Looking at the work
The most useful thing I built is not in the app at all. You cannot review
generative art by reading the code. You have to look at a lot of output at
once, because the failure mode is "most seeds are ugly". So we wrote a small
script that opens the app in a real browser, walks through sixteen combinations
of mode, seed and palette, and lays them out on one contact sheet. Every change
after that got judged against the sheet instead of against one lucky seed.
AWS services used and architecture overview
The app is a static bundle — about 15 kB gzipped, with no backend at all — so
the architecture is small on purpose.
GitHub (main branch)
│ git push
▼
AWS Amplify Hosting ← the service doing the work
│ npm ci → npm run build → dist/
│
├──▶ Amazon S3 stores the built files
├──▶ Amazon CloudFront serves them worldwide, fast
└──▶ AWS Certificate Manager free HTTPS
https://main.d2y0qenbuka0ju.amplifyapp.comAWS Amplify Hosting (region:
eu-north-1 , Stockholm) is the one service I
configured. It watches my GitHub repository, runs the build described in my
amplify.yml , and publishes the dist/ folder. Behind the scenes it sets up
S3 for storage, CloudFront as the CDN, and a TLS certificate — I did not touch
any of those individually, which is the whole point of using Amplify for a
project this size.It also redeploys automatically on every push. I updated my README after the
first deployment, pushed, and watched it rebuild and go live on its own. That
was the moment CI/CD stopped being a diagram in a study guide and became a
thing that happened to me.
One small build detail worth passing on: my screenshot script depends on
Playwright, and Playwright's install step downloads a ~150 MB browser that the
hosting build has no use for. Setting
PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD=1 in
the preBuild phase keeps the build quick.All of this sits inside the AWS Free Tier. Amplify's free allowance covers
1,000 build minutes and 15 GB served per month. A 15 kB bundle and one-minute
builds are not going to trouble that.
What I learned
A certificate is not the same as shipping. I am an AWS Certified Cloud
Practitioner. I could define S3, CloudFront and CI/CD before this weekend. I had
never actually deployed a web page to AWS. Connecting the repository to Amplify
took about ten minutes, and most of that was me reading carefully because I was
nervous. The gap between knowing what a service is and having used it once is
much bigger than I expected — and much easier to close.
Painting is easier than programming. I mean this honestly. Brushes and
paints feel easy compared to a keyboard. With paint, my hand knows what I want
before I do. In code I have to say it out loud, exactly, and then find out I
said it slightly wrong. What surprised me is that the hard part of this
project was not the code at all — it was looking at output and admitting it was
ugly. There is no test for ugly.
Breaking things and fixing them is the job. I used to think bugs meant I had
done something wrong. This weekend I found the black landscape, the invisible
title, and a shape that escaped its own frame — and fixing each one taught me
something real about how drawing on a canvas actually works. That is
programming. I genuinely enjoyed it.
Constraints made the app better. Refusing to add a backend forced me to put
the composition in the URL, and that turned out to be nicer than a database
would have been. It is instant, it costs nothing, and nobody has to sign up.
I am very happy to have my first project deployed on AWS. It is a small app,
but it is live, it is mine, and it makes things I would hang on a wall.
Try it: https://main.d2y0qenbuka0ju.amplifyapp.com
Code: https://github.com/zainabAntri/-creative-app
Built with TypeScript, HTML Canvas and Vite. Hosted on AWS Amplify.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article