Part 2 of The Mid-Market Commerce Reality Series
In Part 1 of this series, we talked about why complex commerce systems break at scale. The short version is this: most systems don’t fail because of traffic, checkout, or the ecommerce platform itself. They fail because operational complexity grows faster than the systems supporting it.
The next logical question is: Where do things actually start to break?
Not on the homepage.
Not in checkout.
Not even in performance.
Commerce systems usually break between systems first.
They break in integrations.
And the reason this is so dangerous is because integration failures rarely look like failures at first. They look like small inconsistencies, manual workarounds, and “we’ll fix it later” processes.
Until one day, finance can’t reconcile numbers, operations doesn’t trust inventory, and leadership realizes the business is running on spreadsheets again.
The Modern Commerce Stack Is Not One System
Most mid-market companies don’t run on a single platform. They run on a stack of systems that all need to work together:
- Ecommerce platform (Shopify, WooCommerce, etc.)
- ERP system
- Warehouse or fulfillment software
- Shipping systems
- Tax calculation software
- CRM
- Marketing automation
- Reporting and BI tools
- Customer portals or custom applications
The only way this works is through integrations that move data between systems:
- Products
- Customers
- Pricing
- Inventory
- Orders
- Shipments
- Tracking
- Invoices
- Payments
At a high level, everything looks connected. Orders flow. Inventory updates. Customers get confirmations.
But under the surface, integrations are doing an enormous amount of work.
And most companies underestimate how much business logic lives inside those integrations.
The Myth of “Just Sync It”
One of the most common phrases in mid-market ecommerce is:
“We just need to sync the website with the ERP.”
That phrase hides a huge amount of complexity.
Because what does “sync” actually mean?
Does the ERP control pricing, or does the website?
Which system is the source of truth for inventory?
When an order is placed, when is it considered “posted”?
What happens if inventory is available in one warehouse but not another?
What happens with backorders?
What happens when a customer has contract pricing that doesn’t match standard pricing tables?
What happens when an order fails to sync?
What happens when an order is edited after it’s placed?
What happens when a shipment is split across multiple warehouses?
None of this is plumbing. This is business logic.
And that business logic has to live somewhere. In most mid-market systems, a large portion of it ends up living in integration code, middleware, plugins, scheduled jobs, and custom scripts.
Which means your integrations are not just connectors.
They are critical operational software.
Integrations Decay, They Don’t Usually Crash
When people think about system failures, they think about outages. The site goes down. Orders stop processing. Something obvious breaks.
Integration failures are different.
They usually don’t crash. They decay.
This decay shows up as small issues:
- Inventory is off by a few units
- A few orders each week fail to sync
- Some customers have duplicate accounts
- Pricing is wrong for certain edge cases
- Tracking numbers don’t always come through
- Finance has to make manual adjustments at month end
Individually, these issues seem manageable. Teams create workarounds. Someone checks a report each morning. Someone else fixes failed orders. Accounting reconciles differences at the end of the month.
But over time, these small issues add up to something much bigger: the organization stops trusting the system.
And when teams stop trusting the system, they stop using the system.
Spreadsheets come back. Manual processes come back. The efficiency gains from ecommerce start to disappear.
This is why integration problems are so dangerous. They don’t stop the business immediately. They slowly make the business harder to run.
Data Drift Is Worse Than Downtime
There’s a concept that’s useful here: data drift.
Downtime is obvious. Everyone knows when the site is down.
Data drift is when systems are almost right, but not exactly right:
- Inventory in the ERP says 120 units, the website says 117
- Pricing is correct for most customers, but wrong for a few contract accounts
- Sales reports don’t quite match finance reports
- Customer records exist in multiple systems with slightly different information
Data drift creates operational friction:
- Customer service doesn’t trust inventory numbers
- Sales doesn’t trust pricing on the website
- Finance doesn’t trust order totals
- Leadership doesn’t trust reports
At that point, the company doesn’t have a technology problem. It has a confidence problem.
And confidence problems slow down decision-making, growth, and investment.
The Real Problem: No One Owns the Integrations
In many mid-market organizations, integrations fall into a strange gap.
- The ecommerce team assumes IT owns them.
- IT assumes the ecommerce agency owns them.
- The agency assumes they were only hired to build the site.
- Operations assumes “the system” handles it.
- Finance just fixes the numbers when they’re wrong.
So integrations become critical infrastructure that no one actually owns.
They were built during a project, and then they just… exist.
But integrations are not one-time projects. They are living systems that need:
- Monitoring
- Logging
- Error handling
- Documentation
- Updates when business rules change
- Updates when APIs change
- Updates when the company adds new warehouses, pricing rules, or workflows
When no one owns integrations, they don’t stay healthy. They slowly drift out of alignment with the business.
What Scalable Companies Do Differently
Companies that scale successfully tend to treat integrations very differently.
They treat integrations as products, not projects.
That means:
- There is clear ownership
- Failures are logged and reviewed
- Data is audited regularly
- Business rules are documented
- Changes are tested before being deployed
- There is visibility into what happens when something fails
Most importantly, they understand that integrations are where operations and technology meet. So they involve both technical and operational stakeholders in decisions about how integrations work.
A Better Question to Ask
Instead of asking:
“Does the website sync with the ERP?”
A better question is:
“Who is responsible for making sure our systems stay in sync as our business evolves?”
That’s a very different question. And the answer usually reveals whether a company is set up to scale or set up to struggle.
Because at scale, the biggest risk to commerce is not usually the storefront.
It’s the connections behind the storefront.
Looking Ahead
In the next article in this series, we’ll talk about what many companies try to do when integrations and systems start to feel fragile: replatform.
Replatforming feels like progress. New technology, new features, a clean slate.
But often, replatforming doesn’t fix the real problem. It just moves it.
We’ll talk about why that happens, and when replatforming actually does make sense.
