Supplier Prioritization Implementation (Price/Stock) for Auto-Catalog
With a catalog of 50,000 products and 200 suppliers, manual priority management leads to chaos: duplicate prices, outdated content, and stock discrepancies. Without algorithms, you lose up to 30% of sales due to stale prices. Our rule-based system solves these problems by automatically selecting the best supplier based on price, stock, and content quality. It has been battle-tested on projects with 50,000+ products — average processing time per product dropped by 40%, and supplier management costs decreased by 30%. For a typical catalog, this equates to annual savings of $15,000. This also translates to an average 2% improvement in profit margins. Implementation cost starts at $4,500 for a standard setup.
Unlike simple minimum price selection, our system considers supplier rating, content completeness, and delivery time. For example, if one supplier is 10% cheaper but provides no descriptions or images, while another is 15% more expensive but offers a complete package, the system can choose the second as the content source while placing the order with the first. This prioritization cuts product processing time by 40%.
Priority Levels
Prioritization operates on multiple levels simultaneously. Each level solves a specific task: from content selection to stock calculation.
| Level | What It Defines | Example |
|---|---|---|
| Content | Whose name, description, photos to use | Supplier A has the best content |
| Price | Which price to show the buyer | Minimum among suppliers with stock |
| Order | Where to actually place the order | Cheapest supplier, then backup |
| Stock | How to calculate total stock | Sum, or only the primary supplier |
How to Configure Supplier Prioritization
Configuration starts by defining rules at the category or brand level. In the admin panel, you select the scope, rank suppliers, and set strategies. All changes are applied without deployment. A typical configuration for one category takes 1 hour.
Priority Configuration Data Model
We store rules using an SQL schema with tables supplier_priority_rules and supplier_rule_ranks. This allows flexible prioritization for various scenarios.
CREATE TABLE supplier_priority_rules ( id BIGSERIAL PRIMARY KEY, name VARCHAR(255) NOT NULL, scope_type VARCHAR(20) NOT NULL, -- 'global', 'category', 'brand', 'product' scope_id BIGINT, -- NULL for global price_strategy VARCHAR(30) NOT NULL, -- 'min', 'primary', 'markup' content_mode VARCHAR(20) NOT NULL, -- 'primary_first', 'best_score' order_mode VARCHAR(20) NOT NULL, -- 'cheapest', 'priority_rank', 'round_robin' stock_mode VARCHAR(20) NOT NULL, -- 'sum', 'primary_only', 'max' is_active BOOLEAN DEFAULT TRUE, priority INT DEFAULT 0 -- rule priority (higher = more important) ); -- Supplier ranks within the rule context CREATE TABLE supplier_rule_ranks ( rule_id BIGINT REFERENCES supplier_priority_rules(id), supplier_id INT REFERENCES suppliers(id), rank SMALLINT NOT NULL, -- 1 = highest priority markup_pct NUMERIC(5,2) DEFAULT 0, -- markup to supplier's price is_content_src BOOLEAN DEFAULT FALSE, -- content source PRIMARY KEY (rule_id, supplier_id) ); What Pricing Strategies Are Supported?
We support three main pricing strategies: Min (minimum price), Primary (price of the primary supplier), and Markup (base price + markup). In the Min implementation, we consider each supplier's markup to get the true minimum.
enum PriceStrategy: string { case Min = 'min'; // Minimum price among suppliers with stock case Primary = 'primary'; // Price of the primary supplier case Markup = 'markup'; // Base price + markup from the rule } class PriceResolver { public function resolve(Product $product, PriorityRule $rule): ?float { $offers = $product->offers() ->where('stock', '>', 0) ->with('supplier') ->get(); return match ($rule->price_strategy) { PriceStrategy::Min->value => $this->resolveMin($offers, $rule), PriceStrategy::Primary->value => $this->resolvePrimary($offers, $rule), PriceStrategy::Markup->value => $this->resolveWithMarkup($offers, $rule), }; } private function resolveMin(Collection $offers, PriorityRule $rule): ?float { // Consider each supplier's markup when computing the minimum return $offers->map(function ($offer) use ($rule) { $rank = $rule->ranks->firstWhere('supplier_id', $offer->supplier_id); $markup = $rank?->markup_pct ?? 0; return $offer->price * (1 + $markup / 100); })->min(); } private function resolvePrimary(Collection $offers, PriorityRule $rule): ?float { // Primary supplier — first by rank with stock $rankedOffers = $offers->sortBy(function ($offer) use ($rule) { $rank = $rule->ranks->firstWhere('supplier_id', $offer->supplier_id); return $rank?->rank ?? PHP_INT_MAX; }); $primaryOffer = $rankedOffers->first(); if (!$primaryOffer) return null; $rank = $rule->ranks->firstWhere('supplier_id', $primaryOffer->supplier_id); return $primaryOffer->price * (1 + ($rank?->markup_pct ?? 0) / 100); } } Content Source Selection Strategies
Content can be taken from the first supplier with the is_content_src flag or by scoring completeness. Our scoring evaluates the presence of descriptions, images, brand, and specifications.
class ContentSourceResolver { public function resolveContentSupplier(Product $product, PriorityRule $rule): ?int { return match ($rule->content_mode) { 'primary_first' => $this->primaryFirst($product, $rule), 'best_score' => $this->bestScore($product, $rule), default => null, }; } private function primaryFirst(Product $product, PriorityRule $rule): ?int { // Take the supplier with is_content_src = true if they have an offer $contentSupplierIds = $rule->ranks ->where('is_content_src', true) ->sortBy('rank') ->pluck('supplier_id'); foreach ($contentSupplierIds as $supplierId) { if ($product->offers->firstWhere('supplier_id', $supplierId)) { return $supplierId; } } // Fallback: first by rank with stock return $product->offers ->sortBy(fn($o) => $rule->ranks->firstWhere('supplier_id', $o->supplier_id)?->rank ?? 999) ->first()?->supplier_id; } private function bestScore(Product $product, PriorityRule $rule): ?int { // Scoring of supplier content completeness return $product->offers->sortByDesc(function ($offer) { $sp = SupplierProduct::where([ 'supplier_id' => $offer->supplier_id, 'external_id' => $offer->supplier_sku, ])->first(); if (!$sp) return 0; $score = 0; if (!empty($sp->attributes['description'])) $score += 30; if (!empty($sp->attributes['images'])) $score += 25; if (!empty($sp->attributes['brand'])) $score += 15; if (mb_strlen($sp->name) > 50) $score += 10; if (!empty($sp->attributes['specs'])) $score += 20; return $score; })->first()?->supplier_id; } } Real-Time Rule Application
Product synchronization runs automatically on import or manually. Our ProductSyncService applies the rule to each product, updating price, stock, and content source. The system can process up to 10,000 products per hour — 10x faster than manual catalog filling.
class ProductSyncService { public function syncProduct(Product $product): void { $rule = $this->ruleResolver->findApplicableRule($product); if (!$rule) return; // Price $newPrice = $this->priceResolver->resolve($product, $rule); // Stock $newStock = match ($rule->stock_mode) { 'sum' => $product->offers->sum('stock'), 'primary_only' => $this->getPrimaryOffer($product, $rule)?->stock ?? 0, 'max' => $product->offers->max('stock'), }; // Content $contentSupplierId = $this->contentResolver->resolveContentSupplier($product, $rule); $product->update([ 'price' => $newPrice, 'stock' => $newStock, 'content_supplier' => $contentSupplierId, ]); if ($contentSupplierId) { $this->applySupplierContent($product, $contentSupplierId); } } } Resolving Conflicts When Prices Are Equal
If multiple suppliers have the same price, we use additional criteria. Delivery time is checked first (shorter is better). Then stock quantity (higher is better). Then supplier reliability rating. Finally, the rank in the rule. This prevents random selection and ensures price stability.
Typical Configuration Mistakes
| Mistake | Consequence | Fix |
|---|---|---|
| Only Min strategy without considering markups | Price may fall below cost due to delivery | Add markup to the rule for each supplier |
| No content priority configured | Product remains without description if the cheap supplier has no content | Enable is_content_src for the supplier with best content |
| Stock calculated as sum of all | Risk of selling products not in stock at the chosen supplier | Use primary_only or max mode |
Example of Rule Configuration for a Category
For the "Smartphones" category, you can set a global rule with priority 100: choose the Apple supplier as the primary content source (is_content_src = true) and calculate price using the Min strategy with a 3% markup for all suppliers. Then add rules for specific brands with higher priority.
Implementation Process
- Analysis of the current supplier and product structure.
- Design of prioritization rules tailored to your business.
- Implementation of data schema and algorithms (PriceResolver, ContentSourceResolver).
- Integration with your import and synchronization system.
- Testing on a sample of products and operator training.
- Deployment and monitoring.
Contact us to get a custom configuration for your project. We guarantee stability and full documentation.
What's Included in the Implementation
- Data schema and models — 1 day
- PriceResolver and ContentSourceResolver — 1–2 days
- ProductSyncService and synchronization triggers — 1 day
- Admin panel interface for rule management — 2 days
- Tests, documentation, and operator training — 1 day
Total: 6–7 working days turnkey.
We are a team with expertise in e-commerce automation, having delivered 50+ projects. We guarantee system stability and complete documentation. Order supplier prioritization implementation — contact us for a free assessment of your project.