Landing page with both the buyer and seller logins
The buyer mode, where the buyer can go through all the styles and pick their favourite piece of clothing that they want to give a new home.
Wishlist items, add to cart their picks change modes from dark to light and many more features.
Thriftit is more than a platform, its a movement toward conscious consumption. Every item reused is one less item wasted, this empowers them
Buyer profile with all the relevant information, and logout option.
Again back to the landing page to login as a seller just click on the become a seller and get started. This helps with no confusion.
Now the seller have to register and approve information like KYC , Aadhar and PAN. If previously registered then login with name and pass.
This is how you list a product.
Select it from your device and give it a price and fix all labels and then click on list the product.
The new product is now listed and is stored in the express api and is visible on the buyers window.
This is the seller dashboard, where they can track their selling record.
The new product that was listed, is now successfully in the market finding its new home.

ThriftIt — Project Story

Inspiration

The fashion industry discards billions of garments every year — not because they're worn out, but because the systems around reuse are too slow, too sketchy, and too inconvenient. ThriftIt started from a straightforward observation: the clothes exist, the demand exists, and what's missing is a marketplace that treats second-hand shopping as a first-class experience.

I wanted to close that gap. Not by preaching sustainability, but by removing the friction that makes people default to buying new. The core hypothesis is simple:

$$ \text{Sustainable Impact} \propto \text{Ease of Reuse} \times \text{User Trust} $$

If you make reuse fast and trustworthy, people choose it. That's the product bet ThriftIt is built on.

How I Built It

ThriftIt is a full-stack web app supporting both a buyer and a seller experience — two distinct user journeys sharing one coherent platform.

Frontend: React, React Router, Redux Toolkit, Tailwind-based UI, Framer Motion
Backend: Node.js + Express APIs
Database: SQLite for product and user data
State + UX: Cart, wishlist, auth/session flows, guarded seller routes
Platform features: Product listings, product details, orders, profile/settings, seller dashboard

Beyond core features, I invested in production readiness — because a sustainable marketplace only works if people can actually find and use it:

Route-based code splitting (React.lazy + Suspense) to keep initial bundle size lean
Lazy-loaded product media to reduce above-the-fold load weight
Open Graph, Twitter cards, and structured data for SEO and link shareability
Route-aware title and description logic to make every page indexable in a SPA context

What I Learned

The biggest shift in my thinking was realising that product quality is not a single axis. Features get you to functional. Performance, discoverability, and clarity are what get you to good.

Architecture pays forward. Clear route boundaries and reusable components early on meant I could move fast later without untangling a mess. The discipline upfront was worth it.
SEO is a product decision, not an afterthought. In a SPA, if you don't explicitly manage metadata per route, your pages are effectively invisible. Treating it as a feature changed how I approached every new route.
Performance is additive. There is no single fix — it is a series of small decisions that compound. Load time breaks down as:

$$ T_{\text{load}} = T_{\text{network}} + T_{\text{parse}} + T_{\text{render}} $$

Shaving time from each term separately is what produces a noticeably faster experience.

Visibility drives behaviour. Sustainability features only change habits if users can see the impact. Embedding that into the product flow — rather than burying it in an "About" page — is what makes it real.

Challenges I Faced

Balancing visual richness with speed — Motion and video-heavy sections elevated the brand feel, but came with real load cost. The solution wasn't to strip the design back, but to be surgical: lazy-load what's below the fold, compress aggressively above it, and let Framer Motion handle animation weight rather than raw video where possible.
Managing multi-role flows cleanly — Buyer and seller journeys share an app but need strict separation: guarded routes, distinct session intents, and navigation states that don't bleed into each other. Getting this right required treating roles as a first-class architectural concern, not a conditional flag bolted on later.
Keeping shared state predictable — Cart, wishlist, products, and auth running in parallel is where Redux can get messy fast. Structuring slices with deliberate boundaries — each owning its own shape and actions — was what kept things from unravelling as features grew.
SEO in a single-page app — SPAs don't get metadata for free. Every route needs its own title, description, and structured data to be discoverable. Building route-aware metadata logic from the ground up was the right call, and it's now a pattern I'll carry into every future project.

Final Reflection

ThriftIt grew from a sustainability idea into a full product engineering problem — one where UX, architecture, performance, SEO, and business logic all had to work together, not in isolation. The version I built here is a foundation: the multi-role marketplace, the optimised delivery layer, and the discoverability infrastructure are all in place. What comes next is scale — more sellers, richer search, and impact metrics surfaced directly in the product so users can see the environmental difference their purchases make. The core conviction hasn't changed: make reuse easier than buying new, and people will choose it.