Seldom
A storefront for things that only exist once.
Seldom is a storefront for one-of-a-kind objects. Sellers publish new drops through Notion, and each item gets its own full-screen presentation, photo carousel, price, and direct path to checkout. When something sells, it stays on the page, marked as sold rather than disappearing.
I designed, built, and deployed Seldom solo in about a month using Claude Code. It accepts payments through Stripe and supports order fulfillment from checkout through shipping.
Role: Product design, engineering, architecture, deployment
Build time: About one month
Status: Live, ready for seller testing
Stack: Next.js, React, TypeScript, Notion, Stripe, Resend, Vercel Blob
Live link: SELDOM
The product decision: less control, less work
Most storefront builders give sellers plenty of flexibility. Themes, layouts, blocks, and customization options let people make a site their own, but they also create work before the actual selling begins.
Seldom takes the opposite approach. The storefront has one visual language and one publishing workflow. Sellers add photos, a price, and a short description to a Notion table. The site handles the rest.
The idea is to make publishing feel like adding an item to a list, not building a website.
The architecture follows the same idea
I used Notion as the database rather than building a separate backend for inventory management. Listings live in a Notion database, and the application reads them through the API. Order and fulfillment details are written back to the same place.
This keeps the system small and gives sellers a familiar way to manage their inventory. It also avoids creating and maintaining a custom admin interface.
The tradeoff is that Notion wasn't designed to be a transactional commerce database. API rate limits, the lack of transactions, and dependencies on property names introduce constraints that a dedicated database wouldn't have in the same way.
For an initial product with a small catalog, I chose to accept those limitations rather than build infrastructure before I had evidence that it was needed. The boundary is clear: if the catalog or seller base grows, I'd revisit the data layer.
One issue emerged from the interaction between caching and publishing. The storefront uses a 60-second cache, while publishing a drop also triggers an email announcement. That means the launch flow can generate extra API requests when the cache is cold, just as a new item goes live. It's a useful reminder that individual features can work correctly while their combination creates a problem.
Designing for the failure that matters
Every Seldom item exists exactly once. That makes duplicate purchases one of the most important failure cases to handle.
When a buyer starts checkout, the application places a temporary reservation on the item. But reservations can expire while payments are processing, so two buyers could still complete payment for the same object.
I built the order flow to handle that possibility. If both payments succeed, the system keeps one order and automatically refunds the other. Both the buyer and I receive an email explaining what happened.
I tested this scenario rather than relying on the normal checkout path. The goal wasn't simply to make payment work. It was to make sure the system had a reasonable outcome when something went wrong.
Building with AI
I used Claude Code throughout the build, but started with planning rather than implementation.
Two commits were dedicated to an implementation plan and a structured review across product, design, engineering, and developer experience. I worked through the system's responsibilities and decisions before moving into the implementation, which brought together the storefront, Notion integration, Stripe, authentication, email, and file uploads.
My takeaway is that AI-assisted development changes where the effort goes. Generating code is only part of the work. Defining the right behavior, making architectural tradeoffs, and checking what happens at the boundaries still require deliberate decisions.
I kept the focus on validating the parts where mistakes matter most: payment handling, reservations, webhooks, and order recovery.
What I tested before shipping
I focused testing on the paths that could cost someone money or leave an order in an inconsistent state.
I checked webhook signature validation and replay handling, tested competing checkouts, verified automatic refunds, interrupted the Notion connection during an order, and let reservations expire to confirm that inventory didn't remain locked.
That process exposed a gap in the order handler. I fixed it and added tests around the affected behavior.
The test coverage reflects the priorities of this version. Payment processing, reservations, and order handling have tests; the presentation layer has less coverage.
What's next
Seldom is deployed and operational, but I haven't onboarded sellers yet. The next step is to work with five sellers and observe how they publish and manage their first drops.
There are three assumptions I want to validate:
Does a constrained publishing workflow feel simpler, or does it feel limiting?
Can one announcement per drop bring enough people to the storefront without follow-up emails?
How much effort does it actually take to go from signup to a published item?
I'd start by measuring time to first published drop and observing where sellers hesitate or need help. That would tell me whether the central product idea works in practice, not just whether the software works as designed.