PrettySure

• 

  PrettySure Net Worth Screen

• 

  PrettySure Scenario Projection

• 

  Architecture

• 

  PrettySure DynamoDB Table

• 

  PrettySure DynamoDB Item

Inspiration

I've been tracking my net worth for years in messy spreadsheets. I've also tried several personal finance apps. And while they're good at tracking numbers and showing evolution over time, I always struggled with the same gap: I couldn't easily understand what those numbers meant for a real decision.

Can I afford to take six months off? Should I say yes to that job that pays less? What breaks if I do nothing for a year?

No tool answered that. They told me where my money went. I needed to know where my life could go.

What it does

PrettySure is a financial projection tool that answers the question most finance apps ignore: what does my future look like? You enter a rough snapshot of where you stand — net worth, a few assets, a debt, monthly flows. Then you ask a real question in plain English: can I afford to take six months off? What happens if I go part-time?

Any model available on Bedrock reasons about your situation and returns an honest range — High, Mid, Low — with a plain English narrative. Not a spreadsheet. Not a financial advisor. Just enough clarity to actually make a move.

How I built it

I started this hackathon with just the problem. No solution, no stack, no UI. I wasn't looking to build an AI product — I was looking for the right tool to solve a problem I'd been living with for years.

The answer turned out to be a conversational interface powered by Claude on Amazon Bedrock. Not because AI is interesting, but because natural language is the right way to ask "can I afford to take six months off?" — and a projection engine is the right way to answer it honestly.

The stack is fully serverless: React + Cloudscape on Vercel, a FastMCP server on Lambda, Claude on Bedrock, and DynamoDB on AWS for snapshot persistence.

Challenges I ran into

Finding the right concept took longer than expected. The core tension: how do you get straight to a meaningful conversation without asking the user to spend an hour entering data first — but also without so little context that the projection is useless? That balance drove most of the early design work.

Getting the ingestion right was harder than expected. The wizard needs to collect enough to power a projection without demanding tax-report accuracy — a genuinely difficult UX balance. The confirm-the-parse pattern (AI pre-fills, user confirms, uninferable fields surface blank) was the key design decision that made it trustworthy.

Fitting a coherent product into a hackathon timeline meant making hard calls about what to cut. Aurora and AgentCore were scoped and designed — but DynamoDB with per-judge Cognito accounts was the right call for the submission window.

Accomplishments that I'm proud of

The one that matters most: it's actually useful.

I showed PrettySure to friends and family during the hackathon. By the end of the weekend, I'd retired the household spreadsheet. That's the real test — not whether it demos well, but whether people reach for it when they have a real question.

Technically, getting the projection engine to return honest ranges rather than false point estimates — and framing that uncertainty as a feature, not a limitation — was the design insight I'm most proud of. Most tools hide uncertainty. PrettySure makes it the whole point.

What I learned

Precision is the enemy of usefulness here.

The insight that unlocked the product was realising that category-level spending data doesn't move the answer for life decisions — trajectory and liquidity do. That shaped everything: the data model, the ingestion wizard, the projection engine.

I also learned that AI works best in this context when it's kept dumb about presentation and the UI is kept dumb about math. Claude translates natural language into tool calls. The tools do the math. The UI renders the result. Clean separation made the whole thing more reliable and easier to reason about.

What's next for PrettySure

• CSV ingestion — connect a bank export or brokerage statement and let the parser do the work. The ingestion wizard already handles the data model; this is the lazy entry point for people who'd rather upload than type.

• More scenarios beyond net worth — the architecture already supports income and expense tracking without significant changes. A freelancer tracking project revenue, a small business owner watching margins — same tool, different bucket labels.

• Scenario memory — conversations and projections get stored so you can revisit a question weeks later and see how your situation has changed. The infrastructure is there; it was a time call not to ship it for the hackathon.

• NZ and AU calibration — better defaults for KiwiSaver, local tax rates, and compensation structures common in this market. The projection engine is geography-agnostic today; the defaults aren't.

Built With

• apigateway
• bedrock
• cloudscape
• cognito
• dynamodb
• lambda
• python
• react
• vercel