Supplier-feed and store integrations for e-commerce clients

Overview

Between 2020 and 2025 I built about fifty small integration apps for freelance e-commerce clients, one per client and sometimes one per supplier.

Each app connects a client's store to one or more wholesale suppliers and keeps the store's products, prices, stock and collections in sync; many also pass orders to the supplier and bring tracking back.

The importers went live on client stores.

Some related client work has its own pages: an Amazon EU seller of VidaXL products and VidaXL dropshipping for Upforsale and SimplyChosen4U.

Context and problem

The clients appear to be small and mid-size online retailers and dropshippers, mostly on Shopify with some on WooCommerce and BigCommerce, who sell products from wholesale suppliers.

Every supplier delivered its catalogue differently: CSV, XLSX or XML files, FTP and SFTP drops, REST APIs and SDKs, or web pages that had to be scraped.

The job was to keep each store in step with those feeds and, often, to close the order loop as well: send each order to the supplier and write the tracking back to the store.

My role

All of it was freelance work, and I built each integration end to end: feed parsing, staging, store API sync, pricing rules, order hand-off and cron scheduling.

Only three of the apps are in git, and every commit in them is mine; the rest appear to follow the same template and code style, with no other contributors.

Solution and user experience

Every app runs the same staged pipeline, exposed as HTTP routes: download the feed, parse and stage the supplier's products in MySQL with a diff, create new products, update price, stock and content, then assign product types and collections and remove discontinued items.

An external crontab on the client's VPS calls those routes with curl, on schedules from every 2 minutes to once a day.

Staging rows carry status flags (new, changed, synced), so only the deltas reach the store.

On several of the apps the merchant can edit per-category margins, and the pipeline prices products from them.

Key features

• Catalogue sync: products, variants, inventory levels by location, custom collections, metafields, orders and fulfillments through the Shopify Admin REST API, with cursor pagination.
• Collections: store collections and taxonomy are built from the supplier's categories.
• Order hand-off: in about 20 apps, a Shopify order webhook becomes a supplier order (through an API, a CSV over SFTP, or an e-mail or sheet), the supplier status is polled, and a Shopify fulfillment with tracking is created.
• Client pricing rules: each client had its own formula, for example tiered markups by price band ending in 99 cents, a discount off the MSRP, a markup capped at the minimum advertised price, or the advertised price with the list price shown as compare-at.
• Large feeds: split into parallel routes or part files.
• Translation: product content translated with DeepL, and translations registered through Shopify GraphQL for a multi-language store.
• Other targets: WooCommerce through its REST API, the BigCommerce v3 catalogue API, and a Google Sheet for one order-routing app.

Architecture and stack

Each client, and sometimes each supplier, got its own small Lumen app copied from the current template, rather than one multi-tenant service.

Jobs are HTTP routes triggered by cron curls, not a queue worker or the framework scheduler; the one Laravel app uses Artisan commands instead.

• Language and frameworks: PHP 7 and 8 on Lumen 5.8, 7, 9 and 11, plus one Laravel 9 app.
• Staging: MySQL tables through the Lumen query builder.
• Feeds: league/flysystem for FTP and SFTP; SimpleXLSX, SimpleXLS, PhpSpreadsheet, SimpleXML and league/csv for files; php-html-parser for scraped pages.
• Stores: Shopify Admin REST in most apps and Shopify Admin GraphQL in some (productCreate, productVariantsBulkUpdate, productUpdate, sales-channel publishing and translationsRegister); WooCommerce REST through automattic/woocommerce; the BigCommerce v3 catalogue API called directly over HTTP.
• Python: Google Sheets order sync with gspread, retailer-site scrapers, and a headless scrape under xvfb-run.
• Scheduling: cron with curl calls to each app's routes.

Implementation details

The template changed over five years. From 2020 to 2022 the apps were Lumen 5.8 with raw cURL, hardcoded store settings and one controller per supplier; in 2022 a Lumen 9 template brought a shared ApiTrait and the Laravel HTTP client; in mid-2024 configuration moved into environment variables; and in 2025 the template reached Lumen 11 with Shopify GraphQL product mutations.

The 2025 build creates products with productCreate and updates variants with productVariantsBulkUpdate, priced with a tiered markup; I left it unfinished.

Standout apps

• A medical-supply order loop: the catalogue comes from the supplier's API, customer ship-to accounts are kept as Shopify customer metafields, each order becomes a CSV with unit-of-measure checks that is uploaded over SFTP, and tracking files read back from SFTP become Shopify fulfillments. It is the most complete order cycle in the set.
• A multi-store lighting and hardware marketplace: the largest app, a Laravel 9 project with 23 Artisan command classes and a shared ApiTrait, covering per-vendor price updates, MAP-based pricing, vendor catalogue matching between stores, parallel per-vendor delete jobs, and GraphQL product updates and sales-channel publishing.
• An auto-accessories store on WooCommerce: the widest scope for one client, with a distributor API feeding WooCommerce at MAP-capped Canadian prices, a vehicle fitment lookup API (year, make, model, sub-model, parts) for the storefront, order hand-off with status polling, and a bridge from an online booking tool into a shop-management system for appointments, customers and vehicles.
• Order routing through a shared sheet: order webhooks from five Shopify stores land in MySQL, a Python job appends them to a Google Sheet for the fulfilment partner, and tracking numbers entered in the sheet are read back to fulfil the Shopify orders.

Challenges

• Every supplier delivered data differently, so each app likely needed its own parser on top of the shared pipeline.
• Feeds that were apparently too large for one request were split into parallel routes or part files.
• Closing a B2B order loop over SFTP meant per-order CSVs with unit-of-measure validation going out and tracking files coming back in.

Trade-offs

One app per client probably kept each integration isolated and quick to adapt, at the cost of duplicated code, cron files copied unchanged between apps, and credentials that had to be maintained folder by folder.

Links

No public link or repository for this project.

Skills demonstrated

• Supplier feed integration across files, FTP and SFTP, REST APIs, SDKs and scraped pages.
• Shopify Admin API work in REST and GraphQL, plus WooCommerce and BigCommerce APIs.
• Order and fulfilment automation with supplier APIs, SFTP files and Google Sheets.
• Data pipelines with staging and change detection.
• Pricing and catalogue rules.
• PHP backend development with Lumen and Laravel, and Python scripting.