Three pieces, cleanly separated.
The Exchange front end is ours — a site in our hosting environment at exchange.fitmentindustries.com, built from the design you just walked through. The marketplace machinery (listings, transactions, escrow, messaging) is Sharetribe's hosted platform, reached over their APIs. Money never touches our servers — Stripe handles payments, seller identity, and payouts underneath Sharetribe. Nothing new is bolted into the existing FI/CO cart.
EEI Retail Platform
- Identity (SSO): one login across FI, CO & the Exchange
- Store-credit wallet: the ledger sellers cash into at 100%
- Catalog service: specs that prefill & verify listings
- Fitment / YMM data: 180K builds behind "fits my car"
- Gallery: two-way — listings link to real builds, and "Shop This Build" rails on FI list the owner's used gear with an Exchange-logo link (supply flywheel)
- Retail storefronts: where store credit gets spent
Enthusiast Exchange Front End
- This demo's design as the skin on Sharetribe's web template (React/Node)
- Deployed like our other brand sites — same hosting, DNS, CDN, analytics
- Browse, PDP, sell wizard, dashboard, messaging UI, help/track
- Holds no payment data, no marketplace records — stateless against the APIs
- Plus a small server-side service for webhooks (credit payout, labels, spec checks)
Sharetribe + Stripe
- Listings & search (with our custom spec fields)
- Transaction engine: offers, escrow-style delayed capture, the 48-hr inspection timer
- Messaging, reviews, users, listing-approval queue (ops console)
- Stripe Connect: payments, seller KYC, 1099-K, cash payouts
- Transactional emails (our branded templates)
- Their uptime, scaling, and PCI burden — not ours
Rule of thumb: customers see our site · Sharetribe moves the transaction · Stripe moves the money · EEI keeps the identity, the data, and the credit.
The Exchange runs on the same fitment engine as FI and CO — literally the same service, not a copy. At item entry, every listing is checked against three sources: the VCDB FI and CO run on, the EEI PIM (the product-information master with all fitment & spec data), and the Exchange's own listing history. Match anywhere → specs prefill and fitment is live at publish. No match → AI validation confirms it's genuinely new, then it flags for spec-team review before going live; approval writes it back to the PIM so the next seller matches instantly — nothing lists into a fitment dead zone, and the catalog gets smarter with every listing. When a shopper picks a vehicle, the Exchange asks the engine the identical question the retail sites ask, gets back the spec envelope, and translates it into marketplace search filters. One fitment truth, zero duplication.
Launch: envelope query → search filters (engine untouched). Fast follow: spec-check stamps fitment metadata per listing → instant "✓ fits your car" chips and the badge nobody can copy: "gallery-verified on your exact chassis." Prerequisite to confirm: is the engine exposed as an internal service, or embedded in the cart code (service-izing it helps FI/CO too)?
There are no duplicate customer records to reconcile. EEI identity mints eei_user_id and stays the system of record; SSO carries that ID into Sharetribe as the OIDC subject, Stripe stores it in account metadata, and the wallet ledger and gallery key on it natively. Sharetribe's user record is a projection of ours, not a second customer — full entity map with every key on the Data Map briefing.
Every listing is machine-inspected before a human ever sees it. Photos run through the vision API — does the wheel in the photo match the catalog part claimed, does visible rash contradict the condition report, what's the DOT date stamped on that sidewall, are there counterfeit tells. Listing text and messages run through text moderation for scam patterns and off-platform-deal attempts (surfaced via Integration API events).
The pipeline: new listing → vision + text checks → auto-pass clean matches, auto-reject rule-breakers, route ambiguity to the moderation queue in the ops console. Humans judge only what machines can't — that's what holds the ~10-minute spec-check promise and the lean ratios on the Team & Ops Plan. Sellers get the assist too: one-click listing descriptions generated from the VCDB match, condition grade, and photos — Gemini Flash-Lite (Google's cheapest model), server-proxied with rate caps (10 per page load, 100/day per IP) so the button can't become a bill. Per-image costs on the Costs brief (~1–3¢).
We deliberately don't sell used tires — tires age out, wheels don't. That gap is a brand integration, not a missing feature: new tires sell right on the Exchange — the first-party Tires category, stocked and shipped by Only Tires, sized to the wheels being bought — and Treadsy books local installation at a shop near the buyer, the same Treadsy integration already running on onlytires.com.
The flywheel gets a third spoke: used wheels sell on the Exchange → new tires sell at Only Tires → install books through Treadsy → and the seller's store credit comes back through EEI retail. Promo bands are already designed into the PDP, the upsell step, and the order confirmation.
The honest constraint: the marketplace engine is single-provider per transaction — there is no native multi-vendor cart, and no amount of front-end cloning changes that (the pages were never the problem; the checkout flow is). The unlock is that Only Tires is family: tires ride the used-wheel order as custom line items on ONE charge to the buyer. Buyer experience: one checkout, one payment, two clearly-labeled shipments (tires from the OT warehouse, wheels from the seller — which is physically true no matter what).
What's platform-native vs. ours: custom line items with includeFor semantics (charge the buyer / credit the provider) are stock Sharetribe — it's how their own commissions and shipping fees are modeled — so the seller's payout automatically excludes the tire lines and that portion accrues to the operator (us) in our Stripe balance. Transaction events over the Integration API: also native. Ours is one thin webhook step (the same service already scoped for credit payouts and labels): on the order event it posts the tire order to OT's platform — or directly into NetSuite as a sales order — and books the internal settlement (wallet-ledger entry + NetSuite journal). Because the split is EEI-to-EEI money already sitting in EEI's account, settlement is accounting, not payments engineering.
Phasing: Launch = the first-party Tires category (designed in the demo — Only Tires catalog, sold-by badging, retail terms) with per-listing checkout. Fast follow = tires as line items on used orders with internal settlement, reusing the FI add-on split already scoped above. Fallback if line-item settlement stalls: OT as a first-party seller account — checkout chains two transactions behind one review screen (card entered once). Only works this cleanly because both sides of the split are EEI companies.
Why not the reverse — clone the OT site and build the Exchange on the retail cart? Because the platform must follow the risky money. Host checkout on the retail cart and EEI becomes merchant of record for peer-to-peer sales — rebuilding escrow, seller KYC/1099-K, offers, facilitator tax, and used-goods chargebacks in-house on the legacy cart: the exact build this project avoids. The marketplace platform owns the money; the retail platform owns the shelf. One checkout, two warehouses.
Transaction reviews are native to the marketplace — Sharetribe's built-in engine: double-blind (neither side sees the other's review until both post or the window closes), tied to verified completed orders only, and surfaced hard in the product — seller ratings on every listing card, review quotes on the PDP, full breakdowns on seller profiles. Trust is earned deal by deal and can't be imported or bought.
Birdeye handles the property level — the same reputation platform EEI already runs everywhere: the Exchange gets its own Birdeye profile, post-transaction review requests follow the family playbook, and the aggregate rating shows on-site (see the About page). Seller reputation stays native and un-gameable; site reputation compounds with the rest of the family.
What connects to EEI.
| Integration | How | Effort | Phase |
|---|---|---|---|
| Single sign-on — one account across FI / CO / Exchange | EEI identity provider via OpenID Connect (Sharetribe-native SSO support) | 1–2 wks if our auth can front OIDC | Launch |
| Store-credit payout — sellers take 100% as EE credit | Sharetribe Integration API event → our webhook → EEI wallet/credit ledger API | ~2 wks if a credit ledger API exists; sized by that answer | Launch |
| VCDB + PIM + historical match on item entry — three sources, one answer | Every entry checks the VCDB, the EEI PIM (all fitment & spec data, in build), and every item ever listed on the Exchange → specs prefill, fitment live at publish. No match anywhere → AI validates it’s genuinely new → spec-team review flag BEFORE it goes live; approval adds it to the PIM for everyone after | 2–3 wks (data exists — pipeline work) | Launch |
| YMM / "fits my car" filtering | Fitment data → search filters; same engine as retail | 2–3 wks | Launch |
| Gallery integration — the same one already live across FI, CO & the family | Exchange renders the shared gallery service natively in its own chrome (see the demo's Build Gallery page) exactly as FI and CO render it in theirs — plus PDP "paper trail" rails, category gallery bands, build ID on listings, and "Shop This Build" rails listing used gear with Exchange-logo links, both directions | ~1 wk — the service and cross-site pattern already exist | Easy |
| Cross-site nav & brand strip (back-links, EE family footer) | Static — already designed in this demo | Done in design | Easy |
| AI moderation & vision verification — listings, photos, messages | Claude text + vision APIs on Integration API events; verdicts write back to the approval queue | ~2 wks alongside the spec-check bot | Launch |
| My Garage — shared vehicle list | Vehicles live on the EEI account (same customer key as SSO); Exchange reads/writes the same garage FI & CO use — set-current drives fitment filters, purchases stamp which car they fit. Owners upload ride photos and opt-in sync to the Fitment Gallery (explicit terms consent) — garage becomes a gallery on-ramp | ~1 wk — data already exists, surface it | Launch |
| Birdeye reviews — same reputation platform as every EEI property | Exchange profile added to the existing Birdeye account; post-transaction review requests routed like other EEI sites; aggregate rating surfaced on-site | ~days — existing contract & playbook | Launch |
| NetSuite (ERP) — orders & settlement land where the books live | Webhook service posts FI/OT-fulfilled line-item orders as NetSuite sales orders (direct or via the OT platform sync), plus journal entries for wallet-credit liability and internal marketplace settlements; nightly three-way recon (Stripe · Sharetribe · ledger) reconciles into NetSuite | ~2 wks alongside the wallet/webhook service | Fast follow |
| Commission Junction affiliates — the network EEI already runs | Exchange program inside the existing CJ advertiser account: deep links to every page + live listing datafeed; conversions fire on completed (post-inspection) orders | ~1–2 wks — account exists, add program + pixel | Fast follow |
| Team Stance street team — heritage FI program, Exchange edition | Member flag on the EEI account → 25% supplies pricing via the promo engine + auto-enrollment in the CJ program + profile/listing badge | ~1 wk on top of the CJ work | Fast follow |
| HubSpot chat & CRM — the chatbot we already run | Existing EEI HubSpot instance: chat widget embedded on Exchange pages, tickets route to the Exchange CS pipeline, order context passed in | ~days — widget embed + pipeline config | Launch |
| Only Tires × Treadsy install — used wheels, new tires | Phase 1: first-party Tires category on the Exchange (Only Tires catalog + Treadsy install booking — the Treadsy integration is live on onlytires.com). Phase 2: tires as line items in Exchange checkout — one charge, internal EEI settlement, OT fulfillment API (see the tires callout). The first-party Tires category is designed in the demo — real Only Tires catalog items w/ live prices, tire PDPs with size filtering + one-tap Treadsy install, a dedicated "Tires on your time" install page, retail (non-escrow) terms | Ph1 ~1–2 wks · Ph2 3–4 wks w/ the add-on split | Fast follow |
| BNPL & alternative payments — Affirm · PayPal Pay-in-4 · Katapult | Affirm rides Stripe PaymentIntents (nearest to live; enablement scoped w/ Sharetribe). PayPal + Pay Later = separate rails, custom checkout step. Katapult = existing EEI lease-to-own partner; used-goods underwriting sign-off is the gate. Every method settles into the SAME escrow — financing changes how the buyer pays, never when the seller gets paid | Affirm 2–3 wks · PayPal scoped separately · Katapult = partner conversation | Fast follow |
| Plate / VIN lookup in the vehicle finder | Third-party decode service (same class we use at retail) | ~1 wk | Fast follow |
| Checkout add-on upsells — lugs, hub rings, accessories that ship from FI | Interstitial upsell step (designed — see the demo's buy flow) → custom line items + FI fulfillment split on the same order | 2–3 wks — line items are Sharetribe-native, the split is ours | Fast follow |
What talks to Sharetribe.
| Channel | Used for | Direction |
|---|---|---|
| Marketplace API (browser/template) | Search & browse, listing pages, auth'd user actions: post listing, offer, checkout, messages, reviews | Front end → Sharetribe |
| Integration API (our server, secret key) | Events/webhooks (transaction transitions → credit payout, label purchase, delivery→inspection timer), ops automation, spec-check bot, seeding | Both ways |
| Console (humans) | Listing approval queue, user management, transaction oversight, email template editing — the ops console you saw maps here | Ops team → Sharetribe |
| Stripe Connect (under Sharetribe) | Buyer payments, escrow-style capture, seller identity/KYC, 1099-K, cash payouts | Managed by Sharetribe |
| Platform mechanics worth naming (all documented Sharetribe features) | Multiple transaction processes in one marketplace — the exact mechanism letting Only Tires run retail terms (instant capture, no inspection, returns) beside P2P escrow · multi-quantity stock covers first-party tire inventory where P2P stays quantity-one · native geo-search powers the within-250-mi / local-pickup filters | Native — configuration, not code |
| flex-cli (deploy-time) | Transaction process pushes, search schema — config files already written and in this repo | Dev → Sharetribe |
Already proven: these demo pages authenticated against our real Sharetribe dev marketplace this week (Marketplace + Integration APIs both verified live). Config pack — transaction process, search schema, seeder — is written and waiting in the repo.
What makes marketplaces sticky, not just safe.
Benchmarked against Reverb and Sweetwater Gear Exchange. The first two are designed into this demo (Price Guide + Follow/Feed); the rest are sequenced levers, not scope creep.
| Feature | How | Why it matters | Phase |
|---|---|---|---|
| Price Guide + deal badges (in demo) | Aggregate completed sales (escrow-verified, condition-graded) + catalog reference → public guide pages, "Great Value / At Market / Above Market" badges; deterministic math | Reverb's moat feature; ours is better-sourced (retail prices + VCDB). SEO cannon: "what are RPF1s worth" | Fast follow |
| Follow + Feed + digests (in demo) | Follow sellers/searches/models/chassis → event fan-out into a feed + daily digest email + instant push; builds on the notification and saved-search rails already scoped | THE retention mechanic for qty-1 inventory — the right set appears once | Fast follow |
| Boost — promoted listings (Reverb calls it Bump; ours drives) (in demo) | Seller picks 2/4/6% at listing (rate picker live in both sell flows); placement boost via search metadata + our ranking; charged only when the bumped item sells; promoted cards labeled | Zero-inventory, high-margin revenue sellers actively want — currently absent from the revenue model | Phase 2 |
| Offers to watchers + auto-accept thresholds | Watcher lists exist; seller pushes a private price (transaction offer w/ audience) + min-acceptable rules on listings | Converts the watch count into sales; kills 11pm lowball refereeing | Phase 2 |
| Seller shop upgrades | Stated return policy, vacation mode, combined-shipping discounts per seller | Turns the profile into a store — what keeps power sellers | Phase 2 |
| Payout-speed tiers | Trusted sellers (rating + history) paid at carrier scan instead of post-inspection — transaction process variant | Seller cash-flow loyalty lever; risk-priced by data we already have | Phase 2 |
| Road-hazard protection attach | Coverage add-on at checkout on used wheels + new tires — the automotive analog of Reverb's gear protection; likely rides an existing Only Tires program | Pure attach revenue on every order | Phase 2 |
| Sold-listing pages stay live | Sold PDPs remain indexable w/ "see similar" + guide link | SEO + price transparency compounding (Reverb does this) | Phase 2 |
Same code, two app stores.
The Exchange was built mobile-first on purpose — which means the app-store version is an extraction, not a rewrite. The same front end wraps into native iOS and Android binaries with Capacitor; everything you walked through today ships inside it.
| Question | Answer |
|---|---|
| How does the web app become an app? | Capacitor wraps the existing React front end in a native shell — one codebase, three targets (web, iOS, Android). 4–6 wks post-launch, sized on the Costs brief. |
| What gets better as a native app? | Camera: the sell flow's photo capture goes fully native. Push notifications (APNs/FCM): offers, messages, and outbid alerts land on the lock screen — the single biggest engagement lever a marketplace has. |
| Does Apple take 30%? | No. Wheels are physical goods — app-store rules require external payment processing for physical goods, so checkout runs through the same Stripe stack with no platform cut. |
| Store costs? | Apple Developer $99/yr · Google Play $25 one-time · review cycles ~1 wk each |
| When? | Fast-follow after web launch — the web app is already installable (add-to-home-screen) day one, so the store apps chase engagement, not capability. |

Wheels
Wheel + Tire Sets
Tires
Suspension
Performance
Aero + Body
Interior
Deals