Systems we designed, built, and still run.
Not mockups or concept decks. These are production platforms with real users, real data pipelines, and real money moving through them. Here is what we built, how it works, and what it took to ship.
SlabX: a collectibles portfolio platform
A trading card and collectibles tracker that scans an item, verifies the grader’s certificate, prices it from real sales, and keeps a permanent history of everything the owner holds. SlabX Web is open now; the iPhone and Android apps are on their way to the stores, and one free account signs you in everywhere.
The problem worth solving
Collectors know what their items are worth only in rumor and screenshots. Prices live across a dozen marketplaces in different currencies, grading certificates sit in registries nobody cross-checks, and the story of an item, what it is, who graded it, what it sold for, who owned it, disappears the moment it changes hands.
The goal was a record that travels with the object for life, built only from real sources and owned by the collector. A vehicle history report changed how people buy cars because the past stopped being a rumor. This does that for the things people collect.
What we built
- A cross-platform app and a full web dashboard sharing one account and one data model
- A pricing engine that pulls nine public catalogs and sold-listing sources into one normalized schema
- Certificate verification against grader registries, including coins and banknotes
- An append-only history ledger per item that is written in order and never edited
- Subscription tiers with entitlements enforced on the device and again on the server
How the platform works
Three flows do the heavy lifting. Each one ends with something written down that the collector owns.
Scan and identify
Point the camera at a card. Recognition reads the name and set, then pulls a live price for the exact printing.
The scan image is read and then deleted. Photos the owner adds themselves stay private to their account.
Verify the slab
Pick the grading company, enter the certificate number, and the platform checks it against the registry and attaches what it finds to the item.
Graded coins and banknotes verify through their own registry, so the record is not limited to cards.
Keep the history
Added, paid, graded, verified, photographed. Every step is written in order and never rewritten, so the record holds up when the item is sold or handed down.
Charts read only from recorded history. Nothing on the platform is simulated or back-filled.
The pricing engine
This was the hard part. Every collectible category has a different authoritative source, a different currency, a different refresh cadence, and a different set of rules about what may be shown. Some publishers explicitly ask that their prices never sit behind a paywall, and that is honored in the data layer, not just the copy.
The engine resolves each item to its own source, records every point it ever reads into a price history table, and rolls a daily snapshot per collection. Sold-listing estimates get an outlier filter and a parser that reads only the item price, rejecting shipping, promotional, and strike-through figures.
Built so the record can be trusted
A history ledger is only worth something if it cannot be quietly rewritten, and if the numbers in it came from somewhere real. Both of those are architecture decisions, not features you bolt on later.
- Price history is append-only, so every reading the platform has ever taken is still there
- Re-adding an item merges into the existing row and raises quantity without touching cost basis
- No API keys ship in the app bundle: pricing, verification, and AI calls route through server functions
- The collection works fully offline on the device, then syncs when an account is attached
- Subscription entitlements are authoritative on device and mirrored server-side for gating
One account, every surface
The same collection, the same history, the same entitlements, whether the collector is at a desk or at a card show.
SlabX Web
A dashboard built like a trading terminal: portfolio value as a range, a 90-day chart, the ledger for every item, a watchlist, and market signals in one place.
Open nowiPhone
Camera scanning, certificate verification, and the full collection on device, working offline and syncing when an account is attached.
Coming to the App StoreAndroid
The same build from the same codebase, so a feature ships to both platforms at once instead of being rewritten twice.
Coming to Google PlayUnder the hood
The same stack we build client systems on, running in production under real load.
React Native & Expo
One TypeScript codebase for iOS and Android with file-based routing and native camera access.
Next.js 16 web app
The web dashboard and marketing site, server-rendered, accessible, and localized.
Postgres data model
Collections, quantities, append-only price history, and daily value snapshots, with versioned migrations.
Server-side functions
Proxy functions keep every key off the client and enforce tier gating on the server.
Offline-first storage
On-device database so the collection opens instantly and works with no connection.
Subscription billing
Tiered plans with entitlement checks on device and a webhook mirror for server gating.
Charts from real data
Custom vector charts that read only recorded snapshots, so no value on screen is invented.
Tested and typed
Type checking, linting, and unit tests over the pricing, parsing, and gating logic on every change.
Where it stands
SlabX Web is open to the public with a free account, and the record stays free. The mobile apps are in the pipeline to both stores.
Nine sources across a dozen collectible categories resolve into a single schema, so adding the next category is configuration rather than a rebuild.
Secrets in the client, and zero simulated values anywhere in the product. Scan images are read and then discarded.
Quote-to-cash transformation
Contracts, payments, and onboarding lived in three disconnected tools, stitched together by manual handoffs between sales, finance, and operations. We unified them into a single automated workflow with a custom CRM and payments integration in the middle, so the team could spend its time on customers instead of re-keying the same deal three times.
- Contracts, payments, and onboarding in one automated flow with a human approval step
- Custom integration keeping the CRM and the billing system in sync both directions
- Real-time revenue visibility across the whole customer lifecycle
Faster client onboarding
Clean, structured system data
Room to grow on the same team
Walk through how an engagement like this runs, phase by phase, on our process page.
The same work, pointed at your business.
SlabX is our own product, which means we carry every decision in it: the data model, the integrations, the billing, the accessibility, and the on-call pager. These are the services behind it.
Want one of these for your business?
Tell us where the friction is. A free 30-minute strategy call, a reply within one business day, and a workflow map you keep either way.
Book a Strategy Call