Generic discovery platforms (Google, Yelp, TripAdvisor) optimise for volume, not relevance. Users sift through hundreds of 4.2★ results trying to find a spot that fits them, while the three places their tasteful friend would actually recommend rarely surface algorithmically. This isn't a UX issue. It's a data-primitive problem: review systems are built on broad averages, not trust graphs.

Two weeks of discovery before writing a line of Swift. Three streams in parallel:

• Qualitative interviews across 6 cities (light and heavy travellers, 22–38) on how they actually find spots, from first impulse to first save.
• Behavioural teardown of where people store places today: Instagram saves, Notes, screenshots, group chats. The real product I was competing with.
• Competitive teardown of 12 discovery apps, mapping what failed and where the white space was.

• A clear majority of memorable spots came from a specific person, not a search result.
• Trust signal overrides star rating. Users will go to a 3.8★ spot if their friend went.
• Discovery splits into two distinct modes: serendipity (browsing) and intent ("good coffee near me, now"). Current apps blur them and serve both badly.
• Existing apps weaponise FOMO and fake urgency. Users want the opposite: confidence.

Core product thesis: replace the rating as the discovery primitive. Use trust instead. Three decisions shaped everything that followed:

1. Follow the taste, not the place. The unit of discovery is a person's curated list, not a search result.
2. No public scoring. Removing stars removes the noise; what remains is qualitative recommendation between people.
3. Built-in serendipity. A feed of "what people I follow are loving right now" instead of a static map nobody opens twice.

Building solo means there's no handoff cost, and no one to argue against the wrong call. I leaned into both. The week-by-week breakdown:

• Interviews, behavioural teardown and competitive analysis (above) synthesised into a one-page product thesis.
• Mapped the trust graph as a data model in parallel with the UX. Schema decisions made *before* the first wireframe so design and backend stayed aligned.
• Hard scope cut: 12 features brainstormed, 4 kept for v1. Each cut justified in writing against the trust thesis.

• Figma and Xcode open at the same time. Designed a screen, built it in SwiftUI the same day, used the build to test the interaction, then adjusted the design.
• No high-fidelity polishing before shipping the flow. Interaction first, visual refinement second.
• Supabase schema, auth and APIs wired up in the same sprints as the UI. Backend choices stayed honest because the design team was the eng team.
• Mapbox integration prioritised for one specific interaction (the location detail view), not for the whole map experience. Scope discipline at the integration layer too.

• TestFlight cohort of 8 trusted users, 2 rounds of feedback, 3 friction points re-designed and re-built within 48h each.
• Brand, App Store assets, metadata and onboarding copy written in week 6, never earlier. The product had to be true before it could be sold.
• Submitted to the App Store at the end of week 6. Approved first review.

• SwiftUI over cross-platform. Single-engineer velocity is higher when the tools match the platform, no abstraction tax.
• Supabase as backend: auth, database and storage out of the box. Zero infra time competing with product time.
• Figma kept lightweight. System-of-one components, no over-engineering. Just enough structure to support velocity.
• No premature optimisation. Analytics, A/B framework, advanced caching all postponed to v1.1.

• Shipped v1 to the App Store in 6 weeks: design, code, backend, brand, submission included.
• Trust-based discovery validated as a wedge; product surface intentionally narrow so feedback signal stays sharp.
• Roadmap now driven by behavioural data, not assumptions. What users *do* in the app determines what gets built next.

Working solo across research, design, Swift and ops has sharpened how I make product decisions. There's no one to defend the bad ideas. Every build week forces a real trade-off (what's strategically right vs. what ships this Friday) and that tension is the whole job. It's the lens I now bring to every client engagement: shipping isn't a separate phase, it's the design constraint that makes the work honest.