
Weekend Creative Agent Challenge: DataCanvas AI
DataCanvas AI is an autonomous AWS agent that analyzes business data, detects trends and anomalies, and turns insights into AI-powered stories.
Weekend Creative Agent Challenge: DataCanvas AI
#agents
Building an Autonomous AI Agent That Turns Business Data Into Stories
Most dashboards are built around a simple idea: show the user the data and let them find the insights.
But what if the application could do some of that work itself?
What if it could periodically analyze the available data, identify meaningful trends and anomalies, decide which findings are worth highlighting, turn those findings into an understandable story, and have that story ready when the user returns?
That was the idea behind DataCanvas AI, my project for the AWS Weekend Creative Agent Challenge.
DataCanvas AI is an AWS-powered autonomous data storytelling agent that combines deterministic data analysis with generative AI. It processes structured business data, identifies important signals such as growth, regional performance, product performance, and anomalies, and then uses Amazon Bedrock with Amazon Nova Lite to transform those findings into a human-readable business narrative.
The project is built using AWS serverless services, with Amazon EventBridge Scheduler triggering the agent automatically.
The core idea is simple:
Don't just show me the data. Tell me what is worth paying attention to.

🎯 The Problem
Businesses generate large amounts of structured data every day.
Sales transactions, customer activity, orders, products, regions, and operational metrics can all provide valuable information. But having access to the data doesn't automatically mean that meaningful insights will be discovered.
A traditional analytics workflow usually looks something like:
Data → Dashboard → Human → Analysis → Report
A person needs to open a dashboard, examine charts, compare metrics, identify unusual behavior, understand what changed, and eventually communicate the findings.
This works, but it is still heavily dependent on manual interpretation.
I wanted to experiment with a different approach:
Data → Analysis → Insight Discovery → AI Story → Action
Instead of making the dashboard the starting point of the analysis, I wanted the agent to perform the analysis first and make the resulting story available to the user.
That became the foundation of DataCanvas AI.
🧠 What Is DataCanvas AI?
DataCanvas AI is a serverless data storytelling workflow that takes structured business data and converts analytical findings into an AI-generated narrative.
The current sample dataset contains 720 records covering business metrics such as:
- Date
- Region
- Product
- Sales
- Customers
- Orders
The agent analyzes these records and calculates several important signals:
- Total sales
- Total customers
- Total orders
- Sales growth
- Customer growth
- Order growth
- Top-performing region
- Top-performing product
- Fastest-growing product
- Recent sales trends
- Statistical anomalies
These findings are then passed to Amazon Bedrock.
Amazon Nova Lite uses the structured findings to generate a story containing:
- Title
- Theme
- Insight
- Why it matters
- Recommended action
- Anomaly explanation
The result is stored in Amazon S3 and exposed through an API that powers the dashboard.
The important architectural principle is:
Deterministic code calculates the facts. Generative AI explains the facts.
🏗️ Architecture

