Rewear

The problem

Fashion commerce in Nigeria already existed.

It just didn’t really happen on marketplaces.

A lot of sellers built their businesses around Instagram and WhatsApp. Products were discovered through posts and Stories, questions happened in DMs, payments happened separately, and delivery was arranged afterwards.

It worked.

But it was fragmented.

For buyers, discovering something they actually wanted often meant following the right accounts, scrolling through feeds, remembering a seller, and eventually moving into a DM.

For sellers, visibility was tied to followers and social algorithms. There was no reliable way to put their inventory in front of people who were actively looking for something new.

I thought there was an opportunity to bring those two sides together.

Not another place to list products. A better way to discover them.

Starting with discovery

Most marketplaces start with search.

Rewear started with browsing.

I wanted the first experience to feel closer to Pinterest or Instagram than a traditional marketplace. You could open the app without knowing exactly what you wanted and still find something worth buying.

The product became built around a simple loop:

That changed how I thought about the marketplace.

The feed wasn’t just a way of displaying inventory.

The feed was the product.

Building both sides

A marketplace has an uncomfortable problem.

You need buyers to attract sellers.

You need sellers to attract buyers.

So I had to think about two products at the same time.

For buyers, that meant making products easy to discover, compare and purchase.

For sellers, it meant making it easy to get their inventory onto Rewear and giving them another source of visibility beyond their existing social following.

The product eventually grew around three ideas:

• Discovery for buyers.
• Visibility for sellers.
• Infrastructure underneath the transaction.

Making sellers easier to onboard

One of the first problems I ran into was obvious in hindsight.

Sellers already had inventory.

They just didn’t have it on Rewear.

Asking someone with dozens or hundreds of Instagram posts to manually recreate everything on another platform was too much friction.

So instead of asking sellers to change their workflow, I built around the workflow they already had.

Instagram Import

Rewear could scan a seller’s Instagram content, identify potential products and allow the seller to quickly review and import them.

The workflow became:

I also built around the possibility of automatically checking for new posts, so sellers could keep their Rewear catalogue up to date without repeatedly uploading everything themselves.

The idea was simple:

The easiest way to get inventory onto Rewear was to start with the inventory sellers already had.

AI where it actually helps

I didn’t want to add AI simply because it was an AI product.

The useful question was:

What work can I remove?

Listing a product involves a surprising amount of repetitive work — descriptions, categories, attributes and other information that sellers have to enter before an item can go live.

So I used AI to help turn images and existing product information into structured listings.

The goal wasn’t to replace the seller.

It was to get them from “I have this item” to “this item is ready to sell” much faster.

Search beyond keywords

Search became another area where the traditional marketplace model felt limiting.

A buyer doesn’t always know what to search for.

Sometimes they know what something looks like.

That led me toward visual search and multimodal product understanding.

Instead of requiring a buyer to describe a product perfectly, the system could use an image as the starting point and find visually similar products.

It was another way of making discovery less dependent on knowing exactly what you’re looking for.

From discovery to transaction

Getting someone to find a product is only half the problem.

Rewear also needed to handle everything that happens after someone decides to buy.

I built the transaction infrastructure around:

Payments were integrated through Paystack.

Orders had to account for different states rather than treating a successful payment as the end of the process.

Seller balances and withdrawals had to remain consistent with transactions.

Delivery had to be connected to the order itself.

And buyer protection had to be considered throughout the process.

What looks like one button in the interface becomes a surprisingly complicated system underneath.

Logistics is part of the product

Fashion doesn’t exist inside an app.

Eventually, someone’s clothes have to move from one person to another.

That meant integrating logistics into the commerce experience rather than treating delivery as something that happens outside Rewear.

Delivery fees, fulfilment, order status and confirmation all became part of the system.

This was one of the things that changed my understanding of marketplace products.

The product doesn’t end at checkout.

Building the technology

Rewear is built around a Flutter mobile application and a backend written in Go.

The system uses PostgreSQL as its core database, with Supabase, OpenSearch, Cloudflare R2 and other infrastructure supporting different parts of the platform.

The stack evolved with the product.

I used search infrastructure for increasingly sophisticated product discovery, object storage for the large amount of media a fashion marketplace requires, and AI services for product understanding and listing workflows.

The important part wasn’t choosing the most impressive technology.

It was choosing technology that allowed me to move quickly while still building toward a system that could support a real marketplace.

The part that was harder than the code

The hardest part of Rewear wasn’t building the app.

It was getting the marketplace to work.

A technically good product can still fail if there isn’t enough inventory.

A seller won’t stay if there are no buyers.

A buyer won’t stay if there aren’t enough interesting products.

That creates a loop:

Breaking that loop became one of the biggest challenges of building Rewear.

What the numbers taught me

At different points, we tracked users, active sellers, listings, transactions, growth and revenue.

But I learned quickly that user count wasn’t enough.

A marketplace with hundreds of users can still feel empty.

What mattered was liquidity.

• Were sellers active?
• Was there enough inventory?
• Were buyers discovering products?
• Were those discoveries turning into transactions?

That changed how I evaluated growth.

Instead of asking only: how many users do we have?

I started asking: is the marketplace becoming more useful?

What didn’t work

Rewear also taught me that building more doesn’t necessarily mean solving more.

When growth is slow, the instinct as an engineer is often to build.

• Another feature.
• Another improvement.
• Another integration.

But sometimes the bottleneck isn’t the product.

• It’s distribution.
• Or inventory.
• Or user behaviour.
• Or simply the fact that the marketplace hasn’t reached enough density yet.

That was an important shift for me.

Not every problem is an engineering problem.

Rewear changed as I built it

Rewear started as a fashion resale marketplace.

The more I worked on it, the more I became interested in the problem underneath it.

The real opportunity wasn’t simply helping people sell clothes.

It was connecting discovery with commerce.

Social platforms are extremely good at discovery.

Traditional marketplaces are good at transactions.

Rewear sits between the two.

That led me to think of the product less as a fashion marketplace and more as infrastructure for social commerce.

What I learned

Rewear was the first project where I had to think about almost every part of a company at once.

• Product.
• Engineering.
• Design.
• Growth.
• Payments.
• Operations.
• Users.
• Sellers.
• Fundraising.

And the uncomfortable gap between what I thought people would do and what they actually did.

I learned that a good product isn’t defined by how many features it has.

It’s defined by whether it makes something meaningfully easier.

I learned that engineering decisions eventually become user experiences.

• A failed webhook becomes a missing order.
• A storage problem becomes a broken image.
• A logistics failure becomes an unhappy customer.

And I learned that building a marketplace is as much about creating the conditions for people to interact as it is about writing the software that enables those interactions.

Looking back

Rewear is still the project that best represents how I like to work.

I started with a problem I could see around me, built the first version myself, put it in front of real users, and kept changing the product as I learned more.

• Some ideas worked.
• Some didn’t.
• Some technical problems took days to solve.
• Some product assumptions took months to disprove.

But each iteration made the underlying problem clearer.

What started as a fashion marketplace became an exploration of something much bigger:

How do you turn discovery into commerce?

That’s the problem I’m still interested in solving.