I used to spend way too much time taking care of my sneakers.

At the time, I was really into sneakers, and cleaning them properly was part of the hobby. But whenever I did not want to do it myself, there was no simple way to find someone I could trust with a pair.

So I started imagining the service I wanted to use myself.

CleanShoes was my attempt at building an on-demand marketplace for sneaker cleaning — connecting people who needed their shoes cleaned with people willing to do it for them.

Basically, Uber for sneaker care.

CleanShoes was a personal project, so I worked across the entire product.

• Product concept and positioning
• User flows
• UX and interface design
• iOS development
• Backend development
• Database design
• API integration
• Cloud deployment
• Beta distribution and testing

It was one of the first projects where I was not just implementing something.

I had an idea, turned it into a product, designed the experience, built the infrastructure behind it, and tried to put it in people’s hands.

The starting point was simple: how can requesting a sneaker cleaning service feel as easy as ordering any other service from your phone?

I designed the experience around that idea and deliberately kept the product focused.

Because it was an iOS-first experience, I built the application natively with SwiftUI, using UIKit where I needed more control.

Behind it, I built a NestJS API connected to PostgreSQL through Prisma and deployed the backend on AWS.

Once the app was stable enough to leave my own device, I distributed beta builds through TestFlight.

That was supposed to be the moment where building turned into learning from users.

It did not really happen.

And that ended up being the most useful part of the project.

The product itself was only one half of the problem.

CleanShoes was a two-sided service marketplace. One side needed people looking for sneaker-cleaning services. The other needed people willing to provide them.

Without enough activity on both sides, the experience broke down.

You could build a great interface, a solid backend, and a functioning application — but none of that created the density the marketplace needed to become useful.

That was something I understood intellectually when I started.

I did not understand how important it was until I tried to launch it.

I had spent most of my energy on the product.

Very little of it had gone into distribution.

CleanShoes never reached the level of adoption I was hoping for.

The problem was not that I could not build the application.

The problem was that I had treated building the product as the hardest part.

For a marketplace, it wasn’t.

I needed to create enough initial demand, attract service providers, build trust, and concentrate activity until the product became useful on its own.

At the time, I had almost no experience with marketing or user acquisition, and I did not have a real strategy for getting there.

So the application existed.

The marketplace did not.

A working product is not the same thing as a working business.

This was probably the biggest lesson.

I had spent months thinking about how the product should work technically and visually. I had spent much less time asking how the first users would actually arrive.

Today, I would treat distribution as part of the product from day one.

Some products need momentum before they can provide value.

A standalone tool can sometimes be useful to its very first user.

A marketplace is different.

If there is no relevant supply when someone arrives — or no demand when a provider joins — neither side has much reason to stay.

I learned that the activation problem has to be designed just as deliberately as the application itself.

Shipping still mattered.

CleanShoes did not become the business I imagined.

But it was one of the projects that pushed me from simply writing software toward thinking about entire products.

I had to make decisions about experience, technology, infrastructure, users, and eventually distribution.

The outcome was not what I wanted.

The lessons stayed.

iOS

SwiftUISwiftUIKit

Backend

Node.jsNestJSREST APIsFirebase

Data

PostgreSQLPrisma

Infrastructure

AWSEC2

Beta & Delivery

TestFlightXcodeGit

Product & Design

FigmaNotion