The entire application is built as a serverless workflow.
At a high level:
Amazon EventBridge Scheduler │ ▼ AWS Lambda DataCanvas Agent │ ▼ Amazon S3 Source Dataset │ ▼ Data Science Analysis │ ┌─────┼─────┐ ▼ ▼ ▼ Growth Trends Anomalies │ │ │ └─────┼─────┘ ▼ Structured Findings │ ▼ Amazon Bedrock Amazon Nova Lite │ ▼ Generated Story │ ▼ Amazon S3 Latest + Historical Output │ ▼ Amazon API Gateway GET /latest │ ▼ Read-Output Lambda │ ▼ AWS Amplify Web DashboardI intentionally kept the architecture relatively simple.
There is no traditional server or continuously running backend. Each AWS service has a specific responsibility, which makes the system easier to understand and extend.
☁️ AWS Services Used
AWS Service | Purpose in DataCanvas AI |
|---|---|
Amazon S3 | Stores the source dataset and generated AI outputs |
AWS Lambda | Performs data analysis and orchestrates the AI workflow |
Amazon Bedrock | Provides the foundation-model inference layer |
Amazon Nova Lite | Generates the business narrative from analytical findings |
Amazon EventBridge Scheduler | Automatically triggers the agent |
Amazon API Gateway | Provides the GET /latest API endpoint |
AWS Amplify | Hosts and serves the frontend dashboard |
Amazon CloudWatch | Provides Lambda execution logs and monitoring |
AWS IAM | Controls permissions between AWS services |
The combination of these services allowed me to build the complete workflow without managing traditional infrastructure.
🗄️ Amazon S3: The Data Layer
Amazon S3 acts as both the input data layer and part of the application's persistent output layer.
The source dataset is stored in an S3 bucket and retrieved by the DataCanvas AI Lambda function whenever the agent executes.
The dataset contains business records representing sales activity across different dates, regions, and products.
The current dataset contains:
720 records
The agent also stores its generated results in S3.
Instead of simply returning the AI response and losing it after the Lambda execution ends, the application persists the output.
The workflow maintains:
outputs/latest.jsonfor the most recent story and also stores historical outputs using dated filenames.
This creates a basic history of the agent's generated intelligence.
That becomes particularly useful for future development because the system can eventually compare today's findings against previous executions.
⚙️ AWS Lambda: The Core Agent
AWS Lambda is the central execution engine of DataCanvas AI.
The primary Lambda function performs the majority of the application's backend processing.
When triggered, it executes several stages.
1. Load the dataset
The Lambda retrieves the CSV dataset from Amazon S3.
2. Analyze the data
The function processes the records and calculates the required metrics.
3. Identify important findings
The application determines which region and product are performing best, calculates growth rates, generates trend data, and identifies statistical anomalies.
4. Prepare the AI context
The analytical findings are converted into structured information that can be provided to Amazon Bedrock.
5. Generate the story
The Lambda invokes Amazon Bedrock using Amazon Nova Lite.
6. Parse the response
The generated response is validated and parsed into the expected structure.
7. Store the result
The final output is written back to Amazon S3.
This makes Lambda the orchestration layer connecting the data, analytics, AI, and storage components.
📊 The Data Analysis Layer
One of the most important decisions I made was to perform the numerical analysis before involving the LLM.
For the current dataset, the agent generated findings such as:
Metric | Result |
|---|---|
Dataset records | 720 |
Total sales | 2,616,505.87 |
Total customers | 72,889 |
Total orders | 38,631 |
Sales growth | 7.5% |
Customer growth | 7.52% |
Order growth | 7.77% |
Top region | South |
Top product | AI Platform |
Fastest-growing product | AI Platform |
Product growth | 8.3% |
This layer is deterministic.
The same dataset and analytical logic should produce the same numerical findings.
Only after these findings are produced does the generative AI layer become involved.
🤖 Amazon Bedrock + Amazon Nova Lite
Amazon Bedrock provides the generative AI capability of DataCanvas AI.
The project uses Amazon Nova Lite to transform the structured analytical findings into a business narrative.
Instead of sending the entire raw dataset to the model, the application provides the model with the important findings generated by the analytical layer.
For example, the model receives information indicating that:
- South is the highest-performing region.
- AI Platform is the top product.
- AI Platform has the fastest growth.
- Overall sales are growing.
- An unusual event was detected on August 15.
Nova Lite then generates the narrative around these facts.
The resulting story might explain:
What happened?
Why does it matter?
What should the business investigate or do next?
This separation is important because I don't want the LLM to be responsible for calculations that can be performed reliably using traditional data-processing techniques.
The model's strength is used where it provides the most value:
interpretation and communication.
🚨 Anomaly Detection
One of the more interesting components of the analytical pipeline is anomaly detection.
The application identifies unusual observations using statistical analysis.
During one execution, the strongest anomaly was:
Attribute | Finding |
|---|---|
Date | August 15, 2026 |
Region | South |
Product | AI Platform |
Sales | 10,623.08 |
Z-score | 5.22 |
A statistical anomaly isn't necessarily an explanation by itself.
It is a signal that something unusual happened.
This is where the combination of data science and generative AI becomes useful.
The analytical layer identifies the unusual event.
Nova Lite helps communicate why the event deserves attention and what could be investigated next.
⏰ EventBridge Scheduler: Making the Agent Autonomous
This is one of the most important parts of the project for the Weekend Creative Agent Challenge.
I didn't want the application to depend entirely on someone clicking a button.
I configured Amazon EventBridge Scheduler to invoke the DataCanvas AI Lambda automatically.
During development, I used a frequent schedule so I could quickly test the autonomous behavior.
The workflow is:
EventBridge Scheduler ↓AWS Lambda ↓Load Dataset ↓Analyze ↓Amazon Bedrock ↓Generate Story ↓Save to S3The dashboard then retrieves the latest generated story.
This changes the nature of the application.
The dashboard isn't the thing that initiates the intelligence.
The agent runs first, and the dashboard becomes the place where the result is consumed.
That is the autonomous behavior I wanted to demonstrate with this project.
🔌 API Gateway
The frontend needs a way to retrieve the latest generated story.
For this, I created an HTTP API named:
DataCanvasAPI
with the route:
GET /latestThe route invokes a separate Lambda function:
datacanvas-read-output
This Lambda reads the latest generated JSON from S3 and returns it to the frontend.
This creates a clean separation between the generation pipeline and the presentation layer.
Agent Lambda ↓Generated Output ↓S3 ↓Read Output Lambda ↓API Gateway ↓FrontendThe frontend therefore doesn't need to know how the agent works internally.
It simply requests the latest available story.
🌐 AWS Amplify: The User Experience
The frontend is hosted using AWS Amplify.
The dashboard provides a visual representation of the generated intelligence.
It includes sections for:
- Executive metrics
- Sales trends
- Top region
- Top product
- AI detection
- AI discovery
- Business context
- Recommended action
The objective was to keep the dashboard focused on decision-oriented information rather than overwhelming the user with dozens of charts.
The experience follows a simple narrative:
What happened? → What is unusual? → What did the AI discover? → Why does it matter? → What should I do next?
📸 Dashboard: Regional Performance

