Designing the client storefront, the moderator console, and the seller portal of a multi-category marketplace — turning three disconnected specs into one coherent system.
UmedMall is a multi-category marketplace built for the Tajik market, benchmarked by the client against OZON, Wildberries, Yandex.Market and Etsy. By the time I joined, a client-side spec already existed. The moderator spec arrived next. The seller/partner spec didn't exist at all — "we'll send it later."
My job was to make sure none of the three surfaces contradicted each other: one taxonomy, one attribute model, one source of truth — expressed through three different interfaces, for three different people, with three different jobs to do.
I designed all three: the client storefront, the moderator console, and the seller portal — research, information architecture, content modeling, UI, and Figma handoff.
The client's three specs were written sequentially, by different people, with no shared vocabulary. The client-facing catalog and the moderator's "Characteristics" page used different words for the same idea. The seller portal wasn't specified at all when I started designing the moderator side.
Three things were true at once:
This is the entire moderator navigation as originally specified — six flat categories, no grouping, no hierarchy, no mention of units, input types, audit logs, cities, or brands. Sellers were expected to type product attributes as free text.
The original sidebar, as briefed:
"Заказы. Категории. Характеристики. Баннеры. Администраторы. Магазины."
— Orders. Categories. Characteristics. Banners. Administrators. Stores. The whole moderator product, in six words.
There was no budget or access for primary user research. So I grounded every decision in two things I could control: how mature marketplaces actually structure this problem, and how badly a naive schema would break under real-world data.
Walked through the moderator/admin patterns of OZON, Wildberries, Yandex.Market and Etsy — not for visuals, but for how they group catalog management, order processing, and seller onboarding. Reused validated structure instead of inventing one from a flat spec.
Read the client-side spec, the moderator spec, and (once it arrived) the seller spec against each other, line by line, looking for contradictions before they became dev tickets — e.g. a "verified store" badge the client side referenced that the moderator side never defined.
Before designing the attributes screen, I deliberately pushed it with hard cases: temperature in °C/°F/K, length in cm vs. m vs. inches, a washing machine's "8kg, white, automatic" typed as one free-text string. Each broke something — which told me what the schema actually needed to prevent.
Six flat top-level items copied from table names hide nineteen real sections. No single moderator should face that list ungrouped.
"Automatic, 8kg, white" typed as one string by one seller can never be filtered, compared, or sorted against the same attributes typed differently by another seller.
"Approved" and "store exists" must be the same fact, not two fields that can drift apart. The spec never said this — the data model demanded it.
The client storefront, the moderator console, and the seller portal each needed to trust the same taxonomy and the same product attributes — without giving sellers enough freedom to enter data that breaks filtering, comparison, or search downstream.
Solve that once, at the data-model level, and three very different interfaces become straightforward to design on top of it.
19 moderator sections collapse into 7 task-based groups, none with more than 4 top-level items.
Every product attribute is an enum, a number with a unit, or a boolean — never an open string a seller can type anything into.
Store and product rejections require a mandatory reason, visible to other moderators — no more "why was this declined?" pings.
None of the four decisions below were in the original spec. Each one came from asking "what happens when this breaks at scale" before it actually did.
Sellers don't get a free-text field for "color" or "capacity." A moderator first defines the characteristic (its input type, its unit, its validation rules) once, globally. Sellers then pick from that fixed vocabulary when listing a product. This single decision is what makes filtering and comparison possible across thousands of listings from hundreds of independent sellers.
Every unit category (length, mass, volume, power, temperature) stores a single base unit internally — Kelvin for temperature, millimeters for length — and converts on display. A seller can enter 25°C or 77°F; the system stores 298.15K either way. Without this, "filter fridges under 90 cm wide" silently fails for every seller who typed “0.9 m.”
I presented three real alternatives — 6 groups (maximally compact), 7 groups (balanced), and 9 groups (maximally explicit) — with the actual trade-off named out loud: fewer groups for a small moderation team wearing many hats, more groups if responsibilities split by role. The client picked 7, and recognized every group name because it reflected their own vocabulary back to them.
The original spec allowed a store application to be marked "Approved" as a status change, separately from actually creating the store record. I flagged that this produces an impossible state — an approved application with no store behind it — and changed the flow so approval is store creation. I also replaced "delete" with "archive" for applications, so rejected history is never lost.
One taxonomy and one attribute engine power the client storefront, the moderator console, and the seller portal — color-coded below as Client, Admin and Seller so it's clear which surface each screen belongs to.
Thirteen sections, each drawn twice — desktop and mobile, light and dark. Nothing here is decorative: every filter, every breadcrumb and every color swatch is the visible end of a decision made in the moderator console.

The client-side brief asked for two levels of nesting, maximum. The admin section of the same brief described three: category → subcategory → type. I followed the data, not the sentence — because a type belongs to exactly one subcategory, and breaking that link is what makes a seller's products vanish from the storefront entirely. So the catalog drills three levels deep, with breadcrumbs that never lose the path.


