AWS Builder Center

Weekend Creative Agent Challenge: DailySpark AI

DailySpark AI is an always-on creative agent that autonomously generates a fresh motivational micro-story, creative title, and one-line lesson every day using Amazon Bedrock, AWS Lambda, and EventBridge Scheduler, then stores the result in Amazon S3.

Vision & What It Does

What if you could return to your computer every evening and find a completely new piece of creative content waiting for you—without opening an application, writing a prompt, or clicking a button?
That is the idea behind DailySpark AI, an always-on creative agent built for the AWS Builder Center Weekend Challenge: Set Your Creative App Free.
DailySpark AI is an autonomous generative AI application that automatically creates a new motivational micro-story every day. Each generation contains three creative elements: a creative title, a short micro-story, and a one-line lesson. The generated content is automatically stored in Amazon S3, making it available whenever I return to the project.
The problem I wanted to solve was simple: most creative AI applications require users to actively open the application and provide a prompt. I wanted to reverse that interaction. Instead of the user asking the AI to create something, the AI creates something on its own and has it ready for the user.
The agent follows this flow:
Scheduled trigger → AWS Lambda → Amazon Bedrock → AI-generated creative content → Amazon S3
DailySpark AI is configured to run automatically every day at 6:00 PM IST. When the scheduled event occurs, AWS Lambda executes the application logic and sends a creative-generation request to Amazon Bedrock using Amazon Nova Micro. The generated content is then stored in an Amazon S3 object using a date-based path.
For example, one generated result was:
The Dawn of Tomorrow's Triumph
A young gardener discovers an ancient seed and patiently nurtures it until a radiant flower blooms. The story concludes with the lesson:
Every small step today plants the seed for tomorrow’s triumph.
The important part is that the creative content is designed to be generated automatically rather than requiring a user to manually initiate each generation.
How I Built It
I started by defining the core idea: a small creative application that could operate autonomously instead of behaving like a traditional prompt-and-response application.
I chose motivational micro-stories because they are small enough to generate regularly while still demonstrating meaningful creative output. I designed the Lambda function to request creative content from a foundation model and then save the generated result in Amazon S3.
One of the first major challenges was getting the generative AI model access working correctly.
Initially, I experimented with Anthropic Claude 3.5 Sonnet through Amazon Bedrock. The Lambda function successfully deployed, but the Bedrock request returned an AccessDeniedException. After correcting the IAM permissions, the error changed to an Anthropic model-use-case access requirement.
Rather than allowing that issue to block the project, I evaluated the available Bedrock inference profiles and discovered that Amazon Nova Micro was available through the APAC inference profile.
I tested the model directly using the AWS CLI with:
apac.amazon.nova-micro-v1:0
The model successfully generated creative text, so I changed the Lambda function to use Amazon Nova Micro.
The next challenge was configuring IAM correctly. The Lambda execution role needed permission to invoke the Bedrock model and write generated content to S3. I created a dedicated IAM role named DailySparkAI-LambdaRole with the required permissions for Bedrock inference and S3 object creation.
After deploying the Lambda function, I performed a functional test. The function successfully returned a response indicating that creative content had been generated and stored in S3.
I then verified the actual S3 object instead of relying only on the Lambda response. The generated file was available at:
daily/2026-08-21.txt
This confirmed the complete AI generation → Lambda → S3 workflow.
The final step was removing manual initiation from the normal workflow. I created an Amazon EventBridge Scheduler schedule with the following daily cron expression:
cron(0 18 * * ? *)
and configured the timezone as Asia/Kolkata.
I also created a dedicated scheduler IAM role that allows EventBridge Scheduler to invoke the Lambda function.
This resulted in the final autonomous architecture where the application can be triggered automatically on its schedule without requiring the user to manually start the creative generation process.
AWS Services Used / Architecture Overview
DailySpark AI uses the following AWS services:
Amazon EventBridge Scheduler — triggers the creative agent automatically every day. AWS Lambda — runs the application logic without requiring a continuously running server. Amazon Bedrock — provides access to generative AI foundation models. Amazon Nova Micro — generates the motivational creative content. Amazon S3 — stores the generated daily output. AWS IAM — securely manages permissions between the AWS services. Architecture ┌──────────────────────────┐ │ Amazon EventBridge │ │ Scheduler │ │ │ │ Every day at 6 PM IST │ └────────────┬─────────────┘ │ ▼ ┌──────────────────────────┐ │ AWS Lambda │ │ DailySparkAI │ │ │ │ Creative generation logic│ └────────────┬─────────────┘ │ ▼ ┌──────────────────────────┐ │ Amazon Bedrock │ │ │ │ Amazon Nova Micro │ └────────────┬─────────────┘ │ │ Generated │ story + title │ + lesson ▼ ┌──────────────────────────┐ │ Amazon S3 │ │ │ │ daily/YYYY-MM-DD.txt │ └──────────────────────────┘
The architecture is intentionally simple. EventBridge Scheduler provides the autonomous trigger, Lambda provides serverless execution, Amazon Bedrock and Nova Micro provide the generative intelligence, and S3 provides persistent storage.
IAM roles are used between the services so that each component receives only the permissions required for its task.
Lambda:

S3:

Eventbridge:

What I Learned
This challenge taught me that building an AI agent is not only about calling an LLM. The most important part is connecting the model to a reliable event-driven system that can operate without continuous human interaction.
I learned how to deploy and update AWS Lambda functions using the AWS CLI, configure Lambda execution roles, work with Amazon Bedrock's Converse API, and use Amazon Nova Micro for generative AI workloads.
I also learned an important lesson about cloud permissions. When the first Bedrock request failed, the error initially appeared to be a simple IAM problem. After fixing the IAM permissions, another model-specific access requirement appeared. Troubleshooting these errors helped me understand the difference between AWS identity permissions and model-specific access requirements.
Another major learning experience was working with EventBridge Scheduler. Instead of manually invoking Lambda, I configured a scheduler with a cron expression and timezone so that the application can operate independently according to its schedule.
I also learned the importance of verifying each stage of a cloud application independently. Rather than assuming that a successful Lambda response meant the entire system worked, I checked the actual S3 object and its metadata. This helped verify that the generated content was actually being persisted.
Most importantly, this challenge changed how I think about AI applications. A generative AI application does not always have to wait for a person to ask it something. By combining a foundation model with scheduling, serverless computing, and storage, it can become an always-on creative agent.
Link to the Project
The complete source code for DailySpark AI is publicly available on GitHub:
The repository contains the Lambda source code, infrastructure configuration, IAM policies, scheduler configuration, and supporting project files used to build the application.
Final Thoughts
DailySpark AI started with a simple question:
What if my creative application could create something before I even asked for it?
The answer became a small autonomous agent that runs on a schedule, uses generative AI to create something new, and stores the result for me to discover later.
That is what I found most exciting about the Set Your Creative App Free challenge. The goal was not simply to build another application that responds to a button click. It was to make the application independent enough to act on its own.
With EventBridge Scheduler triggering Lambda, Amazon Bedrock and Nova Micro providing the creative intelligence, and Amazon S3 preserving the output, DailySpark AI turns a simple generative AI experiment into an always-on creative workflow.
The best creative tool might be the one you never have to open.
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