AWS Builder Center
Weekend Creative Agent Challenge: CurrencyPulse - A Daily Exchange Brief That's Ready When I Wake Up

Weekend Creative Agent Challenge: CurrencyPulse - A Daily Exchange Brief That's Ready When I Wake Up

How I built CurrencyPulse, an always-on AWS agent that tracks exchange rates, compares day-to-day changes, and turns the numbers into a practical morning brief with Amazon Bedrock and Nova Micro.

Cloud Engineer

Vision: A Useful Update Waiting in the Morning

Exchange rates change every day, but most of us do not want to open a finance dashboard and study charts before deciding whether to send money home, pay an overseas tuition bill, plan a trip, or buy something imported.

I built CurrencyPulse to make that decision easier.
CurrencyPulse is a small, always-on agent that prepares one practical currency brief every morning. It watches a set of USD exchange rates, compares them with the most recent previous run, and explains what the movement might mean in normal language.
The output is a simple web page that is already waiting when I open it. There is no prompt box and no "generate" button.
The point is that the useful part happens automatically, before I need to open the app.
The default view tracks NPR, INR, EUR, GBP, and AUD. The tracked list can be changed with one configuration value.
The page shows:
  • Latest exchange rates
  • Percentage movement for each currency
  • The largest move
  • A short explanation of what changed
  • A compact history of previous briefs

How I Built It

I deliberately kept the architecture small.
A daily EventBridge Scheduler invocation starts an AWS Lambda function called  generateBrief .
The Lambda calls the free, keyless  open.er-api.com  endpoint to fetch the latest USD-based exchange rates. It then reads  data/history.json  from Amazon S3.
If this is the first run, it starts with an empty history. Otherwise, it finds the most recent entry before today and calculates the percentage change for every currency that exists in both readings.

Where Amazon Nova Micro Fits

The current rates and those comparisons are sent to Amazon Bedrock using Amazon Nova Micro.
I asked the model for:
  • A short headline
  • A three-to-five-sentence explanation
  • The currency code of the most notable move
The prompt asks for direct, specific language rather than a press release or a generic financial disclaimer.
The Lambda also treats the model response as untrusted input. It removes optional Markdown fences, parses the JSON inside a  try/catch , checks the required fields, and logs the raw response if parsing fails.
That separation was intentional:
The application handles the numbers. The model explains what those numbers might mean.

Generating the Daily Page

After the brief is generated, Lambda appends the result to  data/history.json , keeps the latest 60 entries, and creates a new inline  index.html .
I chose this static approach because the site does not need:
  • A database
  • API Gateway
  • A frontend framework
  • An always-running server
The generated page has a responsive layout with:
  • A prominent daily insight
  • An exchange-rate table
  • A “last completed run” timestamp in Nepal time
  • The next scheduled update
  • The data source
  • The Bedrock model being used
  • Recent history
If the page is left open, it refreshes every 15 minutes so it can pick up a newly published daily brief without a manual reload.


A Small AWS Detail That Taught Me Something

A few details mattered more than I expected.
The scheduler runs at:
02:15 UTC
That is:
08:00 NPT
in Nepal.

I display that schedule directly in the UI because "automatic" is much clearer when the user can see when the next run will happen.
I also added a prefix-scoped  s3:ListBucket  permission.
Without it, S3 returned  AccessDenied  instead of a clean missing-object response on the first run when  history.json  did not exist yet.
That was a good reminder that least privilege still needs to account for how an AWS API reports an empty state.

AWS Architecture


The deployed application uses:
  • Amazon EventBridge Scheduler — for the daily  cron(15 2 * * ? *)  trigger.
  • AWS Lambda — running Node.js 20 and TypeScript for the agent workflow.
  • Amazon Bedrock with Amazon Nova Micro — for the plain-English interpretation.
  • Amazon S3 — for the history file and the public static website.
  • AWS IAM — for separate least-privilege roles for Lambda and the scheduler.
  • Amazon CloudWatch Logs — through the Lambda basic execution role for debugging external API and Bedrock failures.
There is no database.
S3 is enough for this scale, and the Lambda only has read/write access to the two objects it needs:
data/history.json
index.html
The S3 bucket blocks public ACLs and uses a bucket policy for website reads.


What I Learned

The biggest lesson was that an always-on agent is more about dependable scheduling and publishing than about making a large interface.
The application feels automatic because:
EventBridge creates the rhythm → Lambda performs the work → S3 makes the result available.
There is no additional service in the middle.
I also learned to design for the first run explicitly.
Missing history, unavailable rates, malformed model output, and a stale page are all normal operational states, not unusual edge cases.
Logging each external call and refusing to publish a broken page made the workflow easier to reason about.
Finally, making the update time visible turned a backend cron expression into something a real user can understand.

Try CurrencyPulse

You can see the deployed application here:  Currencypulse 
The source code is available here:  https://github.com/GitHer-Muna/CurrencyPulse.git    
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