Case Study - Fintech / Marketplace TrustCardSell
A gift-card exchange where people turned unwanted cards into cash. I rebuilt the transaction platform and crushed a runaway fraud problem by redesigning where and when the system collected signal.
Turn your gift cards into cash
CardSell, also known as CardSwapper, let users convert unwanted gift cards into real money through a mobile and web flow. Enter a card number and PIN, verify the card with supported retailers, receive an offer, accept it, and move the payout to PayPal.
The customer promise was simple: a fast, easy, secure gift-card exchange. Underneath it was a high-liquidity payout workflow, which made it exactly the kind of surface fraudsters look for.
Fraud was not a detection problem. It was a transaction-design problem.
The product had two needs pulling in opposite directions: make selling a card feel fast for legitimate users, and stop bad actors from exploiting a payout workflow built for speed. At the time, 30-40% of transactions were fraudulent.
The first instinct in a situation like that is to buy or build a better fraud model. The better diagnosis was that the flow itself was inviting abuse: the wrong signals were collected at the wrong moments, and friction was landing on real users instead of fraudsters.
The fix was better signal collection at the right moment in the flow, combined with friction that cost fraudsters more than it cost legitimate sellers.
The first two weeks were system mapping
Before changing the product, I mapped the transaction system end to end: where fraudulent users entered, what data was collected before an offer, which fraud signals existed but were ignored, and where third-party card verification, payout limits, and account state needed to interact.
Entry points
Where suspicious sellers entered, returned, duplicated cards, or moved around account state.
Signal timing
Which data had to be captured before the system made an offer or moved money.
Legit friction
Which checkpoints slowed real sellers without materially increasing fraud cost.
Ops feedback
Which support, Slack, email, and admin signals exposed rejected, paid, and fraud states.
The offer flow became the control point
The offer pipeline became the place where product, risk, third-party verification, and payout logic met. Instead of treating fraud as a separate cleanup step, the transaction itself became the system of control.
Collect card metadata, seller state, promo code, user agent, and quote context.
Validate supported product lines and card value before committing to payout.
Combine account, card, payout, and duplicate-card signals while risk is still controllable.
Let legitimate users move quickly while routing suspicious transactions into rejection or review.
Execute the card sale only after the right verification and risk gates passed.
Move into pending, paid, rejected, or fraud states with ops visibility.
Risk controls without making the product hostile
The rebuild added practical controls where they mattered: payout limits per transaction, daily and weekly totals, duplicate-card detection, user verification, fraud-check states, user-agent capture, third-party card validation, and clearer account authorization.
The product still explained itself in three plain steps. The complexity stayed under the floorboards, where it belonged.
Product flow
Better checkpoints across card submission, offer creation, acceptance, and payout.
Risk logic
Payout limits, duplicate-card detection, fraud states, and third-party validation.
Ops integration
Support/admin visibility around accepted, rejected, paid, pending, and fraud states.
Near-zero fraud. 4x transaction volume.
The platform was rebuilt around a safer transaction flow. Fraud dropped from 30-40% to near zero, and transaction volume grew 4x.
The important lesson was that marketplace trust is not just a model or an operations queue. It is product architecture: what you ask for, when you ask for it, what you do with the answer, and how much damage can happen before the system knows enough to stop.
What this demonstrates
Marketplace trust
Redesigned a high-risk transaction workflow without killing legitimate conversion.
Technical product depth
Worked across Node/Express backend, Next.js surfaces, card verification, auth, notifications, and payout state.
Systems diagnosis
Mapped the real fraud system before forcing a solution onto the product.
Outcome ownership
Tied product flow, risk controls, and support operations to measurable business results.