ES
Back to projects

Zero-Cost Dropshipping Integration

Automated integration between Shopify, supplier and ERP with real-time synchronization, stock verification and automatic order processing for less than 10 euros per month.

Node.jsTypeScriptShopify APIRailwaySupabaseRedis
Zero-Cost Dropshipping Integration

When BarefootYou, an online barefoot shoe retailer, came to me with their e-commerce challenge, the requirements were straightforward: synchronize their Shopify store with their supplier’s inventory system and an ERP platform. In real-time. While keeping costs at nearly zero.

Simple, right? Except they’d been manually managing products for months, and we couldn’t just wipe everything and start fresh.

The Problem

Three independent systems that needed to talk to each other:

  • Shopify: Customer-facing store
  • Supplier API: Inventory and fulfillment
  • ERP: Warehouse management

The supplier updates stock every 5 minutes. That inventory is shared across multiple retailers. And the client already had hundreds of products with sales history, reviews, and SEO rankings that couldn’t be lost.

Oh, and keep it running for free (or close to it).

Architecture: Keep It Simple

The solution came down to three core components:

1. Real-time stock checks — App Proxy that validates inventory when customers view their cart

2. Nightly syncs — Cronjob that keeps the full catalog updated

3. Order webhooks — Automatic order submission to supplier

The magic ingredient? EAN codes. Every product variant across all three systems shares this 13-digit identifier. No fuzzy matching, no SKU format conversions. Just clean, deterministic synchronization.

The Hard Part: Migrating With History

Starting fresh is easy. Migrating existing products without losing anything? That’s the challenge.

The client had products that:

  • Existed in Shopify but weren’t connected to the supplier system
  • Had different naming conventions
  • Included variants (sizes, colors) created manually
  • Carried months of sales history and reviews

We built a matching system using EAN codes. For each supplier product:

  1. Check if a Shopify variant exists with matching EAN
  2. If yes, link them (preserve all history)
  3. If no, create a new hidden product for review

The first 100 matches were validated manually. Only after confirming the logic worked did we automate the rest.

Real-Time Stock: The Cart Check

Customers can’t buy what’s not in stock. But with shared inventory updating every 5 minutes, we can’t rely on cached data.

Solution: Shopify App Proxy.

When a customer views their cart, JavaScript calls our backend endpoint. We:

  1. Check Redis cache (30-second TTL)
  2. On cache miss, query supplier API
  3. Return stock levels to frontend
  4. Update Shopify inventory in background
  5. Sync to ERP

The UI shows immediate feedback:

  • Visual warnings for out-of-stock items
  • Disabled checkout button if anything unavailable
  • Suggested alternatives when possible

The 30-second cache is crucial. Cart checks happen constantly. Without caching, we’d hit API rate limits within minutes.

Nightly Sync: Keeping Catalogs Fresh

Real-time checks handle immediate needs. But we need a full sync to catch:

  • New products from supplier
  • Discontinued items
  • Price changes
  • Inventory corrections

Every night at 2 AM:

  1. Fetch full catalog from supplier
  2. Compare with current Shopify products
  3. Create new products (as drafts for manual review)
  4. Update existing inventory and prices
  5. Archive discontinued items
  6. Email summary to client
Daily Sync Report

Updated: 1,247 products
Created: 3 new products (hidden)
Archived: 1 discontinued product
Errors: 0

Simple. Automated. The client wakes up knowing exactly what changed.

Automated Orders

When a customer checks out:

  1. Shopify webhook fires
  2. We transform the order to supplier format
  3. Submit to supplier API
  4. Save order mapping in database
  5. Background sync to ERP

A daily tracking job checks shipment status and updates Shopify with tracking numbers.

The client never touches an order unless something breaks.

Infrastructure: When Modern Tools Meet B2B Reality

I started with Vercel. Great developer experience, edge functions, fast deploys. Everything worked perfectly.

Then the supplier emailed: “We need your IP addresses for whitelisting.”

Static IPs. Standard for B2B integrations.

Vercel’s answer: 100 euros/month. On a project meant to cost almost nothing.

Enter Railway

I migrated everything to Railway:

  • Static IPs included in base plan
  • Better logging (Vercel had 30-minute retention)
  • Same deployment simplicity
  • 10-15 euros/month total

The lesson? Modern serverless platforms optimize for B2C traffic. Traditional B2B integrations need:

  • Static IPs for whitelisting
  • Persistent connections
  • Longer timeouts
  • Comprehensive logging

Railway gave us all of this at 1/10th the cost.

Cost Optimization

Final monthly costs:

  • Hosting (Railway): 10 euros
  • Database (Supabase): 0 euros (free tier)
  • Cache (Redis): 0 euros (free tier)
  • Email (Resend): 0 euros (free tier)

Total: 10 euros/month

How?

Strategic caching: 30-second cache for stock, 1-hour for products, reduces API calls by 80%

Webhook-driven: No polling. Events trigger actions. No wasted resources.

Batch operations: Update 50 items per API call instead of 1 at a time

Free tiers: Carefully chosen services that offer generous free plans

Results

After three months:

  • 1,200+ products synced daily
  • 300+ orders/month processed automatically
  • 99.4% order success rate
  • < 300ms stock check response time
  • 0.01 euros cost per order

Most importantly: the client focuses on marketing while the system handles operations.

Lessons Learned

1. Pre-existing data is messy Starting fresh is easy. Migration requires careful planning, validation, and time.

2. Check B2B requirements first Static IPs, persistent connections, logging. These aren’t edge cases—they’re standard for supplier integrations.

3. Cache aggressively API limits are real. Design around them from day one.

4. Architecture drives costs Smart decisions (webhooks, caching, batching) matter more than server specs.

5. Universal identifiers are gold EAN codes made everything deterministic. Without them, we’d be doing fuzzy matching and manual reviews forever.

6. Test real workflows Integration tests that simulate actual user flows catch more bugs than comprehensive unit tests.

What’s Next

The system works. But there’s room to grow:

  • Multi-supplier support: Architecture ready for additional suppliers
  • Predictive alerts: Warn when inventory will run out based on sales velocity
  • Dynamic pricing: Adjust prices based on competition
  • Advanced analytics: SKU performance, stock velocity, order patterns

For scaling beyond 1,200 products:

  • Move to background job queue (BullMQ)
  • Add database read replicas
  • Implement CDN for images
  • Consider GraphQL for more efficient Shopify queries

Final Thoughts

Building this integration taught me that technical challenges are often easier than business ones. The hard parts weren’t the code—they were understanding constraints:

  • Existing data that can’t be lost
  • Shared inventory that changes constantly
  • API limits that shape architecture
  • B2B requirements that modern tools overlook
  • Cost optimization that comes from smart decisions

The system runs 24/7, syncs thousands of SKUs, processes hundreds of orders, and costs less than a few coffees per month.

Most importantly: it just works. The client doesn’t think about inventory sync or order routing. They focus on growing their business.

That’s the goal.

Interested in building similar integrations? The key is understanding your constraints first—then building architecture around them. Modern tools are powerful, but they’re not always designed for traditional B2B workflows.