This is not a success story. It is the beginning of a project.
I’m starting to build a B2B2C marketplace from scratch. The long-term goal is to open-source the core project and provide related technical and business services around it.
The code is not open source yet. The project is still in its early startup and development stage. So instead of pretending that everything is already finished, I decided to document the process as I build it.
Why Build a B2B2C Marketplace?
Traditional e-commerce usually follows a relatively simple model:
Platform → Inventory → Customer → Delivery
But local commerce can work differently.
Instead of the platform buying inventory and shipping everything itself, local merchants can publish their products, manage inventory, receive orders and fulfill them locally.
The platform focuses on connecting the two sides:
Consumers looking for products
Local merchants who have products and fulfillment capabilities
The platform that provides search, matching, transactions and infrastructure
This creates a different architecture from a traditional single-store e-commerce system.
The Basic Business Model
The core idea is relatively simple:
Customers discover products → compare stores → place orders → local merchants fulfill → customers receive their orders.
The platform does not necessarily need to own the inventory. Instead, it provides the infrastructure that connects consumers and merchants.
This means the system needs to understand more than just products. It also needs to understand:
Products
Stores
Offers and prices
Inventory
Distance
Delivery options
Orders
Payments
After-sales service
Four Different Ends
One of the first architectural decisions is that this is not simply one website with different user permissions.
I’m planning the platform around four major ends.
- Consumer The consumer side is where customers discover and purchase products.
Search products
Compare prices
Find nearby stores
Check availability
View delivery options
Add products to cart
Checkout and pay
Track orders
Request after-sales support
The goal is not simply to build another product catalog. The consumer should be able to answer one practical question:
Where can I buy the right product, at the right price, from a suitable store, and receive it efficiently?
- Merchant The merchant side is designed for local stores.
Store management
Product publishing
Inventory management
Price management
Order processing
Delivery management
Customer communication
Sales and performance data
The merchant should be able to use the platform as a digital sales and operations tool, rather than simply being another seller account inside an e-commerce website.
- Admin The admin side is responsible for operating the marketplace itself.
User management
Merchant management
Product and category management
Order management
Payment and refund management
Promotion management
Content management
Platform analytics
Risk and compliance operations
- Supply / Partner The fourth side is designed for suppliers, brands and other business partners.
This part is still being defined, but the long-term direction may include:
Wholesale supply
Product sourcing
Brand cooperation
Distribution
Merchant supply services
Technology and business services
The purpose is to make the platform more than a consumer-facing marketplace.
The Transaction Flow
One of the first flows I am working around looks like this:
Browse / Search → Product → Store / Offer → Cart → Verification → Checkout → Payment → Order → Delivery → After-sales
Every step creates its own technical requirements.
For example, a product cannot simply have one global price. The actual purchase decision may depend on the combination of:
Product
Store
Current offer
Inventory availability
Customer location
Delivery method
Estimated delivery time
This is one of the reasons I’m treating the marketplace as a platform architecture rather than a traditional online store.
AI Search: More Than a Search Box
Another direction I want to explore is AI-powered search.
Traditional search answers:
“Which products match this keyword?”
AI search should eventually answer a more useful question:
“Based on what I need, which product and which store should I consider?”
The system could potentially understand factors such as:
Product requirements
Budget
Distance
Availability
Delivery time
Store rating
Price
Customer scenario
The objective is not to replace the customer’s decision. It is to reduce the amount of work required to make that decision.
AI Customer Service
Customer service is another area where I want to experiment with AI.
Instead of sending every question to one general chatbot, different problems can be routed to different AI service agents.
Order support
Delivery support
Refund support
Product support
Account support
Merchant support
If an issue cannot be resolved automatically, the conversation can eventually be transferred to a human operator.
The idea is to make customer service part of the platform architecture, rather than adding an AI chatbot as an isolated feature.
Architecture: Start Simple, Scale Later
I don't want to start by building dozens of microservices.
At the beginning, the priority is to validate the business model and complete a real transaction.
The initial architecture will therefore focus on a modular structure, with clear boundaries between business domains.
The basic direction is:
Backend API
Consumer frontend
Merchant frontend
Admin platform
Supply / partner platform
MySQL
Redis
Queue / asynchronous processing
Object storage
AI services
If the business eventually reaches a scale that requires service separation, individual modules can be extracted later.
The architecture should evolve with the business, not become the business itself.
Why Open Source?
The long-term goal is to open-source the core project.
But I don't want to open-source an empty repository just for the sake of putting a GitHub badge on a landing page.
I want to first build something that actually works:
A working marketplace
A real merchant workflow
A real consumer workflow
A real order lifecycle
A working administration system
Real-world feedback
Then the code, architecture decisions and lessons learned can become much more useful to other developers.
What I Am Building Right Now
At this stage, the project is still in the starting phase.
There is no claim that the platform is finished. There is no claim that the architecture is perfect. And the project is not officially open source yet.
Right now, I am focusing on:
Defining the business model
Designing the four platform ends
Defining the core data model
Designing the transaction flow
Building the MVP
Testing the merchant workflow
Testing the consumer workflow
Preparing the foundation for future open source
The First Goal Is Simple
The first milestone is not millions of users.
It is not hundreds of merchants.
It is not even the open-source release.
The first milestone is:
Complete one real transaction.
One customer. One merchant. One product. One payment. One fulfillment. One completed order.
If that workflow works, we have something real to improve.
The 90-Day Direction
My initial development roadmap is roughly divided into four stages:
Validate — Research, business model and technical planning.
Build MVP — Core marketplace functions and the four ends.
Launch Trading — Products, merchants, payments, orders and delivery.
Improve & Scale — SEO, supply, AI features and additional marketplace capabilities.
The exact roadmap will probably change. That is part of the reason for documenting the process publicly.
This Is a Development Log
I want this series to record the project as it actually develops.
That means future posts may include:
Architecture decisions
Database design
API design
Frontend development
Merchant onboarding
Marketplace search
AI integration
Deployment
Problems and failures
Lessons learned
Eventually, the open-source release
I don't know exactly what the final product will look like yet. And that's okay.
The interesting part is seeing how an idea gradually becomes a real product.
What's Next?
The next step is to move from architecture diagrams and business ideas into actual implementation.
The focus will be on building the core marketplace, getting the four ends connected, and eventually putting the first real order through the system.
After that, I can start making the project more public, documenting the codebase and preparing the open-source version.
Open source is the goal.
But first, let's build something real.
This is Day 0.
More to come.
Top comments (0)