The first dashboard view demonstrates how DataCanvas AI communicates a regional performance story.
The system identified the South region as the strongest revenue-generating region.
Instead of simply displaying the number, the AI-generated narrative provides context around the result and suggests an area that could be investigated further.
This is the core purpose of the application:
Turn a metric into a meaningful story.
📸 Dashboard: Product Performance

Another execution focused on the AI Platform, which emerged as both the top product and fastest-growing product in the dataset.
The generated narrative emphasized the product's growth and its potential importance to future strategy.
This also demonstrates an interesting characteristic of the system.
A dataset doesn't necessarily contain just one story.
The same data can reveal different perspectives:
- Regional performance
- Product growth
- Sales trends
- Customer growth
- Anomalies
The analytical layer provides the signals, while the AI layer turns those signals into a narrative.
🛠️ Challenges I Encountered
The implementation wasn't completely straightforward, and several failures became useful learning experiences.
IAM Permissions
The first Lambda execution failed because the execution role didn't have the required S3 permissions.
The error specifically indicated that the role was not authorized to perform:
s3:ListBucketI had to update the Lambda execution role with the required permissions.
This reinforced an important AWS lesson:
AWS services don't automatically have permission to access one another.
The execution role needs explicit permissions for the resources and actions required by the function.
S3 Object Key
After fixing the IAM problem, the Lambda returned a
NoSuchKey error.The bucket was accessible, but the requested object path didn't match the actual S3 key.
Correcting the dataset path resolved the issue.
This was a useful reminder that the complete S3 object key, including its prefix, matters when retrieving an object.
Bedrock Model Invocation
The first attempt to invoke Nova Lite using the model ID resulted in a validation error because the model configuration required an appropriate inference profile.
I updated the implementation to use the appropriate inference-profile-based model identifier.
This was an important learning experience because it showed that integrating a foundation model isn't simply about knowing the model name. Understanding how the model is exposed and invoked through Bedrock is equally important.
Model Response Formatting
The model also returned a response wrapped in Markdown code fences rather than clean JSON.
The application detected that the response wasn't directly parseable and used fallback parsing.
This led to another important lesson:
Generative AI output should always be treated as variable.
Applications need validation and error handling around model responses.
📚 What I Learned
The biggest lesson from DataCanvas AI is that an AI application is much more than an LLM API call.
The complete workflow looks like:
Data → Storage → Processing → Analysis → AI → Validation → Persistence → API → UI
Every layer contributes to the final experience.
I also learned that deterministic analytics and generative AI complement each other extremely well.
Traditional code is better suited for:
- Calculations
- Aggregation
- Ranking
- Statistical analysis
- Anomaly detection
Generative AI is better suited for:
- Interpretation
- Summarization
- Narrative generation
- Context
- Communicating recommendations
Combining the two gives each technology a role where it performs best.
Another important lesson was around autonomy.
An LLM call alone doesn't make an application autonomous.
The autonomous behavior comes from the complete workflow:
Scheduled trigger → Data retrieval → Analysis → AI generation → Persistence → Presentation
That orchestration is what turns an AI feature into an AI-powered system.
🔮 What's Next?
DataCanvas AI is currently a prototype focused on demonstrating the core autonomous workflow.
There are several areas I would like to explore next.
User-uploaded datasets
Allow users to upload their own CSV files and automatically profile the structure.
Automatic dataset profiling
The agent could identify numerical, categorical, and time-series fields and select appropriate analytical techniques automatically.
Multiple data sources
The system could eventually connect to databases, APIs, data warehouses, and other business systems.
Historical reasoning
Instead of treating every execution independently, the agent could compare current findings with previous outputs.
For example:
"The South region has remained the highest-performing region for the last six reporting cycles."
Feedback-driven storytelling
Users could provide feedback on generated stories, allowing future versions to prioritize the types of insights users find most useful.
More autonomous analysis
The longer-term vision is for the agent to determine not only what story to tell, but also what analysis should be performed based on the characteristics of the incoming dataset.
🎯 Why I Built It
There are already countless dashboards that can display sales, revenue, customers, orders, and charts.
I wanted to explore a different interaction model with data.
Instead of:
"Here is your dashboard. Find something interesting."
I wanted:
"I analyzed the data while you were away. Here's what you should know."
That distinction is what motivated DataCanvas AI.
The dashboard is ultimately only the presentation layer.
The interesting part happens behind it:
Data arrives ↓Agent executes ↓Data is analyzed ↓Important signals are identified ↓Nova generates a story ↓Result is stored ↓Dashboard presents itThe user doesn't have to manually initiate every analysis.
🏁 Final Thoughts
The AWS Weekend Creative Agent Challenge gave me an opportunity to explore a question I've been increasingly interested in:
What if AI applications could proactively discover useful information instead of waiting for users to ask?
DataCanvas AI is my first attempt at answering that question.
It combines data science, generative AI, and AWS serverless architecture to create an autonomous workflow that analyzes business data, identifies meaningful signals, generates a narrative, stores the result, and makes it available through a web application.
The project isn't intended to replace a complete enterprise BI platform.
Instead, it explores a different layer on top of analytics:
proactive storytelling.
The idea is simple:
Data comes in.
The agent analyzes it.
Important signals are discovered.
Nova explains them.
The story is saved.
And the result is waiting when you return.
For me, that's where autonomous AI becomes particularly interesting.
Not just answering questions about data.
But proactively discovering which questions are worth asking in the first place.
🔗 Try DataCanvas AI
🌐 Live Application
💻 Source Code
🛠️ Technology Stack
AWS Lambda • Amazon S3 • Amazon Bedrock • Amazon Nova Lite • Amazon EventBridge Scheduler • Amazon API Gateway • AWS Amplify • Amazon CloudWatch • AWS IAM • Python • JavaScript • HTML/CSS
#AWS #AmazonBedrock #AmazonNova #GenerativeAI #AI #Agents #Serverless #AWSLambda #AmazonS3 #EventBridge #APIGateway #AWSAmplify #DataScience #DataAnalytics #DataStorytelling #agents
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article