Weekend Showcase Challenge: CloudPulse — Your Autonomous AWS Builder Companion
CloudPulse started as an autonomous agent that generated a fresh AWS project idea every day. For the Summer Showcase, I evolved it into a builder companion that generates, evaluates, and turns ideas into actionable AWS challenges.
Weekend Showcase Challenge: CloudPulse — Your Autonomous AWS Builder Companion
What if you could open your laptop every morning and already have something interesting to build?
That question led me to build CloudPulse, an autonomous AI-powered project idea engine for AWS builders.
During the earlier Weekend Creative Agent Challenge, I built CloudPulse to solve a problem I repeatedly see among students and developers: they want to build on AWS, but often get stuck before writing their first line of code.
The hardest part isn't always learning a new AWS service. Sometimes it's simply deciding what to build.
CloudPulse was my attempt to solve that blank-page problem.
For the Summer Builds Showcase, I decided not to start from scratch. Instead, I went back to CloudPulse, polished the original idea, and pushed it toward something more useful: an autonomous AWS builder companion.
From Idea Generator to Builder Companion
The original version of CloudPulse had one primary responsibility: automatically generate a new AWS project idea every day.
It used an EventBridge Scheduler to wake up the application, invoke a Lambda function, send a structured prompt to Amazon Bedrock, generate an idea using an Amazon Nova model, validate the response, and store the result in DynamoDB.
That already worked well, but I wanted to take the concept one step further.
A project idea by itself isn't always enough.
A builder also needs to know:
- Is this idea actually useful?
- How difficult is it?
- What AWS services should I learn?
- Where should I start?
- What would the architecture look like?
- What should I build first?
So the showcase version focuses on turning a simple idea into something closer to a buildable challenge.
Instead of simply saying:
"Build an AI-powered application for students."
CloudPulse can provide context around the problem, recommended AWS services, an architecture direction, difficulty, features, and an implementation roadmap.
The goal is to reduce the distance between "I want to build something" and "I know what I'm building next."
How CloudPulse Works
CloudPulse is designed to operate autonomously.
A scheduled EventBridge trigger starts the generation workflow.
The flow is:
EventBridge Scheduler → AWS Lambda → Amazon Bedrock → Validation & Logic → DynamoDB
The stored project can then be accessed by the web application through an API layer.
For each generation, CloudPulse provides structured information such as:
- Project name
- Problem statement
- Target users
- Key features
- Recommended AWS services
- Architecture concept
- Difficulty level
- Implementation roadmap
The system also considers previously generated projects so that it can avoid producing the same type of idea repeatedly.
This was particularly important because an autonomous generator can easily become repetitive if every request is treated independently.
Designing for Creativity
One of the most interesting engineering problems was figuring out how to make the generated projects diverse.
Instead of asking the model for a completely random project every time, I introduced multiple dimensions that can change between generations.
These include:
- Difficulty level
- Industry
- User type
- Problem domain
- AWS architecture pattern
- Technology combination
This allows CloudPulse to move between different categories of projects rather than continuously generating variations of the same CRUD application.
One day the idea might focus on an event-driven architecture.
Another could involve generative AI.
Another might explore monitoring, automation, data processing, or a community-focused application.
The objective is not simply to generate more ideas.
It is to generate ideas that make builders want to actually open their editor and start building.
AWS Architecture
The architecture intentionally remains lightweight and serverless.
EventBridge Scheduler │ ▼ Lambda │ ▼ Amazon Bedrock Amazon Nova │ ▼ Validation & Logic │ ▼ DynamoDB │ ▼ API Gateway │ ▼ Web ApplicationThe main AWS services used are:
Amazon Bedrock — Provides access to generative AI models for creating project concepts.
Amazon Nova — Generates the project concepts and supporting content.
AWS Lambda — Handles the serverless application logic and orchestration.
Amazon EventBridge Scheduler — Allows CloudPulse to run automatically on a schedule without requiring a user to initiate generation.
Amazon DynamoDB — Stores generated projects and provides persistent storage.
Amazon API Gateway — Provides the API layer between the web application and backend services.
Amazon S3 — Hosts static application assets.
AWS IAM — Controls permissions between the different AWS components.
Because the system is serverless, there is no traditional application server that needs to remain running continuously.
The Importance of Validation
One lesson from building an autonomous AI system is that generating text is only one part of the problem.
When a person is using an AI chatbot, they can look at the response and decide whether it makes sense.
CloudPulse is different.
It can run while nobody is watching.
That means the application needs to treat model output as something that must be validated before it becomes application data.
The generated response needs to follow the expected structure before being stored and displayed.
This separation between AI generation and application logic became an important design principle for me.
The model is responsible for creativity.
The application is responsible for structure, validation, storage, and delivery.
What I Learned Across the Summer
CloudPulse has also been a reflection of what I learned throughout the Summer Builds series.
I started by thinking primarily about what an AI model could generate.
Over time, I started thinking more about what needs to surround the model to make an AI application reliable.
I learned how serverless services can be combined to create applications that operate without constant human interaction.
I learned how EventBridge can turn a normal application workflow into an autonomous scheduled process.
I learned how Amazon Bedrock and Amazon Nova can become part of a larger application rather than simply being used as a chatbot backend.
I also learned that AI-generated output needs boundaries.
Good AI engineering isn't only about getting an impressive response from a model. It's about designing the system around that model so the overall application remains predictable, useful, and maintainable.
Most importantly, I learned to think about applications as systems rather than individual features.
What's Next for CloudPulse?
There is still a lot I want to explore.
Future versions could allow builders to rate ideas, save their favorite projects, personalize recommendations based on their AWS experience, generate architecture diagrams, estimate complexity and cost, track implementation progress, and create personalized challenges.
The longer-term idea is bigger than an idea generator.
I want CloudPulse to become an AI companion for builders — something that continuously discovers interesting problems, proposes projects, helps plan them, and encourages people to actually build.
The best AI application might not always be the one you have to open and ask a question.
Sometimes, it might be the one that has already prepared something useful before you arrive.
Try CloudPulse
CloudPulse is built as a practical demonstration of how generative AI, serverless computing, scheduled automation, and persistent storage can work together to create an application that keeps working even when nobody is interacting with it.
This project started as an experiment in autonomous idea generation.
For the Summer Showcase, it became an experiment in something I find even more interesting:
Can AI help builders overcome the hardest part of building — getting started?
That is what I want CloudPulse to explore.
A big thank you to the AWS Builder Center community and everyone who participated in the Summer Builds series. The challenges gave me a reason to keep experimenting, shipping, and turning small ideas into working AWS projects.
And a special shoutout to @Lewis Sawe for inspiring me with The Museum That Grows and showing how an autonomous agent can continuously create something without waiting for a human prompt.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article