Settl

Settl turns messy “who paid for what?” Slack messages into a live shared expense tab, right where teams already chat. I built this for roommates, student orgs, friend groups, and small enterprise teams that split costs often but never open dedicated expense apps consistently. It matters because it removes the biggest source of friction in shared spending: memory and follow-up. In practice, Settl cuts the back-and-forth of expense tracking and settlement by capturing costs at the moment they happen, showing instant balances, and nudging people before debts become awkward.

What Settl does

Settl is a native Slack expense agent that lets people log, track, and settle shared expenses in plain English.
Examples:

• @Settl grabbed dinner, $94, split 4 ways
• /settl summary
• /settl settle @alex

It parses natural language, stores an expense ledger per channel, calculates who owes whom, supports currency conversion, and can sync expenses to Splitwise for users who connect their account.

Who it's for

Settl is for groups that already coordinate in Slack and need lightweight, reliable shared expense tracking:

• Roommates splitting groceries, rent add-ons, and utilities
• Clubs and student teams managing event costs
• Startup teams tracking offsites, meals, and shared purchases
• Friend groups planning trips

These are people who do not want another standalone app workflow, but rather fast logging inside the conversation they are already having.

Why it matters

Money in group settings is uncomfortable because it's personal, and the solution isn't more reminders or tougher conversations. When a group has a neutral place where expenses are visible, shared, and updated in real time, the emotional weight disappears.

Settl is that neutral place, built inside Slack where the group already lives. Nobody has to become the "human ledger," and nobody has to chase anyone down. Expenses get logged the moment they happen, balances stay visible to everyone, and settlement is one command away.

Impact:

• Reduces forgotten expenses by logging them in real time from chat
• Reduces coordination overhead with one-command summaries and settle flows
• Reduces awkward follow-ups with proactive reminder nudges
• Improves trust by keeping a visible, shared source of truth

Personal Story

I recently started a new job and moved to a brand new city. Managing my expenses is crucial, but there's always a bottleneck. I built Settl because I kept seeing the same pattern in shared groups: someone pays, everyone says “I’ll send it,” and then nobody remembers details a week later. I have been in group chats where one person quietly became the human ledger, and that role always burned out. I wanted a tool that felt less like bookkeeping and more like natural conversation, especially one where you never have to leave your default messaging platform.

What it does

At a high level, Settl:

• Listens to Slack mentions, slash commands, and interactive actions
• Understands expense intent from natural language (AI + regex fallback)
• Validates and computes equal/custom splits
• Persists groups, expenses, and linked account tokens in Slack Datastores
• Shows balance summaries and settlement actions via Block Kit
• Optionally syncs new expenses to Splitwise
• Sends reminder nudges on a configured cadence

How I built it

Settl is built with Node.js and Bolt for JavaScript as a Slack-native app.

Architecture highlights:

• Listeners: mentions, commands, actions, and assistant handle Slack entry points
• Pipeline: a shared expense pipeline does parse -> validate -> split -> persist -> confirm
• Parsing layer: AI-powered parser (NVIDIA/OpenAI/Anthropic) with deterministic regex fallback
• Data layer: Slack Datastores for groups, expenses, and user tokens
• Integrations: Splitwise OAuth + REST sync, optional Splitwise MCP, FX conversion API
• UX: Block Kit confirmations, review cards, custom split modal, settlement actions

Challenges I ran into

• Natural language ambiguity: “split” can mean new expense logging or settlement context; I added intent reconciliation and safer fallbacks.
• Mention handling: distinguishing Slack user mentions from plain-text @name required separate resolution logic and error handling.
• Interactive state: review cards and modals needed temporary draft storage and expiry handling to prevent stale actions.
• Sync reliability: external API failures should not block local logging, so sync is best-effort with clear user feedback.
• Slack UX constraints: assistant/thread behavior and action responses required careful routing to keep messages in the right place.

Accomplishments that I'm proud of

• Built a complete end-to-end flow from chat message to persisted ledger to actionable settlement.
• Kept the UX conversational while still handling structured financial logic.
• Added graceful degradation (AI parser fallback, splitwise sync fallback) so core behavior remains reliable.
• Designed the app around where people already work (Slack), instead of forcing another app habit.

What I learned

• Reliability beats cleverness in financial workflows; users need predictable outcomes first.
• AI parsing works best when paired with strict schemas, guardrails, and deterministic fallbacks.
• Small UX choices (clear confirmations, actionable buttons, gentle reminders) matter as much as backend logic.
• Integration-heavy products need thoughtful failure handling from day one.

What's next for Settl

• Add stronger onboarding for first-time group creation and member setup
• Improve settlement sync beyond expense creation (full two-way reconciliation)
• Add richer analytics (who owes trends, monthly summaries, recurring costs)
• Support policy/custom rules for teams (default splits, expense categories, approvals)
• Expand payment rails beyond Venmo links for faster completion

Built With

• block-kit
• bolt
• datastore
• javascript
• node.js
• nvidia-build
• sdk
• slack
• slack-ai
• slack-cli
• socket
• splitwise-mcp