AWS Builder Center
Weekend Creative Agent Challenge: AI Content Creator Agent

Weekend Creative Agent Challenge: AI Content Creator Agent

Autonomous Daily Content Generation on AWS Free Tier

Vision & What It Does

Imagine waking up every morning to find fresh, creative content waiting for you—poems, stories, blog posts, or articles—all generated automatically without you lifting a finger. That's the vision behind the AI Content Creator Agent, an autonomous, always-on application that generates creative content on a daily schedule and stores it for you to browse, read, and manage.
The problem it solves is simple yet powerful: content creators, bloggers, and marketers often struggle with consistent content generation. They need a tool that works 24/7, requires no manual intervention, and costs nothing to run. Traditional solutions require expensive subscriptions or complex infrastructure management.
The AI Content Creator Agent is different. It's a fully serverless, autonomous agent that:
  • Generates creative content daily at a scheduled time (07:00 UTC) without any user interaction
  • Supports multiple content types: poems, stories, blog posts, and articles
  • Offers customization: different styles (romantic, dramatic, humorous, formal, casual) and lengths (short, medium, long)
  • Stores everything securely in the cloud with a beautiful web dashboard for browsing
  • Costs absolutely nothing to run—everything operates within AWS Free Tier limits
The application demonstrates true autonomous functionality. Every day at 7 AM UTC, EventBridge triggers a Lambda function that generates new content, stores metadata in DynamoDB, and saves the content to S3. Users can then open the web dashboard anytime to view, read, and manage their generated content.



How You Built It

Building this application required careful planning and execution across multiple AWS services. Here's how I approached it:

Development Phases

Phase 1: IAM Setup & Security I started by creating an IAM role with least-privilege permissions. This role grants Lambda functions access only to the specific S3 bucket, DynamoDB table, and CloudWatch logs they need—nothing more. This follows AWS best practices for security.
Phase 2: Storage Provisioning Next, I created the infrastructure:
  • An S3 bucket ( content-creator-bucket-navee-2026 ) for storing generated content
  • A DynamoDB table ( ContentMetadata ) with a composite primary key (user_id + timestamp) for efficient querying
Phase 3: Lambda Function Development I wrote five Python 3.11 Lambda functions:
  1. generate_content.py - Generates creative content and stores it
  1. list_content.py - Retrieves all content from DynamoDB
  1. get_content.py - Fetches a specific piece of content
  1. delete_content.py - Removes content from storage
  1. utils.py - Helper functions for common operations
Phase 4: EventBridge Scheduling I configured EventBridge with a cron expression ( cron(0 7 * * ? *) ) to trigger the generate_content function every day at 07:00 UTC. This is the "always-on" aspect—the agent works autonomously without user intervention.
Phase 5: API Configuration I created Lambda Function URLs for each function, enabling direct HTTP access without needing API Gateway. This simplified the architecture and reduced complexity.
Phase 6: CORS Configuration Getting CORS right was critical. I configured each Lambda Function URL to accept requests from any origin with appropriate headers, allowing the frontend to communicate with the backend.
Phase 7: Frontend Development Finally, I built a responsive web dashboard using HTML, CSS, and JavaScript. The dashboard features:
  • A form to generate content with customizable options
  • A list view showing all generated content with previews
  • A modal viewer for reading full content
  • Delete functionality for content management
  • Real-time updates and error handling

Challenges Overcome

Challenge 1: Lambda Function URL Authorization Initially, I received "Forbidden" errors when calling the Lambda Function URLs. The issue was that the CORS configuration wasn't allowing all HTTP methods. I fixed this by updating the CORS settings to allow  *  for methods and headers.
Challenge 2: DynamoDB Query Patterns DynamoDB requires careful schema design. I initially struggled with querying content by content_id. I resolved this by using scan operations with filter expressions, though in production, I'd recommend adding a Global Secondary Index (GSI) for better performance.
Challenge 3: Frontend-Backend Communication The frontend needed to know the correct Lambda Function URL. I solved this by updating the API_URL variable in the JavaScript code to point to the correct endpoint.
Challenge 4: Python Dependencies in Lambda Managing Python dependencies in Lambda required creating a ZIP file with the lambda_functions folder and requirements.txt. I used PowerShell's Compress-Archive command on Windows to create the deployment package.



AWS Services Used / Architecture Overview

Architecture Diagram

