Every system that wires into commerce.

Wiring the storefront to the systems that run trading: ERP, PIM, OMS, WMS, search, payments, marketplaces, CMS and middleware. Each integration is a contract between two systems, covering data shape, write surface, cadence, error handling and monitoring. The contract is the real work, not the connector configuration. iWeb writes that contract down, versions it and monitors it after launch.

ERP integrations have their own deeper hub because ERP is usually the commercial backbone and the integration pattern is mature. This directory covers the broader estate iWeb wires into the storefront, including PIM, OMS, WMS, search, payments, marketplaces, CMS, middleware, shipping, fulfilment, tax and fraud systems.

PIM-to-storefront and PIM-to-channel feeds against governed contracts: attributes, copy, variants, asset URLs and completeness state. Real-time reads where the operation needs them, scheduled syncs where it does not. The contract is versioned and observable rather than implied by a connector setting. This applies to Akeneo, Salsify or another PIM.

Storefront orders posted through monitored queues, order state read back through governed APIs and warehouse and ERP boundaries kept clean. Partial dispatch, returns, cancellations and state changes are observable end to end rather than visible in one system at a time.

Stock levels read on demand and cached at the storefront boundary; pick, pack and dispatch events written back to OMS and ERP through monitored queues; reconciliation reports surface drift before it shows up at checkout. Branch-aware stock is modelled honestly rather than flattened. The pattern applies to Mintsoft, Peoplevox or other warehouse and fulfilment platforms.

Search engines such as Algolia, Constructor.io, Klevu or another search platform wired into product, category and merchandising flows. The catalogue feed is derived from the PIM, the relevance configuration sits with named owners and index rebuilds are observable rather than fired silently.

Payment providers, such as Stripe, Opayo or other payment platforms, wired into checkout with tokenisation, 3DS and account-based payment for B2B trade. The choice is shaped by trading geography, basket profile and chargeback exposure. Reconciliation against the ERP is monitored and reported rather than assumed clean at month end.

Marketplace platforms and channels, such as Amazon, eBay, Mirakl, TikTok Shop or other marketplaces, integrated into the operational core for catalogue listings, order flows and seller management. Listings are derived from the governed PIM record with channel-specific mapping rather than parallel data entry.

Headless or integrated CMS platforms connected to the storefront for marketing, content and editorial workflows. The CMS reads the governed PIM record where product data is referenced, so content and commerce do not drift apart at the surface.

When more than two systems share a write surface, when reliability requires queued retries, or when integration contracts need to be transformed and versioned in one place. Middleware is not a default. iWeb names the trade-off between point-to-point and middleware honestly against the operation rather than reaching for a platform by habit.

Versioned contracts written down before implementation, backwards compatibility named and deprecation paths planned. APIs are observable through telemetry and reconciliation reports rather than trusted on faith. The integration contract is the design artefact, not the connector configuration.

Stock and pricing are usually read on demand and cached at the storefront, orders posted asynchronously through monitored queues, and reference data refreshed on a defined schedule. The cadence is tuned to ERP and PIM load and named per integration rather than assumed.

Throughput, latency, error rate, queue depth, dead-letter volume and reconciliation gaps surfaced as visible signals to a named on-call rota. Alerts are tuned against trading impact rather than system noise. The runbook is written down so the on-call team can act without escalation.

Retries with backoff, dead-letter queues for human review, reconciliation reports for drift and clear ownership for each error class. Errors are surfaced to named owners rather than silently swallowed. Failure modes are documented in the runbook before they happen, not after.

A named senior owner on the iWeb side for the integration surface and monitoring, and a named owner on the merchant side for the business process the integration serves. Ownership is written down so handoffs do not drift between teams.

Contract tests at the API surface, staging environments that mirror production data shape, end-to-end rehearsals against realistic volumes and post-deploy reconciliation runs. Integrations usually break at boundaries, so testing focuses on the boundary rather than on internal connector behaviour.

Rescue starts with an audit of the existing integration contracts, monitoring coverage, reconciliation gaps and runbook completeness. Remediation is sized against trading impact. The first month on support is deliberately conservative on change while the team learns the existing pattern.

Mapping is governed: source field, target field, transformation rule, validation rule and reconciliation behaviour. The mapping is reviewable and reversible rather than buried in connector code. Where mapping changes, the change is named, sized and rolled out under monitoring.

In the system that owns the data: pricing logic in ERP, catalogue logic in PIM, fulfilment logic in OMS and WMS, search logic in the search engine. The integration surface moves data rather than becoming a parallel rules engine. Business logic in middleware is a flag, not a feature.

A named senior team owns the integration surface day to day: monitoring, releases, incident response and contract changes. Quarterly reviews look at drift, error rate trends and reconciliation gaps so debt is paid down before it shows up at the storefront.

With a written integration contract per boundary, covering data shape, write surface, cadence, error handling, monitoring and ownership. The contract is the design artefact; code, connectors and middleware come after the contract, not before.