Dishd: The Marketplace That Turns Meals Into Verifiable Trust
A halal home-cooking PWA that pushes receipts, pickup, reputation, and privacy rules into the database so local food commerce can be verified instead of guessed.
- Dishd treats trust as infrastructure, so receipts, pickup events, and reputation are enforced by the system instead of left to user discretion.
- The most interesting mechanic is not the listing flow but the state change, because a completed order becomes a verified check-in only when the cook closes it out.
- Privacy is part of the product design, with fuzzed public locations and gated address reveal preserving discovery without exposing home kitchens.
- The stack matters because the database is not passive storage here, it is part of the product logic that computes credibility and blocks abuse.
Trust Is the Product
Most marketplaces for local food lean on profiles, ratings, and moderation. Dishd takes a harder line: it tries to make trust mechanically enforceable. That changes the product from a directory into a verification system.
The repo’s structure makes that thesis obvious. The marketplace flows live alongside social and reputation logic, while Supabase and Postgres carry the rules that matter most. In Dishd, trust is not a layer on top. It is part of the stack.
The Order That Becomes Proof
The sharpest idea in the codebase is the order-as-check-in flow. A buyer can place an order, but only the cook can mark it complete, and that completion writes a verified event into the system. The result is a trust event that cannot be minted by the wrong party.
buyer places order
-> order pending
cook marks complete
-> backend trigger writes verified check-in
-> credibility recomputes
buyer cannot complete order
-> invalid transition blocked
Receipts, Freshness, and Anti-Reuse
Dishd’s sourcing layer is where the trust story gets concrete. Meat dishes can require receipts, and those receipts are not treated as casual attachments. The codebase applies freshness windows, uniqueness constraints, and OCR-linked fields so proof is harder to recycle across kitchens.
| Conventional handling | Dishd handling |
|---|---|
| Upload a receipt and trust the upload | Receipt freshness, unique hashes, and OCR-linked fields constrain reuse |
| Moderation catches suspicious cases later | Database rules prevent obvious reuse up front |
| Old proof can linger indefinitely | Freshness windows expire stale sourcing evidence |
| Proof is just metadata | Proof becomes part of the trust chain |
That design matters because the abuse case is obvious. If proof can be copied, the marketplace becomes theater. If proof is constrained by the database, the marketplace has a chance to stay legible.
Credibility Is Calculated, Not Claimed
Dishd does not treat reputation like a vanity score. Credibility is computed from signals such as completed orders, sourcing streaks, permits, cancellations, and upheld flags. The repository then pushes that logic into Postgres triggers so the result stays current without being hand-maintained in the UI.
That is the deeper product decision. A badge says, "trust me." A computed system says, "here is what the data supports right now." In a trust-sensitive marketplace, the second approach is much harder to game.
| Badge logic | Dishd logic |
|---|---|
| Users claim credibility through profiles | The system computes credibility from live signals |
| Trust changes slowly and by convention | Trust changes when transactions and checks do |
| State often lives in the UI | State lives in triggers and database functions |
| Abuse is handled mostly by moderation | Abuse resistance starts in the data model |
Privacy Without Losing Discovery
Dishd also solves a quieter problem: how do you let people discover home kitchens without exposing exact addresses? The answer is to separate public presence from private location. The map gets fuzzed coordinates, while the exact address stays gated until it should be visible.
That gives the platform a useful middle ground. Buyers can browse locally, but cooks do not have to publish their home like a storefront. For a home-cooking marketplace, that is not a cosmetic detail. It is a trust requirement.
Why This Is Not Just Another Marketplace
Compared with a conventional local marketplace, Dishd shifts the center of gravity away from listing quality and toward verifiable workflow. Reviews narrate trust after the fact. Dishd tries to manufacture the evidence first.
| Question | Conventional local marketplace | Dishd |
|---|---|---|
| Where does trust come from? | Profiles, ratings, and moderation | Receipts, completion events, and database-enforced rules |
| Who can create proof? | Usually any participant | Only allowed workflow transitions create verified events |
| How is location handled? | Often public by default | Public discovery is fuzzed, exact addresses are gated |
| What keeps reputation current? | Manual updates or async moderation | Triggers and computed credibility |
| What does the database do? | Store records | Enforce the product thesis |
Built Like a System, Not a Demo
The stack reflects the idea. Next.js handles the app layer, Supabase and PostgreSQL carry the rules, Stripe handles payments, and tests exercise the flow. The important part is not that the project uses modern tools. It is that the tools are arranged so the database can participate in product logic.
That is why Dishd feels more like a protocol than a storefront. The code says the platform cares less about looking trustworthy and more about making trust auditable.
The Bigger Idea
Dishd points to a broader lesson for local commerce. If a platform depends on trust, it may need to encode trust in the data model, not bolt it on with reviews and hope. That is a stricter design, but it is also a more honest one.
The project is small, but the idea is durable. In marketplaces where authenticity matters, the best interface might not be the most persuasive one. It might be the one that can prove what happened.





