AWS Builder Center
Renewal Radar - Never Fail To Forget

Renewal Radar - Never Fail To Forget

Never get surprise-charged by a subscription, domain, insurance policy, or warranty again. Log each item's renewal date once; a daily job emails you a heads-up before anything is due within the next 7 days.

AWS Cloud Engineer | 3x AWS Certified | Automation Driven | AI Practitioner | BigData | EMR | MSK
My Weekend Annoying Task Challenge: Renewal Radar


Vision & what the app does

Every so often a charge lands that I forgot was coming: a domain quietly auto-renews, an annual subscription I meant to cancel bills again, an insurance policy rolls over at last year's rate. The information exists — it's scattered across a dozen emails and account pages — but nothing pulls it together and warns me before the money leaves.
Renewal Radar fixes that one annoying thing. You log each item once (name, category, cost, and when it renews), and a job runs every morning that checks what's coming due. If anything is within the next seven days, it emails you a tidy digest sorted by urgency, so you can cancel, budget, or renegotiate before the charge hits instead of noticing it on a statement afterward. It handles subscriptions, domains, insurance, warranties, and memberships, and understands monthly, yearly, and one-time renewals.
The design goal beyond "make it work" was make it free and fully reversible — the whole thing runs on always-free-tier services and tears down with a single command, leaving no resources billing in the background.

How I built it

I kept the scope deliberately small: a place to record renewals, and a scheduled job to remind me. That maps cleanly to two flows sharing one database.
The manage flow is a static site on Amazon S3 that talks to an Amazon API Gateway HTTP API, which invokes a Lambda function that reads and writes an Amazon DynamoDB table. The reminder flow is an Amazon EventBridge Scheduler cron that fires once a day and invokes a second Lambda — the notifier — which scans the table, works out the next occurrence of each renewal, and emails anything due soon through Amazon SES.
A design decision I'm happy with: recurring renewals are advanced on the fly at check time rather than stored as a "next date" that has to be updated. The notifier computes the next monthly or yearly occurrence from the original date each run, so a renewal never goes stale and nothing has to write back to the record after an email goes out. That kept the notifier stateless and the data model trivial.

Everything is defined in one AWS SAM template, so it deploys and destroys as a unit.

Challenges I hit (and how I got past them)

  • The SES sandbox almost looked like a blocker. New SES accounts can only send to verified addresses. But since Renewal Radar emails me, I just verify my own address once and use it as both sender and recipient — the sandbox restriction never applies, and I didn't need to request production access at all. The SAM template even creates the SES identity so the verification email is triggered on deploy.
  • A YAML gotcha in the template. My DELETE route path  /renewals/{id}  sat inside an inline  { ... }  mapping, and the curly braces broke the parser on  sam build . Quoting the path ( "/renewals/{id}" ) fixed it — a good reminder that braces are meaningful in YAML flow mappings.
  • Leaving no cost traces. The usual hidden leftover is CloudWatch log groups that outlive the stack. I declared them explicitly with a short retention and  DeletionPolicy: Delete  so teardown removes them too, and used a dedicated deploy-artifact bucket that the teardown script empties and deletes — so  ./teardown.sh  genuinely leaves nothing behind.
I did the entire build, deploy, and Git push from AWS CloudShell in the browser — no local installs, and no access keys to manage since CloudShell is pre-authenticated.

AWS services used / architecture overview

  • Amazon S3 — hosts the static frontend.
  • Amazon API Gateway (HTTP API) — public endpoint for add/list/delete.
  • AWS Lambda (×2) — a CRUD function and the daily notifier.
  • Amazon DynamoDB — on-demand table storing the renewals.
  • Amazon EventBridge Scheduler — the daily trigger.
  • Amazon SES — sends the digest email.
  • Amazon CloudWatch Logs — short-retention Lambda logs, removed on teardown.
How the agent is triggered: the reminder logic is not called by a user — an EventBridge Scheduler cron ( cron(0 8 * * ? *) ) invokes the notifier Lambda once a day. To confirm the automation worked, I temporarily switched the schedule to every five minutes and tailed the logs live before reverting.
Browser (S3 site) -> HTTP API -> CRUD Lambda -> DynamoDB
EventBridge (daily) -> Notifier Lambda -> reads DynamoDB -> SES -> my inbox






What I learned

  • SES sandbox behavior — and that a "self-notifying" app sidesteps it entirely.
  •  DeletionPolicy  and explicit log groups as the difference between a stack that "deletes" and one that truly leaves zero cost traces.
  • Scoping IAM tightly — the notifier's send permission is scoped to a single SES identity ARN, not  ses:* .
  • EventBridge Scheduler with timezone-aware cron, and how to verify a scheduled job is actually firing.
  • Keeping an entire app inside the always-free tier by avoiding always-on compute — no EC2, no NAT gateway, nothing that meters while idle.
The most useful takeaway wasn't a single service — it was designing for reversibility from the start, so the app is something I can spin up, use, and delete with confidence that it left no trace.

Link to app / repo

#productivity #subscriptions #renewal #automation #SES #S3 #Lambda
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