AWS Builder Center
Weekend Creative Challenge: Idea → Universe

Weekend Creative Challenge: Idea → Universe

What if one strange idea could become an entire fictional universe? Idea → Universe turns a simple thought into a world with rules, characters, places, conflicts, secrets, and possibilities.



Idea → Universe

I wanted to build something where the user doesn't need to know what to create.
They just need an idea.
That became Idea → Universe, a creative web application that takes a simple thought and turns it into an entire fictional universe.
You could enter something like:
A college where nobody can lie.
Or:
A city that moves to a different planet every midnight.
Or even:
A vending machine that sells memories.
The idea is the seed. The application builds the world around it.
Instead of generating only a story, Idea → Universe creates things like a world's rules, important places, characters, conflicts, secrets, and possible future events.
The main idea behind the project is simple:
One idea → an entire universe.

Why I Built It

There are already many creative applications that generate stories, poems, images, and other content.
I wanted to try something slightly different.
What if the user's input wasn't the story itself?
What if it was just the beginning?
For example, if someone enters:
A school where students can remember the future.
There are so many questions that can come from that one sentence.
What happens when two students remember different futures?
Who controls the school?
Can the future actually be changed?
What happens to someone who remembers something that never happens?
That is the kind of exploration I wanted the application to encourage.
Instead of giving the user one final answer, Idea → Universe gives them a fictional world to explore.

What The App Does

The interface is intentionally simple.
The user enters an idea and can choose a genre and tone, or leave them on Auto.
Then they click Create Universe.
The application organizes the generated concept into different parts of a fictional world:
  • World — what the universe is like
  • Rules — unusual laws that control it
  • Places — important locations
  • Characters — people living inside the world
  • Conflict — the main problem
  • Secret — something hidden inside the world
  • Future — where the universe could go next
I wanted the result to feel less like reading a normal AI response and more like discovering a world that didn't exist a few seconds ago.


How I Built It

I built Idea → Universe using the MERN stack.
The frontend uses React, the backend uses Node.js and Express, and MongoDB is used for storing application data.
I also decided to use Docker from the beginning.
This made it possible to keep the development environment consistent and later move the application from my Windows machine to an AWS server without manually setting up every dependency again.
The basic application flow is:
User
↓
React Frontend
↓
Express Backend
↓
MongoDB
Docker Compose manages the application and database containers together.
One thing I liked about this approach was that I could test the exact same containerized application locally before deploying it to AWS.

From Localhost To AWS

Once the application was working locally, I wanted to take it one step further and actually deploy it to the cloud.
I created an Amazon EC2 instance using Amazon Linux and deployed the Dockerized application there.
Instead of installing the entire MERN stack manually on the server, I installed Docker and ran the project using Docker Compose.
The deployment ended up looking very similar to my local environment:
Local Machine AWS EC2
Docker Compose Docker Compose
↓ ↓
MERN + MongoDB MERN + MongoDB
One of the challenges I ran into was Docker Buildx.
The Docker environment on the EC2 instance initially had an older Buildx version, which caused Docker Compose to fail during the image build.
At first it looked like an application problem, but after checking the error I realized the issue was actually with the Docker build environment.
After upgrading Buildx, the application built successfully.
Both the application and MongoDB containers were then running on the EC2 instance.
Seeing the same application that was running on my localhost become accessible through an AWS public IP was probably my favorite part of the deployment.


AWS Services Used

I intentionally kept the AWS architecture simple.

Amazon EC2

Amazon EC2 hosts the Dockerized Idea → Universe application and makes it accessible over the internet.
The basic architecture is:
User
↓
Internet
↓
Amazon EC2
↓
Docker Compose
├── Idea → Universe Application
└── MongoDB
I chose EC2 because I wanted to understand what actually happens when a web application moves from a local computer to a cloud server.
I also explored using an IAM role for the EC2 instance rather than storing long-lived AWS access keys inside the application.
This was an important security lesson for me: AWS credentials shouldn't simply be placed inside source code or committed to GitHub when an instance role can be used instead.


What I Learned

The biggest thing I learned from this challenge was that building an application and deploying an application are two different problems.
Something can work perfectly on localhost and still fail on AWS because of Docker versions, permissions, networking, security groups, or configuration.
Docker was another major learning experience for me.
I had used Docker during development, but this challenge gave me the opportunity to actually use it to move a project from my Windows machine to an AWS EC2 server.
I also became more comfortable with debugging one layer at a time.
Instead of changing everything when something failed, I started checking the system step by step:
Application
↓
Docker
↓
Docker Compose
↓
EC2
↓
Security Group
↓
Internet
That made troubleshooting much easier.
I also learned to think about cloud costs while developing. After testing the deployment, I cleaned up the AWS resources instead of leaving the EC2 instance running unnecessarily.

What's Next

This version is only the beginning.
I want to continue improving Idea → Universe by making the generated worlds more interactive.
For example, a user could choose one character and explore their story, open a location and discover what happened there, or create new events inside an existing universe.
I also want to explore adding Amazon Bedrock in a future version so that the creative engine can generate even richer and more unpredictable worlds.
The goal is still to keep the main experience simple:
Give me an idea. I'll give you a universe.

Try Idea → Universe

Source code:
Try something strange.
For example:
A college canteen becomes a spaceship every night at midnight.
Or:
Everyone in a city receives tomorrow's memories today.
Or make up something completely different.
That's where the fun starts.

Conclusion

Idea → Universe started with a simple question:
What if one sentence was enough to create an entire world?
Building it gave me the opportunity to take that idea from a local MERN project, containerize it with Docker, deploy it to Amazon EC2, troubleshoot real deployment problems, and make it accessible through the internet.
The part I enjoyed most wasn't just getting the application online.
It was seeing how a very small idea could turn into something much bigger.
One idea. Infinite possibilities.
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