┌─────────────────────────────────────────────────────────┐
│ User Browser │
│ (HTML/CSS/JavaScript Dashboard) │
└────────────────────┬────────────────────────────────────┘
│ HTTP Requests
▼
┌─────────────────────────────────────────────────────────┐
│ Lambda Function URLs (REST API) │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Generate │ │ List │ │ Get │ │
│ │ Content │ │ Content │ │ Content │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
│ ┌──────────────┐ ┌──────────────┐ │
│ │ Delete │ │ EventBridge │ │
│ │ Content │ │ Scheduler │ │
│ └──────────────┘ └──────────────┘ │
└────────────────────┬────────────────────────────────────┘
│
┌────────────┼────────────┐
▼ ▼ ▼
┌────────┐ ┌──────────┐ ┌────────┐
│ S3 │ │DynamoDB │ │CloudW. │
│Storage │ │Database │ │Logs │
└────────┘ └──────────┘ └────────┘

AWS Services Used

Service
Purpose
Free Tier Allowance
Your Usage
Cost
AWS Lambda
Serverless compute for content generation and API endpoints
1M requests/month
~100 requests
$0
Amazon DynamoDB
NoSQL database for storing content metadata
25 GB storage
~1 GB
$0
Amazon S3
Object storage for generated content
5 GB storage
~500 MB
$0
Amazon EventBridge
Scheduled triggers for autonomous content generation
1M events/month
~30 events
$0
AWS CloudWatch
Logging and monitoring
5 GB logs/month
~100 MB
$0
AWS IAM
Identity and access management
Unlimited
Full usage
$0
TOTAL MONTHLY COST



$0/month

Key Architecture Decisions

  1. Serverless-First Approach: No servers to manage, automatic scaling, pay-per-use pricing
  1. Lambda Function URLs: Direct HTTP endpoints without API Gateway complexity
  1. DynamoDB for Metadata: Fast, scalable NoSQL database perfect for content metadata
  1. S3 for Content Storage: Durable, scalable object storage for generated content
  1. EventBridge for Scheduling: Native AWS service for cron-based triggers
  1. Separation of Concerns: Frontend and backend are completely decoupled



What You Learned

1. AWS CLI Mastery

Building this project entirely via AWS CLI (no console) taught me the power of infrastructure automation. Every resource—IAM roles, S3 buckets, DynamoDB tables, Lambda functions—was created through CLI commands. This approach is repeatable, version-controllable, and production-ready.

2. Serverless Architecture Design

I learned that serverless isn't just about "no servers"—it's about designing applications that scale automatically, cost nothing at idle, and require minimal operational overhead. The event-driven model (EventBridge → Lambda → DynamoDB/S3) is elegant and powerful.

3. Amazon Bedrock & AI Integration

While this version uses sample content generation, I explored Amazon Bedrock and Nova models for real AI-powered content. Understanding how to integrate LLMs into serverless applications opens doors to sophisticated AI features.

4. DynamoDB Data Modeling

DynamoDB requires different thinking than relational databases. I learned about partition keys, sort keys, query patterns, and the importance of designing schemas around access patterns. For this project, I used user_id as partition key and timestamp as sort key.

5. IAM Least-Privilege Principles

Creating an IAM role with minimal permissions taught me security best practices. Each Lambda function should only access the resources it needs—nothing more. This reduces blast radius if credentials are compromised.

6. CORS Configuration Complexity

Getting CORS right between frontend and Lambda Function URLs required understanding browser security policies, preflight requests, and proper header configuration. This is often overlooked but critical for production applications.

7. Autonomous Systems Design

Building an always-on agent that works without user intervention taught me about designing for reliability, error handling, and monitoring. The system must gracefully handle failures and provide visibility into what's happening.



Link to App or Repo

Link to App or Repo

GitHub Repository:  View GitHub Repository 
Live Application:  Open Live Application 
Frontend Dashboard: The frontend dashboard is included in the GitHub repository under the  frontend  folder. View Frontend Dashboard Code 
The GitHub repository contains:
  • Complete Python source code for all Lambda functions
  • HTML/CSS/JavaScript frontend code
  • serverless.yml configuration file
  • requirements.txt with Python dependencies
  • Comprehensive README with deployment instructions
  • Architecture documentation



Conclusion

The AI Content Creator Agent demonstrates that you don't need massive budgets or complex infrastructure to build powerful, production-ready cloud applications. By leveraging AWS Free Tier services and serverless architecture, I built a fully functional autonomous agent that generates creative content daily, stores it securely, and provides a beautiful interface for users—all for $0/month.
This project proves that the future of application development is serverless. With AWS Lambda, DynamoDB, S3, and EventBridge, developers can focus on building features instead of managing infrastructure. The always-on, autonomous nature of this agent shows how serverless enables new possibilities that would be expensive or complex with traditional approaches.
Whether you're building content generators, data processors, or any event-driven application, serverless architecture offers a compelling path forward.

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