Our Logo - Representing our brand's representation of simplicity for all.
Demonstration material showing a possible storefront where sellers list and buyers can purchase.
Our algorithm finds the best shipping route - making it easy to lower operation costs
Add to cart - and see exactly how much you are going to save!
Know exactly what's going on like prices, plans, and opportunities
See everything in our beautiful footer.

Coconut

Inspiration

Coconut started from a simple problem: being able to sell something online does not mean it is economically practical to ship it.

For small businesses on remote islands, that gap can be especially painful. An artisan might be able to sell a handmade basket, piece of jewelry, carving, or textile to someone across the world, but the logistics behind that transaction are still designed around each business acting independently. When order volume is small, fixed freight costs, local pickup, packaging, limited departure schedules, and final-mile delivery can make shipping disproportionately expensive.

We did not want to build another generic e-commerce marketplace with an AI chatbot added on top. We wanted the island constraint to fundamentally change how the marketplace works.

That led us to Coconut: a marketplace where independent island businesses still sell their own products, but the expensive logistics layer is coordinated across the entire island.

Our core idea became:

What if dozens of tiny island exporters could behave like one coordinated logistics network?

That idea influenced almost every part of the product, from recommendations to pricing to route optimization.

What it does

Coconut is a shipping-aware commerce and logistics platform for remote-island artisans.

Customers can browse products from independent sellers just like they would in a normal marketplace, but Coconut considers the physical logistics behind every purchase.

When someone adds a product to their cart, Coconut:

Determines how the items can be packed.
Finds an eligible shared shipment leaving the island.
Calculates the customer's share of the pooled freight cost.
Estimates final-mile delivery from the mainland gateway to the customer.
Compares the pooled cost with an estimated independent-shipping scenario.
Re-ranks other products based partly on how efficiently they can travel with the existing order.

That creates one of Coconut's most important features.

A customer might already have a handwoven basket in their cart and see:

Shell Earrings — $14 — +$0.00 additional shipping

Instead of recommending those earrings only because they are stylistically related, Coconut checks whether they can fit into the customer's existing parcel without pushing it into a more expensive shipping configuration.

A bulky ceramic item may add several dollars to shipping and therefore receive a lower logistics score.

This makes recommendations aware of the real-world cost of moving physical goods.

Dynamic pricing

We wanted the dynamic-pricing component to have a real economic reason behind it rather than arbitrarily changing product prices.

The price of the craft remains controlled by the artisan.

What changes dynamically is the shared logistics price.

For a simplified example, suppose an outbound shipment has a fixed freight cost (F). If an order contributes chargeable weight (w_i), and the entire batch contains total chargeable weight (W), Coconut can allocate part of the shared freight cost as:

[ C_i = \frac{w_i}{W}F ]

As more compatible orders join the batch, (W) increases. That can reduce the fixed-cost share assigned to each participating shipment.

So a customer might see something like:

Shared batch	Estimated shipping
30% utilized	$24.80
60% utilized	$20.10
84% utilized	$17.60

The numbers in our application come from the system's logistics calculations rather than a hardcoded percentage discount.

Coconut therefore creates dynamic logistics pricing based on consolidation economics.

Recommendation engine

Our recommendation engine combines customer relevance with logistics efficiency.

A simplified version of our scoring model is:

[ R = 0.30P + 0.25S + 0.15B + 0.10M + 0.10T + 0.10F ]

where:

(P) = product relevance
(S) = shipping efficiency
(B) = shared-batch benefit
(M) = seller margin quality
(T) = production readiness
(F) = seller fairness

The shipping component is especially important.

For a candidate product (p):

[ \Delta S_p = Shipping(Cart + p) - Shipping(Cart) ]

If adding a product results in:

[ \Delta S_p = 0 ]

then Coconut knows the seller may be able to gain another sale without increasing the buyer's estimated shipping cost.

We also built the system to explain recommendations rather than displaying an unexplained "AI confidence" score.

A customer can see reasons such as:

Fits inside your current parcel
Adds no estimated shipping cost
Ready before the next shipment cutoff
Can join your existing shared departure
Matches products already in your cart

