The Main page where items are being scanned
Answer appears on screen with what to do with that item
A dashboard with how many items got scanned on that day

About the Project

Inspiration

Most donation workflows focus on donors, store shelves, or reporting dashboards. But one of the most important decisions happens much earlier, at the intake table.

That is the moment when a staff member has to quickly decide what should be reused, what can be resold, what should be recycled, and what needs a second look. It is a fast, repetitive, high-pressure task, and small mistakes at that stage can create much bigger downstream problems. A usable item may never reach someone who needs it. A low-value item may take up resale space. A questionable item may need more review than it gets.

We built SortSense because that frontline decision felt both critical and underserved. We wanted to create something that helps the people doing the sorting, not just the people looking at reports later. The idea was to make that moment faster, clearer, and more consistent through a simple scan-and-route experience.

What It Does

SortSense is an AI-assisted donation triage tool for intake staff.

When a user scans an item, SortSense helps route it into one of four outcomes:

Reuse
Resale
Recycle
Flag for human review

The current prototype supports food, clothing, and electronics. Instead of showing a complicated technical output, it gives the user a clean, immediate answer with a simple explanation. The goal is not to overwhelm staff with data. The goal is to help them act quickly and confidently.

We also built an operations dashboard so managers can see what is happening in real time, including item counts, category mix, and review rates.

How We Built It

We built SortSense as a working end-to-end prototype with three main parts:

A sorter-facing interface where staff can scan an item and receive a routing result.
An operations dashboard that gives visibility into live triage activity.
A backend decision pipeline that processes the item and returns a category-specific recommendation.

At a high level, the flow works like this:

A user scans an item through the sorter interface.
The system identifies whether it is food, clothing, or electronics.
It applies category-specific checks to generate a routing decision.
It returns a clear recommendation and logs the result for tracking and export.

The experience was designed around simplicity. Even though the backend uses multiple signals and real-time processing, the front-end interaction stays fast and straightforward. That was an important product choice for us because this kind of tool has to work in a practical, high-throughput environment.

Challenges We Faced

One of the biggest challenges was building something that felt useful without overpromising.

In projects like this, it is easy to make the system sound highly intelligent, but the real challenge is trust. We did not want SortSense to make confident recommendations when the situation was unclear. That is why one of the most important parts of the project is the flag for human review path. If the system is uncertain, it does not pretend otherwise.

Another challenge was designing a single product experience for very different kinds of items. Food, clothing, and electronics each come with different risks, different signals, and different expectations. We had to make the underlying logic flexible enough for each category while keeping the user experience consistent.

We also had to strike a balance between speed and clarity. The tool needed to feel immediate for frontline staff, while still producing output that would be meaningful for operations and reporting.

What We Learned

We learned that some of the most impactful problems are not always the most visible ones.

The sorting decision at intake may seem small, but it shapes everything that happens next. That made us think much more carefully about designing for real workflows instead of abstract technical demos.

We also learned that user trust comes from restraint. A product becomes more credible when it knows when to escalate, not just when to predict.

Most importantly, we learned that a compelling hackathon project does not need to be flashy for the sake of being flashy. What makes SortSense interesting is that it focuses on a specific, overlooked operational pain point and turns it into a simple, memorable product experience.

Why It Matters

SortSense is about improving the quality of a decision that happens over and over again, often under pressure, and with real consequences.

When that decision becomes faster and more consistent:

staff can work more efficiently
reusable items are less likely to be missed
recycling becomes more intentional
uncertain cases are handled more responsibly

That is what makes SortSense meaningful to us. It is not just about classifying objects. It is about helping donation systems work better at the exact point where value is either preserved or lost.