AWS Builder Center
Weekend Showcase Challenge: DailyQuest AI

Weekend Showcase Challenge: DailyQuest AI

DailyQuest AI is an always-on AI agent that turns long-term goals into personalized daily challenges. Built with Amazon Bedrock, Nova Lite, AWS Lambda, DynamoDB, EventBridge Scheduler, and IAM, it proactively prepares quests based on a user's goals, skill level, available time, interests, and previous activity. This article explores the architecture, personalization, automation, challenges, and lessons learned while transforming a traditional AI app into a proactive serverless agent.



#application

Vision and What It Does

DailyQuest AI is a personalized productivity application designed to help people make consistent progress toward their goals without having to decide what to work on every day.
Many people have a larger goal—such as learning Data Structures and Algorithms, improving coding skills, studying for an exam, developing a fitness habit, or exploring a creative skill—but struggle to convert that goal into a small and achievable daily action.
DailyQuest AI solves this problem by turning a user's larger goal into personalized daily quests.
During onboarding, the user provides information such as their goal, skill level, available time, and interests. Based on this information and the user's previous activity, the application prepares a daily challenge that matches their current situation.
A quest can include a title, description, difficulty level, estimated completion time, tasks, category, and XP reward.
For example, a beginner learning DSA might receive a short problem-solving challenge, while an intermediate programmer with more available time could receive a more advanced coding task. A user interested in fitness or creativity can receive an entirely different type of challenge.
The core idea is simple:
Instead of asking the user, "What should I work on today?", DailyQuest AI prepares the next step for them.

From an AI Application to an Always-On Agent

One of the main goals of my original build was to explore how an AI-powered application could become an always-on agent.
A traditional AI application generally waits for the user to open the application, provide input, and request something from the AI.
DailyQuest AI takes a different approach.
The system can proactively prepare a new quest using a scheduled AWS workflow. The user does not have to manually request a new challenge every morning.
The scheduled workflow retrieves the user's profile and relevant previous activity, generates a personalized quest using Amazon Bedrock and Amazon Nova Lite, and stores the result in Amazon DynamoDB.
When the user opens DailyQuest AI, the prepared quest can already be available.
This was an important shift in the way I thought about AI applications. The AI is not simply responding to a prompt. It is participating in a workflow that can take action proactively.

How DailyQuest AI Works

The application starts with onboarding.
The user selects their goal, skill level, available time, and interests. This information becomes the foundation for personalization.
The profile is stored in Amazon DynamoDB along with information such as XP, streaks, progress, and timestamps.
Previous quests are also stored so that future challenges can take the user's activity into account.
A scheduled workflow can then trigger the DailyQuestGenerator AWS Lambda function.
Lambda retrieves the relevant user information and checks whether today's quest has already been created.
If a quest does not exist, the workflow prepares the user's context and sends it to Amazon Bedrock.
For this project, I used Amazon Nova Lite with the model ID:
 amazon.nova-lite-v1:0 
The model generates a structured daily challenge based on the user's goal, skill level, available time, interests, and previous activity.
The generated quest is then stored in DynamoDB.
When the user opens the application, the Next.js frontend retrieves the prepared quest through the backend API and displays it on the dashboard.
This creates a complete cycle:
User Profile → Scheduled Agent → User Context → Amazon Nova Lite → Daily Quest → DynamoDB → User Dashboard

Preventing Duplicate Quests

One of the important engineering decisions in DailyQuest AI was making the quest-generation process idempotent.
A scheduled system can potentially run more than once. If every execution generated a new quest, a user could receive multiple quests for the same day.
To prevent this, the system uses a deterministic quest identifier based on the user and date.
Before generating a quest, Lambda checks whether the corresponding quest already exists.
If it exists, generation is skipped.
If it does not exist, the agent invokes Amazon Nova Lite, generates the quest, and stores it in DynamoDB.
This means that running the workflow multiple times does not continuously create duplicate daily quests.
During testing, this behavior allowed the first generation to create the quest while subsequent executions for the same date recognized that the quest already existed.

