Product Import Preview with Dry-Run Mode

You upload a price list with 500,000 rows. One swapped column — and prices drop by 30%, stock zeroes out due to wrong format. Recovery takes hours, conversion drops by 15%. Our dry-run mode solves this: you see exact changes before applying. It cuts errors by 4x — confirmed by deployments for catalogs from 50,000 SKU. The idea is based on dry-run testing, adapted for product catalogs.

Why dry-run is essential for online stores

Without preview, a column mapping error or wrong date format instantly corrupts the catalog. Standard validation often misses logical errors: price 0 or negative stock. Dry-run checks every change before writing. You see which products are created, updated, or unchanged. After approval, the operator triggers the apply. Our dry-run loads a preview for 100,000 rows 10x faster than standard parsing — by batching 1000 rows at a time.

Temporary table or Redis: what to choose?

For production we use a temporary database table. It's reliable for millions of rows, unlike in-memory (size limit, loss on crash) or Redis (complex recovery, extra service). Batch inserts minimize load. Schema: import_previews for summary and import_preview_items for details. Index on (preview_id, operation) speeds up filtering.

How do we compute diff for each product?

The key component is ImportDiffComputer. It loads the current product record by SKU and compares all configured fields. If the product is new — returns type create. If identical — unchanged. For differences, it builds a list of changes: price, qty, name, description, category_id. A typical picture: out of 500,000 rows roughly 30% contain changes (prices, stocks), 5% are new products, the rest unchanged.

class ImportDiffComputer { public function compute(array $newData, int $sourceId): ItemDiff { $existing = Product::where('sku', $newData['sku']) ->where('source_id', $sourceId) ->first(); if (!$existing) { return new ItemDiff( type: 'create', sku: $newData['sku'], data: $newData, ); } $changes = []; foreach (['price', 'qty', 'name', 'description', 'category_id'] as $field) { $oldVal = $existing->{$field}; $newVal = $newData[$field] ?? null; if ((string) $oldVal !== (string) $newVal) { $changes[$field] = ['old' => $oldVal, 'new' => $newVal]; } } if (empty($changes)) { return new ItemDiff(type: 'unchanged', sku: $newData['sku']); } return new ItemDiff( type: 'update', sku: $newData['sku'], changes: $changes, ); } } 

How is dry-run architecture structured?

In the import service, a flag $dryRun switches behavior: if true — returns preview, otherwise — apply result. Validation and diff execute identically, eliminating discrepancies.

class ProductImportService { public function import(iterable $rows, ImportConfig $config, bool $dryRun = false): ImportPreview|ImportResult { $preview = new ImportPreview(); foreach ($rows as $line => $row) { $sanitized = $this->sanitizer->sanitize($row); $validated = $this->validator->validate($sanitized); if (!$validated->valid) { $preview->addError($line, $row['sku'] ?? '?', $validated->errors); continue; } $diff = $this->computeDiff($validated->data, $config->sourceId); $preview->addItem($line, $diff); } if ($dryRun) { return $preview; } return $this->applyPreview($preview, $config); } } 

Saving preview

ImportPreviewRepository saves preview into temporary table in batches of 1000 rows. This allows handling files of any size — our experience shows stable work with 500,000 rows on typical hosting.

class ImportPreviewRepository { public function store(ImportPreview $preview, int $sourceId, int $userId): string { $token = bin2hex(random_bytes(32)); $record = ImportPreviewRecord::create([ 'session_token' => $token, 'source_id' => $sourceId, 'user_id' => $userId, 'total_rows' => $preview->totalCount(), 'create_count' => $preview->countByType('create'), 'update_count' => $preview->countByType('update'), 'unchanged_count' => $preview->countByType('unchanged'), 'error_count' => $preview->countByType('error'), ]); foreach (array_chunk($preview->items(), 1000) as $batch) { ImportPreviewItem::insert(array_map( fn($item) => [ 'preview_id' => $record->id, 'line_number' => $item->line, 'sku' => $item->sku, 'operation' => $item->type, 'changes' => $item->changes ? json_encode($item->changes) : null, 'errors' => $item->errors ? json_encode($item->errors) : null, ], $batch )); } return $token; } } 

How does the API manage previews?

The controller provides three endpoints: summary (statistics), details with pagination/filtering, and apply preview. Apply is queued to avoid blocking the UI. You can filter by operation or search for a specific SKU.

class ImportPreviewController { public function summary(string $token): JsonResponse { $preview = ImportPreviewRecord::where('session_token', $token) ->where('expires_at', '>', now()) ->firstOrFail(); return response()->json([ 'token' => $token, 'summary' => [ 'create' => $preview->create_count, 'update' => $preview->update_count, 'unchanged' => $preview->unchanged_count, 'errors' => $preview->error_count, 'total' => $preview->total_rows, ], 'expires_at' => $preview->expires_at, ]); } public function items(string $token, Request $request): JsonResponse { $preview = ImportPreviewRecord::where('session_token', $token)->firstOrFail(); $items = ImportPreviewItem::where('preview_id', $preview->id) ->when($request->operation, fn($q, $op) => $q->where('operation', $op)) ->when($request->search, fn($q, $s) => $q->where('sku', 'like', "%{$s}%")) ->orderBy('line_number') ->paginate(50); return response()->json($items); } public function apply(string $token): JsonResponse { $preview = ImportPreviewRecord::where('session_token', $token) ->where('expires_at', '>', now()) ->firstOrFail(); ApplyImportPreviewJob::dispatch($preview->id, auth()->id()); return response()->json(['status' => 'queued', 'import_id' => null]); } } 

How to implement partial apply and preview cleanup?

The operator can uncheck specific rows — excluded SKUs are marked as excluded and ignored in the final run. Expired previews (older than 2 hours) are deleted by scheduler every hour. Cascade deletion ensures data integrity.

public function applyPartial(string $token, array $excludeSkus): void { $preview = ImportPreviewRecord::where('session_token', $token)->firstOrFail(); ImportPreviewItem::where('preview_id', $preview->id) ->whereIn('sku', $excludeSkus) ->update(['operation' => 'excluded']); } // Cleanup in schedule $schedule->command('import:cleanup-previews')->hourly(); 

Steps to implement dry-run mode

1. File analysis: detect column structure, map to catalog fields.
2. Validation: check format, required fields, referential integrity.
3. Diff computation: compare with existing products by SKU, collect changes.
4. Preview storage: write to temporary table with batching.
5. Display: API summary/items, UI with change table and filtering.
6. Application: partial or full, respecting excluded rows.
7. Cleanup: scheduled removal of expired previews.

Turnkey implementation timelines

Exact estimate after analysis of your stack and data volumes. Order a free analysis of your import within 1 day.

What you get as a result

We develop dry-run mode on your stack (Laravel, Symfony, Node.js), compute diff with all catalog fields, set up temporary storage (DB or Redis), create REST API for summary, details and apply, and React/Vue components for change display. Implement partial apply and preview cleanup. Provide documentation and team training. Guarantee stable operation for one month after deployment. Potential savings — significant cost reduction by eliminating errors and downtime.

Get an engineer's consultation — we'll help avoid typical mistakes and speed up launch. Our experience: 5+ years integrating import systems for online stores.