Piyush Grover
iOS — Personal Product · Live on the App Store
A private ledger for shagun — the gifts and cash exchanged at Indian celebrations — with a reciprocity engine at its heart. Designed end-to-end in Figma, then built AI-directed without writing code. Live on the App Store.
Shagunly is an iOS app for tracking shagun — the cash and gift exchanges that are a core part of Indian weddings, festivals, and birthdays. It replaces the mental math, scattered notebooks, and "who gave what" guesswork with a simple, culturally-native ledger.
I designed it end to end in Figma — the theme, the design system, every component and flow — then directed the entire technical build without writing a line of code, using Claude as the engineering partner. This case study covers both halves: the design decisions, and what it actually takes to hand a finished design to an AI and ship it to the App Store.
At Indian occasions — weddings, Diwali, birthdays — cash and gifts change hands constantly, and tracking who gave what (and what's owed in return) is a real, ongoing social obligation. Families still do this with pen-and-paper registers or fragmented memory. There was no lightweight, culturally-specific tool built for this — generic expense trackers don't understand the shagun mental model of reciprocity, occasions, and relationships.
This was a problem I understood firsthand, which shaped both the product's name (a playful spin on "shagun") and its tone throughout.
The idea came from my father — tech-savvy, and done with the paper registers. He wanted the record off paper and onto a phone, where it could be pulled up in seconds instead of leafed through.
Rather than a formal research phase, this was insight-driven design — grounded in direct, lived experience of the problem and validated early with family as real users. That closeness to the user became a strength: every design decision could be pressure-tested against "would my own family actually use this at a wedding?"
Shagunly began life as Sagan Tracker, a progressive web app. It worked, but a PWA has real ceilings for this use case — no App Store presence, weaker offline reliability, and a "second-class" feel for something meant to be used mid-celebration, one-handed, often with spotty venue wifi.
I made the call to rebuild native in SwiftUI. That's a significant product decision — trading faster iteration for a proper install, TestFlight distribution, and a path to the App Store — and it's the kind of build-vs-rebuild tradeoff any product designer has to own.
Before any colour or type, I resolved layout and hierarchy as greyscale wireframes in Figma — one primary question per screen, balance and next action above the fold, direction chosen before amount. The visual language came later, on top of a structure that already worked.
Because I'd be handing this to an AI rather than an engineer, the system had to be unambiguous: every colour, size and spacing step named and fixed in Figma first. Vague intent produces vague code — a defined token set produces the screen you drew.
Two decisions drive the whole palette: a deep night base so celebratory colour can glow without shouting, and a serif display voice that brings warmth to what is, underneath, a money app.
Each component was drawn with its states before it was built — default, pressed, disabled, selected — so the build had nothing left to invent.
Shipped as a responsive iPad layout too — same flows, same data, adapted to a wider canvas rather than just stretched.
The home screen surfaces what matters first: net balance, the next occasion needing a gift, and recent activity. Every relationship is a running balance, not a transaction log — a glance tells you whose turn it is. Occasions split into Upcoming and Past, each carrying its own gift-tracking status — drilling into one totals what was given and received, and lists every gift logged against it. Logging a shagun takes seconds: given or received, an auspicious-amount preset, a person, and an optional occasion link.
Every screen above is the survivor of a set of options drawn out in Figma. The decisions that shaped Shagunly weren't visual polish — they were product calls about what the app should feel like to a family mid-celebration. What was on the table, what shipped, and why:
Considered A plain numeric field — fastest to build, culturally blind.
Shipped One-tap auspicious presets — ₹501, ₹1,100, ₹2,100, ₹5,100 — above the keyboard.
Why Shagun amounts conventionally end in ₹1. Presets make the culturally correct amount the path of least resistance and cut mid-event entry to a single tap.
Considered A transaction log per contact — accurate, but reads like accounting.
Shipped A running balance per relationship, with a "Your turn / Their turn" cue.
Why Shagun is reciprocity, not bookkeeping. Framing each person as a relationship state answers the real question — "where do we stand?" — at a glance.
Considered Editable-by-default detail views — powerful, but noisy and risky.
Shipped Read-only by default; editing sits behind a deliberate pencil tap.
Why Most opens are checks, not changes. A calm read state keeps the record safe from accidental edits in the middle of a crowded function.
Considered Amount-first forms, with given/received as an afterthought toggle.
Shipped Received / Given as the first, color-coded choice — green in, red out.
Why Direction is the meaning of the transaction. Committing it first keeps every later field — preset, person, occasion — in the right mental frame.
Considered Requiring an occasion on every entry — cleaner data, slower capture.
Shipped Occasion is optional at capture, linkable when there's time.
Why At a live event, speed beats structure. Optional linking keeps the ledger usable in the moment without giving up organization afterwards.
Considered Default system typography on a light canvas — native, but generic.
Shipped A serif display voice over a deep night palette with festive gradient accents.
Why The serif brings warmth and sense of occasion to a money app; the dark canvas lets celebratory color glow without shouting.
Each fork was drawn out in Figma before committing — the rejected option on the left, what shipped on the right.
Beyond the screen-level trade-offs, a handful of decisions shaped what Shagunly actually is — each a product call before it was a design or engineering one.
One shared lookup answers "what did this person last give us?" everywhere — home banner, gift suggestions, reminders. It prefers a same-occasion match (their wedding → your wedding) before falling back to most recent, and every name comparison flows through one normalisation rule, so "Anita", "anita " and "ANITA" are one person.
Why it matters When grouping logic lives in five places, it disagrees in five ways. Here it can't.
Tracking apps assume you're always the giver. But when you host Dad's 60th, gifts flow toward your family. Marking an occasion "My family's" flips the perspective: the CTA becomes Log gifts received, entries default to incoming, the "no gift yet" urgency disappears, and the reciprocity line hides — the guest of honour is not a prior giver.
Why it matters One boolean, but it required rethinking every screen's assumptions.
A household keeps one gift book. Anyone joins with a six-letter share code, and every entry shows who logged it. The rule that makes it work socially: only the author can edit a record — everyone else can ask. Change requests queue on the author's home screen to approve or decline.
Why it matters Enforced twice — in the UI, and in Postgres row-level security with a SECURITY DEFINER function that verifies ownership server-side. A hacked client changes nothing.
Batch entry ("Save & Add Another" keeps the occasion and date, resets the person), live Indian digit grouping (₹1,00,000 as you type), one-tap auspicious amounts, camera capture at the door, and a picker that turns a typed one-off occasion into a saved one without leaving the form.
Why it matters The app is used standing up, in a crowd, mid-celebration — or not at all.
The year in gifts — totals, closest exchange, most generous moment — as a full-screen story.
Why it matters A ledger app that earns a screenshot.
No analytics SDKs, no ads, no tracking. Photos never leave the user's account; export ships every record as spreadsheets in two taps; delete-account removes everything atomically. The privacy policy is plain language on purpose, with a section explaining exactly what family members can and cannot see.
Why it matters For a record of family gift-giving, discretion is the product.
This is the join between the two halves of the project. I redlined each screen in Figma the way I'd spec it for an engineer — component, size, radius, token, state, edge case — and that spec became the brief for the build.
The discipline mattered more here than it would with a human engineer: a person asks when something's ambiguous, an AI just picks. Anything I left vague came back as something I didn't design, so the spec had to carry the decision, not just the look.
Design decided in Figma. The build followed the spec.
With the design settled in Figma, the build became an execution problem — the part of the story most portfolios don't tell, and increasingly the part hiring managers ask about.
I have no coding background. Every screen, flow, and backend interaction was built by directing Claude against the Figma spec — describing intent, reviewing output, iterating — the same way I'd direct an engineer, but faster and entirely in my own hands.
Not just prototypes:
EntryDetailView) built and wired into the app's root navigation
Directing a build doesn't mean skipping the hard parts — it means understanding them well enough to catch them. The bugs that mattered were the quiet ones:
Encodable omits nil keys, so clearing a photo or a note silently survived in Postgres — the classic PATCH-semantics trap. Fixed with explicit update payloads that encode every field, writing SQL NULL on purpose. That discipline now covers all five mutating tables.signInWithIdToken path as Apple — so auth is branded, in-app and browser-free.These aren't things I coded — they're things I had to understand well enough to direct, and to catch when the build got them subtly wrong.
Shagunly was tested on TestFlight with family as real, external testers — not synthetic QA. Build 2 cleared Apple's Beta App Review, and that feedback loop directly shaped Build 3 (the read/edit view split and forgot-password flow both came out of it). The app has since cleared full App Review and is live on the App Store ↗.
Shagunly is as much a case study in product judgment as it is in interface design. The interesting decisions weren't about corner radii — they were things like: rebuild native or stay web? Strip the paywall or protect revenue during validation? Ship a calm read-only view or a more powerful but noisier editable one by default?
Directing an AI to build the app didn't replace design thinking — it removed the traditional bottleneck between having a decision and seeing it live in a real, installable product that real people could test. It let me stay end-to-end: the same person who decided what to build also shipped how it works.
Shagunly is out in the world. Get it on the App Store ↗