Personalized and Adaptive Challenges

DailyQuest AI is designed around the idea that a user's daily challenge should evolve with them.
The system can consider:
  • Current goal
  • Skill level
  • Available time
  • Interests
  • Previous quests
  • Completion history
  • Progress
  • Difficulty
This information can be used to make future challenges more relevant.
For example, if a user consistently completes their coding quests, future challenges can gradually become more difficult.
If a user is struggling or repeatedly missing challenges, the system can instead prepare shorter and more manageable tasks.
Previous activity can also help reduce repetitive recommendations.
The long-term vision is to create a feedback loop where every completed quest provides useful context for preparing the next one.

AWS Services Used

DailyQuest AI combines several AWS services to create the always-on workflow.
Amazon Bedrock is used as the generative AI layer for personalized quest generation.
Amazon Nova Lite is the foundation model used to generate structured daily challenges from user context.
AWS Lambda runs the quest-generation workflow without requiring a continuously running backend server.
Amazon DynamoDB provides persistent storage for user profiles, quests, progress, XP, and quest history.
Amazon EventBridge Scheduler provides the scheduled trigger that allows the agent workflow to run automatically.
AWS IAM provides controlled permissions so the Lambda function can access the required AWS resources securely.
The frontend is built with Next.js and React and communicates with the backend through API routes.

Architecture Overview

The architecture is intentionally serverless.
The user interacts with the DailyQuest AI web application through the Next.js frontend.
User profile information and quest history are stored in DynamoDB.
A scheduled EventBridge workflow triggers the DailyQuestGenerator Lambda function.
Lambda retrieves the required user context from DynamoDB and checks whether today's quest already exists.
When generation is required, Lambda calls Amazon Bedrock using Amazon Nova Lite.
The generated quest is validated and stored back in DynamoDB.
The Next.js application can then retrieve the prepared quest and display it to the user.
AWS IAM controls the permissions required by the Lambda execution environment.
This architecture allows the AI workflow to operate independently of the user interface while keeping the application relatively lightweight and serverless.

How I Built It

I started by building the core DailyQuest AI experience with Next.js and React.
The first version focused on the user-facing experience: onboarding, profile creation, goal selection, skill level, available time, interests, daily quests, progress tracking, XP, and streaks.
Once the application experience was working, I focused on the backend architecture.
The next step was connecting the application to DynamoDB so that user profiles and quests could persist beyond a single session.
After that, I implemented the quest-generation workflow using AWS Lambda and Amazon Bedrock.
I then added scheduled execution using EventBridge Scheduler so the system could prepare quests without requiring the user to manually trigger generation.
Finally, I worked on idempotency, user identity, API integration, permissions, and deployment.
The project evolved from a normal AI-powered web application into a system where the AI could proactively perform a useful task.

Challenges I Faced

One of the biggest challenges was understanding the difference between simply using an AI model and building an AI agent.
Calling a model and displaying its response is relatively straightforward.
Building an agent that can operate independently requires much more infrastructure.
The system needs a trigger, context, memory, decision-making or generation, an action, persistent state, and appropriate permissions.
I had to think about how scheduled execution would work, how Lambda would retrieve user information, how quests would be stored, how duplicate generation would be prevented, and how the frontend would retrieve the result.
I also encountered deployment and integration issues while connecting Next.js, DynamoDB, Lambda, and the AWS environment.
These issues were valuable because they showed me that building an agent is not only about writing the AI prompt. The surrounding cloud architecture is equally important.

Security

Security was another important consideration.
AWS credentials should never be exposed in the frontend or hard-coded into the application.
Instead, the backend workflow uses AWS IAM permissions through the Lambda execution role.
The Lambda function receives only the permissions required to interact with the necessary AWS services.
The frontend communicates with the application backend rather than directly exposing AWS credentials.
This keeps the AWS infrastructure separated from the client-side application and provides a safer architecture for the project.

What I Improved for the Showcase