Under every price in the catalog sits a second line: 639 TJS × 6 months. Not on the product page, not at checkout — in the tile, before anything is clicked. In this market a large purchase is normally split into monthly payments, so a price without its installment is only half a price. At checkout the same logic continues: seven ways to pay, most of them local banks, and “pay after delivery” for people who want to see the box first.

One order can cross several stores, so the cart is grouped by seller, each with its own delivery cost. Two states matter more than the happy path: “the price has changed” marked on the item rather than silently applied, and “unavailable to order” pulled into its own block with a replace button instead of quietly disappearing. Checkout then runs address → payment → done, and the continue button stays disabled until the address is real.



Colors are named for what they mean, not what they are. modeSolid-red-0 resolves to solid-red-0 in the light theme and to solid-red-100 in the dark one — one semantic name, two substitutions. Switching themes repaints nothing by hand, and a new screen inherits both themes the moment it is drawn. None of this was in the brief.


An empty cart, a 404, a 500 — the three screens no brief ever mentions and every user eventually meets. I drew a mascot for them: a raccoon in a cardboard box, in eight variations, and error pages in four versions each (desktop and mobile, light and dark). The brief said nothing about any of it. A marketplace that only looks finished when it has products in it isn't finished.


All thirteen storefront sections were delivered as desktop and mobile pairs, in both themes. Not "responsive behavior described in a comment" — drawn, so engineering never had to invent a state that wasn't there.

An application is a store asking for a product that is not in the shared catalog yet. New, approved and rejected live at three separate addresses in the sidebar rather than behind a status filter on one list — a moderator spends the day inside “New”, and everything on that screen is waiting on them. The decision itself is never made from the list. Opening an application shows the product exactly as a shopper would meet it — gallery, the discounted price next to the old one, the wholesale price, the seller with their rating and badges, the attribute set, the description. At the bottom sits a notes field and three ready-made reasons — photo does not match, wrong category, attribute — so a rejection rarely leaves without an explanation, and the explanation does not have to be written from scratch every time.



“Attributes” is four registries, not one: characteristic groups, the characteristics themselves, units of measurement and input types. The last two are where the catalog is actually decided. Input types are a fixed list of nine, each reduced to a primitive — free text, letters only, letters with digits (for article numbers and models), integer, decimal, yes/no, pick one, pick several, date. A moderator creating a characteristic does not draw a field; they pick a type, and the seller's form is assembled from it. Units each carry a category and a formula back to a base: millimeter is x, centimetre x*10, metre x*1000, inch x*25.4, foot x*304.8. One seller types inches, another centimetres; both land in the same base, so a shopper's “under 15 cm” catches both. Neither registry was in the brief.



There was no brief for the seller portal when I started it — it was going to arrive later, and it never did in time. So the home screen was built from one question: what does a shop owner need to know in the five seconds after logging in? Four tiles, and every number comes as a pair — the running total and the current month underneath it. 342 orders, 58 of them this month. An average order value of 781 somoni overall, 698 this month: the tile shows the dip without a chart. The products tile is deliberately not a boast — under “128 products” sits “18 out of date”, so the first screen of the day names a debt rather than an achievement. The store's own on/off switch sits in the header, and four buttons below repeat the routes people actually take. The month on a tile and the month in Analytics are the same figures, so a seller is never shown two versions of the truth.


Everything above is machinery a seller only meets after signing up. This screen comes before all of it, and it has one job: turn somebody who came to UmedMall to buy something into somebody who sells here. So it promises exactly one thing and does not hedge it — you handle the products, the reach is on us.

Without users to test on, the real validation loop was showing the client two honest versions — what I thought was right, and what they'd actually written — and merging them in the open rather than picking a winner silently.
My version used a hierarchical tree with breadcrumb drill-down. The client's literal spec wanted a flat A–Z list for fast scanning. Shipped both: a flat list for moderators who need to scan everything, with breadcrumb-aware drill-down into subcategories and types underneath.
My version prioritized simplicity and reuse across banner types. The client's spec demanded specific fields per banner (name required, URL optional, uncompressed image upload). Final version kept their exact field list, with the simpler interaction model underneath it.
Rather than asserting "this is correct," I presented 6-group, 7-group and 9-group versions side by side with the trade-off named explicitly, and let the client choose with full context — not just a recommendation to accept or reject.
moderator sections, collapsed from 6 flat literal-spec items into 7 named, task-based groups — none deeper than one click.
free-text product attributes in the final schema — every value is an enum, a number with a unit, or a boolean.
interfaces — client, moderator, seller — sharing a single attribute and taxonomy engine instead of three independent data models.
A shopper can filter consistently no matter which of hundreds of sellers listed a product. A seller fills predictable, constrained forms instead of guessing what a moderator will accept. A moderator works from navigation that matches how they actually triage — not how a database happened to be named.
The marketplace is live at umedmall.tj — real stores, real listings, real orders — with the official launch still being prepared. Business metrics will be added when the client shares them; I'd rather show none than invent them.
The marketplace is live, and the complete Figma file — storefront, moderator console and seller portal on one taxonomy — is open to view.