Personal build In production · not live yet
A wish list for two, built around keeping the surprise.
Hintlist is a gift list app for couples. Each person keeps a list, and each partner gets a private planning space on top of the other's list: notes, sizes, prices, what's been bought. The person you're shopping for never sees any of it.
I'm building it to work through a full product the way I'd run one at work: start from a problem, research what exists, set principles, prototype, then build on real infrastructure. This page documents the method while the build is underway, so it's honest about what's done and what isn't.
The problem
Wish list apps already exist, and they solve the obvious part well: save a product link, share the list, mark items reserved so nobody buys the same thing twice. Reviewing the category showed two consistent gaps.
- They're built for groups and stores. Families, Secret Santa, registries. A couple is a different relationship: two people, one each way, year after year.
- Anything without a link is an afterthought. "Get my watch repaired," "a new puppy," or a trip can't be pasted from a store. Several apps require a photo, price and URL even for a manual entry.
- The giver gets a checkbox, not a tool. "Mark as reserved" is where most apps stop. The person actually doing the shopping has nowhere to keep sizes, notes, a budget or the question they want to ask.
Principles
One line to add
A wish is a single line of text. A photo, link or price makes it richer but is never required, and a bare note still looks finished rather than like an incomplete form.
Privacy by design
Everything the giver adds is private to the giver, and that rule is enforced by the database, not just hidden in the interface.
Restraint
Two tabs and an account menu. No feeds, badges, streaks or inbox. The interface is close to monochrome so the wishes themselves carry the visual interest.
Sign in when it matters
You can start a list without an account. Google sign-in happens when you invite your partner, because that's the first moment an account does anything for you.
The system
The core idea is one list with two views. Each wish is stored once; the giver's layer is stored separately and attached to it.
Mine
Your own list, in your order. A small line explains who can see it: your partner sees this list, never what's been bought from it. A menu on each wish lets you mark it received or remove it if you've changed your mind.
Their list, two ways
Your partner's tab has a switch. "As they see it" shows their list exactly as they built it, read-only. "Your plan" is the private workspace: notes, prices, a running budget, an "I bought this" mark, and your own gift ideas they'll never see. A blood-orange label on that view says plainly that your partner can't see it.
Questions, two ways
You can ask openly about an item ("which brand?"), or send a secret this-or-that, like "green, blue or yellow?", without revealing what it's for. Answers appear in one card at the top of the recipient's list, then attach privately to the item.
Sizes by category
People aren't one size. The profile holds a size and a fit note per category: medium in jackets with room for a sweater, large in tees, extra large in trench coats. When a wish is clothing, the matching size appears on the giver's view of that item.
Profiles that fill in over time
Add a coat with no jacket size on file and the app asks once, inline. Answer a secret pick and it can save to your profile. Your partner can guess a preference and you confirm it. Nobody fills out a long form.
One wish, start to finish
- Add: I paste a link to a wool overcoat from a store's website. The app pulls in the photo, name and price, recognizes a jacket, and asks for my jacket size, once.
- View: my partner sees the coat on my list, plus "Jackets: M · room for a sweater."
- Plan: in his private view he adds a note and a price, which feed his budget total.
- Ask: he sends a secret pick, "charcoal or camel?" I answer without knowing it's about the coat.
- Buy: he marks it bought. My list doesn't change.
- Receive: after the holiday, I mark it received and it moves to a record of gifts.
How it's built
The prototype taught the product; the build needs real infrastructure: accounts, data that syncs between two people, rules about who can see what, and code that runs on a server. Every tool was chosen to run on a free tier for a two-person app, with costs flagged before anything is added.
Claude
Product partner for research, design and code: reviewing the category, pressure-testing ideas, building the clickable prototype on a design canvas, then writing and committing the application code.
ChatGPT
Early concept riffing.
Next.js and React
The application itself, written in TypeScript. A web app that works on any phone, without app store approval.
GitHub
Version control. Every change is a commit, so any decision can be traced or rolled back.
Vercel
Hosting. Each change pushed to GitHub redeploys the live app automatically.
Supabase
The Postgres database and accounts. Row-level security policies make the privacy rule structural: the giver's notes, purchase marks and private ideas can only be read by the giver, and a secret question never records which item it's about anywhere the recipient can see.
Google sign-in
Accounts through Google, asking only for name and email. Narrow permissions keep the consent screen short and avoid Google's extra review for sensitive data.
Why not the same setup as the civics app
The civics app is a set of static files: everyone sees the same thing, so it can be served directly from this site. Hintlist needs accounts, private per-person data and server-side code, which static hosting can't provide. That's the reason for a separate host and a database.
Decisions along the way
Most of the useful work was deciding what not to build, and noticing where the first version was wrong.
Designing from observation
I wanted the ease of Apple's Freeform. Rather than decompiling it, I named the principle I was after, adding should never feel like a form, and designed to that.
Parking a bigger idea
Midway through, the concept grew into a notebook for everyone you know: birthdays, allergies, the thing they collect. It's a real product, and a much bigger one. I kept the data model centered on a person so it can grow there later, and kept version one to couples.
Three views, two tabs
Using the prototype, I realized the giver needs to see their partner's list clean, exactly as built, as well as their own plan on top of it. I chose a switch inside one tab over a third tab, because both views are the same list in two modes.
Copy that tested badly
"Mark bought" read as a person named Mark. "Ask a pick" made sense only to the people who designed it. Both were renamed after the first look at the live app.
Status and plan
Done
Product principles, a clickable prototype of every core screen, the application code on sample data, the live deployment, and a database schema with the privacy rules written in.
In progress
Connecting the database, Google sign-in, and the partner invite, so two real people can use it this holiday season.
Next
Link previews that pull a product's photo and price, photo uploads, notifications for questions, and visual identity.
Later
A "hints, not lists" path for people who are uncomfortable writing a list, price alerts, and suggested next steps for wishes that aren't products, like finding a watch repair shop.
How I'd measure it
- Surprise kept: zero cases of a recipient seeing a purchase, checked against the database rules, not just the screens.
- Effortless adding: most wishes added in one line, with no required field ever blocking a save.
- Questions answered: how often secret and open questions get a reply, and how quickly.
- Return: both partners coming back before an occasion, not just the one who set it up.
The method carries over from the civics app: write the rules down precisely, let AI tools handle the volume, and test what you built against how a real person reads it.