For the Weekend Showcase Challenge, I focused on taking DailyQuest AI beyond the initial prototype and thinking about the complete product experience.
The original project demonstrated the idea of an always-on personalized quest generator.
For the showcase, I focused on making the architecture clearer, improving the application flow, strengthening the AWS integration, and refining the overall experience around daily progress.
The most important improvement was not simply adding another AI feature.
It was improving the connection between the user's long-term goal, their previous activity, the scheduled agent workflow, and the next quest generated for them.
This makes the AI functionality feel like part of the product rather than a separate chatbot feature.

What I Learned Across the Summer

Building DailyQuest AI across the summer gave me a much better understanding of how AI applications are evolving.
I started with the idea of building an application that uses AI.
As I worked through the different stages, I began thinking more about workflows, automation, persistent state, and autonomous behavior.
One of my biggest lessons was that an AI agent is more than a model.
The model provides intelligence, but the surrounding infrastructure gives that intelligence the ability to do something useful.
Triggers allow the agent to act.
Databases provide memory.
APIs provide interaction with the application.
Cloud functions provide execution.
IAM provides controlled access.
Together, these components can turn a generative AI model into an actual agentic workflow.
Working with AWS services also helped me understand how serverless architecture can be used to build systems that do not require a traditional always-running backend.

The Bigger Idea Behind DailyQuest AI

The problem DailyQuest AI tries to solve is small, but it represents a larger idea.
People often know what they want to achieve but struggle with consistency.
A goal such as "learn DSA" or "get better at coding" is too large to act on every day.
Breaking that goal into a specific action makes progress easier.
DailyQuest AI attempts to automate that process.
Instead of waiting for the user to decide what comes next, the system can prepare the next step based on what it already knows.
That is where I see the value of an always-on AI agent.
The goal is not to make AI constantly interact with the user.
The goal is to let AI perform useful work in the background so that the user can benefit from it when they need it.

Future Improvements

There are several areas I would like to explore next.
I would like to improve long-term personalization so that the agent can understand a user's progress over a much longer period.
Another improvement would be notifications when a new quest has been prepared.
I also want to explore more advanced difficulty adaptation, richer progress analytics, additional challenge categories, personalized schedules, and better recommendations based on completion patterns.
Another interesting direction would be allowing users to provide feedback about each quest and using that feedback directly in future generation.
Over time, DailyQuest AI could become more than a daily challenge generator.
It could become a personal AI companion that continuously helps users decide what to do next while adapting to how they actually learn and work.

Why I Built It

I built DailyQuest AI because I have personally experienced how difficult it can be to stay consistent with a large technical goal.
There is usually no shortage of things to learn.
The difficult part is deciding what to do today and making sure that today's task is realistic enough to actually complete.
That led me to a simple question:
What if an AI agent could prepare the next useful step before I even opened the application?
DailyQuest AI is my attempt to answer that question.

Conclusion

DailyQuest AI started as a personalized productivity application and evolved into an exploration of always-on agentic AI.
The core idea is simple:
Don't make the user come to the AI. Let the AI prepare something useful before the user arrives.
By combining Next.js with Amazon Bedrock, Amazon Nova Lite, AWS Lambda, Amazon DynamoDB, EventBridge Scheduler, and AWS IAM, I was able to explore how a generative AI model can become part of a proactive, persistent workflow.
The project taught me that building an AI agent is not just about selecting a powerful model.
It is about designing the complete system around the model—how it receives context, when it acts, what it remembers, what it produces, where that result is stored, and how securely everything works together.
DailyQuest AI is my attempt to turn a simple productivity problem into a proactive AI experience.
And this showcase is an opportunity to take that idea one step further.

Links

Tag: #application
AWS Services: Amazon Bedrock, Amazon Nova Lite, AWS Lambda, Amazon DynamoDB, Amazon EventBridge Scheduler, AWS IAM
Builder who inspired me:@pawanjoshidev
#application #AWS #AmazonBedrock #AmazonNova #AWSLambda #DynamoDB #EventBridge #GenerativeAI #Serverless #AIAgents
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