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.
| Strategy | When to Use | Accuracy | Update Frequency |
|---|---|---|---|
| Full scheduled import | FTP/CSV, no stock API | Low (up to 24h delay) | Once daily |
| Delta sync | API with updated_since support |
Medium (15–60 min delay) | Every 30–60 minutes |
| Real-time webhook | Supplier supports push | High (seconds) | Instant |
| Real-time check on add-to-cart | Any API | High for critical moments | On demand |
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.
Example queue configuration in Laravel
'stock-sync' => [
'driver' => 'database',
'connection' => 'mysql',
'table' => 'jobs',
'queue' => 'stock-sync',
'retry_after' => 1800,
],
We use withoutOverlapping on cron tasks to avoid duplication.
What's Included in the Sync Implementation
| Stage | Scope of Work |
|---|---|
| Supplier API analysis | Study documentation, test endpoints, identify limits |
| Data model design | Create DB schema for storing stock and logs |
| Sync core implementation | Write code for full, delta sync, and webhook |
| Real-time check | Integrate stock check on add-to-cart |
| Testing | Load testing, verify correctness under failures |
| Documentation | Architecture description, deployment guide |
| Training | Demo the system, transfer knowledge to your team |
| First month support | Monitoring, bug fixes, adjustments as needed |
Why Trust Us?
We have been in web development for over 5 years and have completed more than 50 integrations with suppliers for e-commerce stores. Our team consists of 10 developers specialized in Laravel, Vue.js, and high-load systems. We guarantee stable sync and quick recovery in case of failures. Contact us for a project audit — we'll evaluate your current situation and propose the best solution.
Estimated Timelines
| Stage | Timeline |
|---|---|
| Full scheduled sync | 2 business days |
| Delta sync + real-time check | 3–4 business days |
| Webhook integration (if supported) | +1 day |
Get a consultation on choosing a sync strategy and learn how automation can reduce returns and increase customer loyalty. We are ready to help at every stage — from analysis to support.