
Weekend Creative Agent Challenge: Numerology & Astrology
A numerology and astrology app that never stops working — real astronomical birth charts on demand, plus a daily and monthly horoscope that regenerates itself on its own clock, deployed entirely on Amazon S3.
Vision
For this challenge I built a numerology and astrology app: Life Path numbers, a real astronomical birth chart (Sun, Moon, and Rising sign computed from actual planetary math — Julian day, ecliptic longitude, sidereal time, not just a calendar lookup table), compatibility readings, and angel numbers. All of it fully client-side — you type in a name and birth date, and it hands something back.
A pure request/response tool like that is reactive by nature — you open it and ask. The challenge's brief was the opposite: something that works while you're not looking, so it has something new ready when you return. Rather than bolt on a generative-AI pipeline that needed heavier cloud infrastructure than a solo weekend justified, I built that "agent" behavior into the app's Daily and Monthly Horoscope: every calendar day, and again every calendar month, the app deterministically produces a fresh reading per zodiac sign — seeded off the real date, not off the user's click. Nobody triggers it, nobody re-runs it, it just changes on its own on a clock nobody controls, and it's already there waiting the next time you open the app. Small in scope, but genuinely autonomous rather than merely reactive — the "ready when you return" idea the challenge asked for, without pretending a hand-triggered generation button is the same thing.
How I built it
The reading itself comes from a small deterministic engine: hash the zodiac sign name together with today's date (or this month, for the monthly reading) into an index, and use that index to pick from a themed pool of readings. Same sign, same day, same reading for everyone — but tomorrow it's different, and nobody had to press anything for that to happen. It's paired with the app's existing real astronomical Sun-sign calculation, so the "agent" behavior is layered on top of genuine math rather than being disconnected from it.

The more interesting story is what happened trying to get this properly onto AWS. I originally built a full pipeline — Lambda, EventBridge Scheduler, Amazon Bedrock (Nova Micro for a poem, Nova Canvas for an image) — and hit a wall that had nothing to do with the code: this AWS account needed manual verification before it could expose any public-facing HTTP endpoint. CloudFront refused outright with an explicit message. API Gateway's default domain returned a bare 500 with zero logs ever reaching the Lambda. A Lambda Function URL, a third and completely different code path, returned 403 despite a correctly scoped resource policy, verified twice. Three unrelated services, the same underlying wall.
With a hard deadline and a rule that only asks for deployment on at least one AWS service, I made the deliberate call to strip the architecture down to the one thing that reliably worked all weekend: Amazon S3, static website hosting, with a bucket policy scoped to public read-only. No edge network, no per-model access gate, no silent failures — just a bucket serving files. Simpler, and it shipped.
I also found a real bug this exposed: an S3 static website endpoint serves plain HTTP, and the Web Crypto API (
crypto.randomUUID , crypto.subtle ) is unavailable on insecure origins by browser spec. A feature that generated an id on every render crashed the whole page white the moment someone actually used it over HTTP, with no error boundary to catch it. Fixed with a non-cryptographic id fallback for the non-secret case, a capability check that fails a secure-storage feature gracefully instead of crashing, and an error boundary as a backstop so a future version of this class of bug degrades instead of blanking the page.AWS services used
- Amazon S3 — stores and serves the built static site (HTML/CSS/JS) directly via static website hosting, with a bucket policy scoped to public
s3:GetObjectonly — no write, delete, or list access to anyone
Architecture, in one line: Vite build →
aws s3 sync → S3 static website hosting, serving the app directly. No CDN, no compute, no backend — the autonomy lives in the client-side date-seeded reading logic, not in server infrastructure.The code behind the "agent"
No server, no cron job, no button. The entire autonomous behavior is one small hashing function plus a lookup:
function dailySeed(str: string): number {
let hash = 0;
for (let i = 0; i < str.length; i++) {
hash = (hash * 31 + str.charCodeAt(i)) >>> 0;
}
return hash;
}
// Same for everyone with this sign on a given calendar day — changes tomorrow.
export function dailyHoroscope(sign: ZodiacSign, today: Date = new Date()): string {
const dateKey = today.toISOString().slice(0, 10); // e.g. "2026-08-24"
const idx = dailySeed(`${sign.name}-${dateKey}`) % DAILY_THEMES.length;
return DAILY_THEMES[idx];
}The trick is the seed string: sign.name + today's date. Hash that into a number, mod it by the size of a themed reading pool, and you get an index that's completely stable for "Leo, August 24th" but lands somewhere else entirely for "Leo, August 25th." Nobody presses a button, nothing runs on a schedule — the calendar itself is the trigger. The exact same function, seeded by year-month instead of year-month-day, produces the Monthly Horoscope.
It's a deliberately unglamorous piece of code — nine lines, no dependencies, no network call — but it's the one piece of the app that behaves like an agent rather than a tool: it changes on its own clock, and it's already different by the time you come back to look at it.
What I learned
The big lesson: "deployed on AWS" for a solo weekend project can run into account-level friction that has nothing to do with your code, your IAM policies, or your architecture — and the error messages for that friction are often far less clear than an ordinary permission error. Three different services (CloudFront, API Gateway, Lambda Function URLs) all failed for what looks like the same underlying account-verification reason, each with a different, unhelpful symptom. Second: the Web Crypto API's secure-context requirement is easy to forget until you actually deploy somewhere that isn't HTTPS by default, and it's worth designing for that failure mode rather than assuming crypto APIs are always there. Third, and least technical: under a real deadline, the smaller architecture that's honest about what it is beats the "correct" one that might not ship — S3 alone, done properly and safely scoped, was the right call this weekend even though it wasn't my first plan.
Link
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article