Shipping and packing

Packing turned out to be an important part of the recommendation problem.

Coconut stores physical information such as:

width
height
length
weight
fragility
stackability

The application evaluates carton sizes and tests item orientation when determining whether products can travel together.

That means a tiny pair of earrings may fit into an existing box with effectively no change to shipping, while a large ceramic piece might require a larger carton or an additional package.

This physical packing calculation feeds directly back into the recommendation engine.

That connection between e-commerce recommendations and actual package geometry became one of our favorite parts of the project.

Route optimization

Coconut also looks at what happens before the shipment ever leaves the island.

Orders may need to be collected from multiple artisans around the island and brought to a shared consolidation point before a departure cutoff.

We model this as a Capacitated Vehicle Routing Problem with Time Windows.

The optimizer considers factors including:

artisan pickup locations
road travel times
vehicle capacity
package weight
package volume
seller pickup windows
production readiness
shipment cutoff time

We use road-routing information to create a distance and duration matrix, then use optimization logic to determine a more efficient collection route.

The Operations view lets us compare a simple baseline route against the optimized result and show metrics such as:

distance before optimization
distance after optimization
distance saved
vehicle utilization
pickup sequence

This gave us a much more meaningful implementation of "shipping route optimization" than simply drawing the shortest line between two points.

Weather-aware departures

Remote-island logistics also depends on what happens after packages reach the port.

Coconut evaluates available outbound departures using factors such as:

estimated logistics cost
delivery speed
shipment utilization
marine conditions

We incorporate marine and weather information such as wave height, swell, and wind into a route-risk score.

Importantly, we do not assume there is one universal "safe" wave height. Vessel operating limits can differ, so Coconut evaluates forecast conditions relative to configurable vessel profiles.

This means the cheapest departure does not automatically win.

For example, Coconut may recommend a slightly more expensive Friday departure if the cheaper Saturday option has significantly worse marine conditions.

Artisan tools

Coconut is not only a buyer-facing marketplace.

The Artisan view helps sellers understand what is happening behind the marketplace.

It can surface:

orders that need to be prepared
upcoming shipment cutoffs
production priorities
current batch participation
optional pricing guidance
promising international markets

For market opportunity scoring, we can combine signals such as trade-category demand, shipping competitiveness, existing marketplace activity, digital access, and broader economic indicators.

The goal is not to tell an artisan exactly what their product is worth or where they must sell it.

Instead, Coconut gives small businesses access to logistics and market information that would normally be difficult for an individual seller to assemble.

How we built it

Our development process was unusually research-heavy.

We started by using ChatGPT to deeply research the challenge, the realities of remote-island logistics, possible public data sources, recommendation approaches, dynamic pricing strategies, packing algorithms, and route-optimization techniques.

Rather than immediately generating code, we first developed a detailed implementation plan describing:

the product architecture
core algorithms
data models
external data sources
failure modes
demo scenarios
serverless infrastructure
acceptance tests

That planning stage ended up being extremely valuable because it gave the entire team a shared technical target before implementation began.

We then used AI coding agents to turn that implementation plan into the first working version of the application. After the initial implementation, our team worked on top of it using several different coding assistants and models for debugging, refactoring, implementation, auditing, and optimization.

The AI tools were not treated as a replacement for the team. They were used more like very fast engineering collaborators: we gave them highly specific requirements, reviewed their output, tested the implementation, identified failures, and then iterated.

Meanwhile, team members worked in parallel on design, product decisions, technical validation, and presentation.

Architecture

We intentionally kept the cloud architecture serverless.

Our high-level architecture is:

Customer
   │
   ▼
Next.js Frontend
   │
   ▼
Appwrite Cloud
   │
   ├── TablesDB
   │
   ├── TypeScript API Function
   │
   └── Python Optimization Function
   │            │
   │            ▼
   │         OR-Tools
   │
   └── External data providers
          ├── road routing
          ├── marine/weather
          ├── shipping rates
          ├── currency
          ├── trade data
          └── economic indicators