-
-
GIF
Connecting a bank through Plaid, so posted transactions are read straight off the card they landed on.
-
GIF
Adding cards, grouped by bank. A card your connection does not carry is disabled in the picker rather than failing later.
-
GIF
The advisor answers in plain language, and every figure carries a trace of which engine call produced it.
-
GIF
Outside one store it names the shop and the card. In a mall it says it cannot tell, and asks which shop you are in.
-
Same $120, different merchant. Amex Gold is first at Trader Joe's and fourth at Walmart, which codes as a discount store.
-
The model writes the rules; the code does the math. A purchase crossing a bonus cap earns $15.00, not the $30.00 a naive rate gives.
Live demo: https://pointwise-2lmw.onrender.com/ — the browser console. Type any merchant and amount and it ranks your whole wallet with the arithmetic shown. It runs on a free tier that sleeps when idle, so the first load can take up to a minute. No credentials needed.
Note that the console and the phone app are two front-ends over the same engine, and they look nothing alike: the dark interface in the video is the Expo app, which runs from the repo (cd mobile && npx expo start). The console is the one you can try without installing anything.
Inspiration
The average US wallet holds four credit cards, each with a different reward structure: rotating quarterly categories, spend caps that reset annually, points worth anywhere from 0.6 to 2.1 cents depending on how you redeem them, and bonus categories defined not by the store's name but by a four-digit merchant category code assigned by its acquiring bank.
So people default to one card and leave money on the counter. The information needed to choose correctly already exists — it is just spread across cardmember agreements nobody reads and arithmetic nobody does standing at a till.
What it does
Ranks your wallet for any purchase. Give it a merchant and an amount and it returns every card you hold, ordered by what each would actually earn, with the gap to second place. $120 at Trader Joe's and $120 at Walmart produce different winners, because Walmart's merchant category code is discount store, not grocery — the same Amex Gold is first in one and fourth in the other.
Tells you where you are and what to use. A banner on the home screen asks for your position only when you tap it, resolves nearby merchants to spend categories, and names the card. In a mall with several shops in range it stops guessing and asks which one you are in.
Reads your real statements. Connect a bank through Plaid and the app pulls posted transactions straight off the card they landed on — which makes the payment method irrelevant. Tap, Apple Pay, PayPal, a card number typed into a form: it all posts to the card, and the card's statement is the honest record.
Scores what you already spent. The activity feed replays every posted transaction through the engine and shows earned versus optimal — $234.21 earned against $65.64 left behind over the demo month, itemised by transaction, so the number is auditable rather than asserted.
Answers questions in plain language. A Claude-powered advisor can rank a purchase, read your wallet, describe a card, audit recent spending, and look up what is nearby — and every answer carries a trace of which of those it used.
How we built it
The architecture rule: the model writes the rules, the code does the math.
A language model reads cardmember agreements and emits structured EarnRule records — rate, category, cap, cap period, activation requirement, redemption value, provenance. A human reviews them. From then on no language model is anywhere near a dollar figure; the engine evaluates those rules deterministically.
The reason is narrow and practical: ask an LLM to apply a $6,000 annual grocery cap to a $500 purchase when $5,800 is already used and it will be confidently wrong. The correct answer is 6% on $200 and 1% on $300 — $15.00, not the $30.00 a naive 6% gives. A wrong dollar figure costs more credibility than no dollar figure at all.
That constraint is enforced in code, not just in a prompt. The advisor has five tools and none of them can move money; a test asserts there never is one. The "what's nearby" tool takes no arguments, so a hallucinated latitude is not expressible — the app supplies the coordinates.
Stack. FastAPI + Pydantic engine, Expo / React Native client for iOS and Android, PayPal and Plaid sandboxes, Claude for the advisor, Render for the hosted console. 333 tests pass with no network access.
Challenges we ran into
PayPal Vault has two APIs and only one of them can pay. Vault v3 mints a token that drops into payment_source.card.vault_id; it needs Save payment methods on the REST app and returns NOT_AUTHORIZED without it. Vault v1 is authorized where v3 is not and still stores a real per-card record keyed by external_card_id — but Orders v2 rejects its id, so it gives identity without execution. The code tries v3, falls back to v1, then to a published test card, and records which tier actually paid: funded_from_vault is false for anything but v3, because conflating the two would be the easiest lie in the system.
PayPal-Request-Id is mandatory on any order carrying a payment_source, and it is the idempotency key — without it a retried order can charge twice.
Transaction Search is merchant-scoped and lags about three hours. It returns the transactions of the business account the REST app belongs to, not a consumer's spending history. So the app records its own captures at capture time and merges the two, with the ledger winning on conflicts.
The honest limit. payment_source.card.vault_id is the merchant's field, and no buyer-side PayPal scope reaches another account's payment methods. So Pointwise cannot choose the card for you — it tells you which earns most and shows the arithmetic, and you tap that card yourself. Discovering that reshaped the product from "pays for you" into "advises you", which is the honest version.
Accomplishments that we're proud of
- Cap splitting and value-based ranking, the two things a lookup table gets wrong. 4x on a card worth 1.8c/point is 7.2%, which beats a 6% cashback card — ranking by the advertised rate gets this backwards.
- Labelled confidence on every category decision —
mcc:,known-merchant:,plaid:orinferred:— so a guess is never dressed up as a fact. - Nothing is passed off as real. Every endpoint reports
is_demo_data, every rule carriesverified_by_human, and the loader audits how many are still unreviewed. - 333 tests, and an engine that needs no network to prove itself.
What we learned
That the interesting constraint in payments is not technical but who holds the scope. Reading a buyer's own activity is a partner-level integration, not a hackathon one — and once you accept that, the product gets better, because an advisor that shows its arithmetic is more trustworthy than a black box that spends your money.
And that an LLM is a terrific reader and a terrible calculator. Splitting those two jobs — the model narrates, the code computes — is the whole design.
What's next for Pointwise
- The extraction pipeline that produces the rules, and draining the human-verification backlog: all 40 seed rules currently ship marked unverified.
- Live Log in with PayPal — implemented, but it needs a registered HTTPS return URL, which Expo Go cannot provide.
- Real card state from an aggregator instead of simulated prior spend.
- Point valuation tuned to actual redemption behaviour, and annual fees amortised into the per-purchase answer.
Try it yourself
No credentials are required — the engine, API, web console and mobile app all run from bundled demo data, and every response reports is_demo_data.
git clone https://github.com/chidrupa99/pointwise
cd pointwise && uv venv && uv pip install -e ".[dev]"
PYTHONPATH=src .venv/bin/python scripts/which_card.py "Trader Joe's" 120
PYTHONPATH=src .venv/bin/python scripts/which_card.py Walmart 120
.venv/bin/python -m pytest -q
PYTHONPATH=src .venv/bin/uvicorn pointwise.api:app --reload --port 8077
Run those two which_card.py lines back to back and you have the whole argument for the project: same $120, different merchant, different winning card.
Built With
- anthropic
- claude
- expo.io
- fastapi
- paypal
- plaid
- pydantic
- python
- react-native
- render
- typescript