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.

8 min read • View on GitHub • More from Tahsan228

A wide editorial scene shows a home kitchen counter assembled like a verification line. A receipt, a sealed meal container, and an order screen feed into a database cylinder and a stamped ledger-like log. The image explains that Dishd turns a meal into a trust event, not just a listing.
Dishd’s core idea is simple: commerce is only useful if the system can prove where it came from and who completed it.
Key Takeaways

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.

Dishd’s state machine makes the cook, not the buyer, the source of a verified completion event.

buyer places order
  -> order pending
cook marks complete
  -> backend trigger writes verified check-in
  -> credibility recomputes
buyer cannot complete order
  -> invalid transition blocked
A close-up shows a hand dropping a completed order card into a slot labeled as a verified check-in while a second hand is blocked from inserting a fake badge. A mechanical counter behind the slot advances a credibility tier. The scene explains how Dishd ties reputation to allowed workflow transitions.
The system does not ask users to behave honestly. It makes only one path count as proof.

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 handlingDishd handling
Upload a receipt and trust the uploadReceipt freshness, unique hashes, and OCR-linked fields constrain reuse
Moderation catches suspicious cases laterDatabase rules prevent obvious reuse up front
Old proof can linger indefinitelyFreshness windows expire stale sourcing evidence
Proof is just metadataProof 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 logicDishd logic
Users claim credibility through profilesThe system computes credibility from live signals
Trust changes slowly and by conventionTrust changes when transactions and checks do
State often lives in the UIState lives in triggers and database functions
Abuse is handled mostly by moderationAbuse 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.

QuestionConventional local marketplaceDishd
Where does trust come from?Profiles, ratings, and moderationReceipts, completion events, and database-enforced rules
Who can create proof?Usually any participantOnly allowed workflow transitions create verified events
How is location handled?Often public by defaultPublic discovery is fuzzed, exact addresses are gated
What keeps reputation current?Manual updates or async moderationTriggers and computed credibility
What does the database do?Store recordsEnforce 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.