Zapnin
Selected work
Plans that actually happen.
Zapnin is our chat-first social planning app, and the most fun thing we've built. Drop a plan in the group, everyone answers In, Out, or Depends, and a resolution engine untangles the “I'll go if you go” loops until the plan is actually on.
Visit the live siteBuilt by Pivot & Anchor, a small product studio.- Studio
- A Pivot & Anchor product
- Platform
- iOS & Android
- Category
- Social planning
- Stack
- Expo, Node, Postgres, Redis
- Get it
- App Store & Google Play
- Status
- Live, free, no ads
Zapnin is the most fun thing we've built, and the one that fought back hardest. It is a chat-first social planning app for the oldest problem in any group chat: the plan that never happens.
You know the failure. Someone says “we should hang out,” three people say “maybe,” one says “I'm down if everyone else is,” and the thread dies. Zapnin replaces the maybe. Everyone answers In, Out, or Depends. Conditions stay private. A resolution engine works out who is waiting on whom, breaks the loops, and the moment it tips, the plan is on.
How it works
01 — Open Zapnin
Scene's lit, you in?
Zapnin opens on its one question, and the whole app exists to answer it. No feed to scroll, no profile to polish, just the people you actually make plans with and a faster way to turn “we should hang out” into a time and a place. One tap and you are looking at your plans, not a setup wizard.
02 — Your plans
Every plan, and where it stands
The home screen is a live board of everything in motion. Each plan shows who has answered and how many are confirmed, with a status that keeps itself current: It's On once it tips, Pending while it waits, Action Needed when the next move is yours. Filter to just the plans that need you, and the group chat that used to bury every plan is replaced by a list that always tells the truth.
03 — Inside a plan
Going, maybe, and who's actually in
Open a plan and the whole picture is on one screen. The place, the date, a bar that fills as people commit, and the count of who is Going against who is still a Maybe. The conditional answers resolve here too, so the moment enough hard yeses land the plan tips to confirmed. The chat sits right under it, because the conversation and the plan were never two separate things.
04 — Chat
The conversation is the plan
Every plan carries its own thread, and it is a real one, with typing, reactions, and replies that reach every phone the instant they are sent. The difference from a group chat is what the messages do. What gets decided here updates the plan itself, so talking it out and watching the plan move are the same action in the same place.
05 — Circles
Your crews, ready to go
The same people plan together again and again, so Zapnin keeps them as Circles. Each one holds its members, its history, and the count of plans you have run together. Starting the next one is a single tap from the group instead of rebuilding the invite list every time, so your regular crew is always one button from the next hang.
06 — Split the bill
Split it without the spreadsheet
When the plan actually happens, the money lives inside it. Add what was spent, split it evenly or by head, and Zapnin works out who owes whom. Drop in a UPI ID and people pay you back in a tap, and every expense and payment is tracked against the plan so nobody reconstructs the night from memory.
07 — Settle up
Down to the fewest transfers
Across a whole circle the debts pile up in every direction, so Zapnin reduces them to the smallest set of payments that clears everyone. Settle Up is the running ledger of who paid what, across every plan, kept in full so a balance is never a guess. Five tangled IOUs become one or two transfers, and the friendship survives the trip.
What we built
Honest responses
In, Out, or Depends. The Depends is the wedge: a conditional yes that keeps the plan alive instead of stalling it.
The resolution engine
A graph that maps conditions, detects circular dependencies, and resolves chains automatically from confirmed anchors outward.
Live status
Every response propagates to every device in real time, so the plan's state is always honest and shared.
Split the bill
In-chat expenses, simplified-debt settlement to the fewest transfers, and circles that remember your groups.
Privacy by default
Show the status, not the story. Conditions stay private; only the outcome is shared.
Zapnin looks like a chat app. Underneath, it is a coordination engine.
The mobile app is React Native on Expo SDK 54, one TypeScript codebase across iOS and Android, on the New Architecture. State is local-first: Zustand stores hydrated from encrypted on-device storage, updated optimistically, with a query cache as a warm fallback. A socket layer keeps it honest. Every plan and every chat is a live room, and responses reach every invitee the instant they happen.
The resolution lives on the server, never the client. The client renders state; it does not compute it. A “depends on Priya” can resolve from any device without races. The engine builds a dependency graph per plan, detects cycles, anchors on the hard confirmations, and propagates outward until the plan finalizes. That is the piece everything else hangs off.
The backend is Node and Express on PostgreSQL with Drizzle, twenty-three tables modelling plans, invitees, conditions, chat, bills, and circles. Socket.IO runs behind a Redis adapter so it scales across instances. Background work runs on BullMQ: nudges to non-responders, day-of reminders, deadline checks, auto-completion, and a settlement cascade across circles.
It runs on Railway, with Postgres, Redis, and a multi-stage Docker build that migrates on deploy. There is a web layer too: a marketing site plus invite links that let someone RSVP and vote on the venue from a browser before they ever install, and a private operations dashboard for the team.
The hard parts
The resolution engine
Graph-based dependency propagation with cycle detection and anchor-based confirmation. The maybe-loop, solved in code.
Real time at scale
Socket.IO behind a Redis adapter, every plan and chat a live room, state broadcast cleanly across instances.
Notifications that respect you
Escalation-based push batching with atomic Redis operations. A busy chat sends one digest, not forty pings, and a mention always breaks through.
Money math, instant
Simplified-debt settlement and a layered, stampede-proof cache so balances across every plan stay instant.
Honest offline
Optimistic UI with rollback, a message queue for dead zones, and a reachability check tuned for real-world networks.
Zapnin pairs a loud display face with a calm body. Righteous carries the headlines, round and confident, the way the product talks. Plus Jakarta Sans does the reading, neutral and modern.
- RighteousDisplay & headings
- Plus Jakarta SansBody & UI
Electric indigo leads, the colour of the brand and every primary action. Then a pair you read without thinking: emerald means In, red means Out. Amber warns, and true black carries the dark mode.
- IndigoPrimary. The brand and every key action.#6366F1
- EmeraldSuccess, and the colour of “In”.#10B981
- RedErrors, and the colour of “Out”.#EF4444
- AmberWarnings and pending states.#F59E0B
- InkTrue-black dark-mode background.#0A0A0A
- PaperLight-mode background; dark-mode text.#FAFAFA
In testing, plans that used to die in the chat got far more likely to actually happen.
Closed beta