Stock Sync Implementation with a Dropshipping Supplier

Implementing Stock Synchronization with a Dropshipping Supplier

Have you ever had a customer place an order only for the supplier to say the item is out of stock? That leads to returns, unhappy customers, and a damaged reputation. It's especially painful when your site shows stock, but the real inventory is already zero. The gap between your storefront and reality can be hours — for popular items, minutes. According to statistics, up to 30% of dropshipping orders are canceled due to stockouts; automated sync reduces that to 5%. We specialize in dropshipping automation and supplier stock synchronization. In this article, we'll show you how to set up reliable sync to avoid these issues.

How to Choose a Synchronization Strategy?

Below are the main strategies we use, depending on supplier capabilities and accuracy requirements. Each has trade-offs in speed and load.

For most projects, we use a combination: delta sync every 30–60 minutes plus a real-time check when the item is added to the cart. This balances load and accuracy. Delta sync cuts transferred data to about 10% of a full import, significantly reducing processing time.

Why Real-Time Check Is Essential?

Periodic sync reduces risk but doesn't eliminate it. Even with delta sync, stock can change between checks. So we add a check at the moment of adding to cart. This solves last-mile accuracy. Below is an example implementation in Laravel.

class AddToCartAction { public function execute(Product $product, int $quantity, Cart $cart): void { // For dropship products, check stock with the supplier if ($product->dropshipProduct && $this->shouldDoRealtimeCheck($product)) { $connector = SupplierConnectorFactory::make($product->dropshipProduct->supplier); $result = $connector->checkStock($product->dropshipProduct->supplier_sku); // Update cache $product->dropshipProduct->update([ 'supplier_stock' => $result->stock, 'synced_at' => now(), ]); if ($result->stock < $quantity) { throw new InsufficientStockException( available: $result->stock, requested: $quantity, ); } } $cart->addItem($product, $quantity); } private function shouldDoRealtimeCheck(Product $product): bool { // Check in real-time if last sync was more than 15 minutes ago $lastSync = $product->dropshipProduct->synced_at; return !$lastSync || $lastSync->diffInMinutes(now()) > 15; } } 

Data Model and Change Logging

To track stock changes, we create a log table. This simplifies debugging and auditing.

Schema::create('dropship_stock_log', function (Blueprint $table) { $table->id(); $table->foreignId('dropship_product_id')->constrained(); $table->integer('prev_stock'); $table->integer('new_stock'); $table->string('source')->default('sync'); // sync | webhook | realtime_check $table->timestamp('recorded_at'); $table->index(['dropship_product_id', 'recorded_at']); }); 

Full Scheduled Synchronization

Once daily (usually at night), we run a full sync to catch discrepancies missed by delta. The implementation consists of two jobs: one dispatches per supplier, the other processes each supplier.

class FullStockSyncJob implements ShouldQueue { public $timeout = 1800; // 30 minutes for large catalogs public function handle(): void { $suppliers = Supplier::where('is_active', true)->get(); foreach ($suppliers as $supplier) { SyncSupplierStockJob::dispatch($supplier)->onQueue('stock-sync'); } } } class SyncSupplierStockJob implements ShouldQueue { public $tries = 3; public $backoff = [60, 300, 900]; public function handle(SupplierConnectorFactory $factory): void { $connector = $factory->make($this->supplier); $page = 1; $updated = 0; do { $products = $connector->getStockLevels($page, 500); foreach ($products as $item) { $dropshipProduct = DropshipProduct::where([ 'supplier_id' => $this->supplier->id, 'supplier_sku' => $item->sku, ])->first(); if (!$dropshipProduct) continue; if ($dropshipProduct->supplier_stock !== $item->stock) { $prevStock = $dropshipProduct->supplier_stock; $dropshipProduct->update([ 'supplier_stock' => $item->stock, 'synced_at' => now(), ]); // Update stock in the store's catalog if ($dropshipProduct->product) { $this->updateProductAvailability($dropshipProduct->product, $item->stock); } // Log the change DropshipStockLog::create([ 'dropship_product_id' => $dropshipProduct->id, 'prev_stock' => $prevStock, 'new_stock' => $item->stock, 'source' => 'sync', 'recorded_at' => now(), ]); $updated++; } } $page++; } while (count($products) === 500); Log::info('Stock sync completed', [ 'supplier' => $this->supplier->slug, 'updated' => $updated, ]); } private function updateProductAvailability(Product $product, int $newStock): void { $wasAvailable = $product->stock > 0; $isAvailable = $newStock > 0; $product->update(['stock' => $newStock]); // Notify 'notify me when back in stock' subscribers if product became available if (!$wasAvailable && $isAvailable) { event(new ProductBackInStockEvent($product)); } } } 

Delta Sync and Webhook

If the supplier's API supports the updated_since parameter, we use delta sync instead of full import — we only load changed records. This reduces load and speeds up updates. For suppliers that support push notifications, we set up a Webhook — stock updates in seconds.

// routes/api.php Route::post('/webhooks/supplier/{supplier:slug}/stock', SupplierStockWebhookController::class) ->middleware('verify.supplier.signature'); class SupplierStockWebhookController { public function __invoke(Request $request, Supplier $supplier): JsonResponse { foreach ($request->input('items', []) as $item) { UpdateDropshipStockJob::dispatch($supplier, $item['sku'], $item['stock']); } return response()->json(['ok' => true]); } } 

What Risks Arise Without Synchronization?

Without automation, you end up manually reconciling stock, which takes hours daily. Customers see inaccurate data, leading to order cancellations and lower search rankings due to high return rates. According to our data, automation cuts order cancellations from 30% to 5%, saving up to 15% of store turnover. For a store with $100,000 monthly turnover, that's $15,000 saved — the solution pays for itself in 2–3 months.

How to Avoid N+1 Queries in Full Sync?

In the SyncSupplierStockJob code, each DropshipProduct::where inside the loop is a potential N+1. For a catalog of 10,000 SKUs, that's 10,000 queries. We optimize by loading all existing records for the supplier in one query into a Collection, then matching by key. Alternatively, use updateOrCreate with mass update, but versioning requires caution.

Monitoring and Notifications

We set up alerts in Telegram/Slack on sync failures. Every step is logged: number of updated records, execution time, API errors. This allows quick response to issues. For example, if the supplier returns HTTP 503, the job automatically retries after 5 minutes with exponential backoff.

'stock-sync' => [ 'driver' => 'database', 'connection' => 'mysql', 'table' => 'jobs', 'queue' => 'stock-sync', 'retry_after' => 1800, ],