AWS Builder Center
Weekend Creative Challenge: Flux Studio

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.

Frontend, generative art, and 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.
A grid of sixteen posters generated by Flux Studio, four each from the Flow, Strata, Bloom and Lattice modes, across six colour palettes.




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.



A generative poster on a cream background with teal and pink geometric shapes in a grid, its FLUX title set in black — the ink colour chosen by measuring the artwork beneath it.




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.com
AWS 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.


Built with TypeScript, HTML Canvas and Vite. Hosted on AWS Amplify.
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