Custom Integrations
Plekify Custom Integrations
Bring a system with an API. We'll build the integration.
Plekify connects your PMS or ERP to Shopify — order-of-record data flows one way, orders and payments flow back. Not a pre-built library. A build, scoped to your system.
A commitment, not a library
Most "integration marketplaces" ship a generic adapter and hope your NetSuite instance, your custom price tiers, your approval rules look like everyone else's. They don't.
We don't maintain a shelf of connectors waiting for your system to match one. We look at your ERP or PMS, your Shopify catalogue, and your channel rules — who buys, at what tier, on what terms — and we build the pipe that fits. If your system has an API, we can integrate it. That's the commitment: not "check if you're on the list," but "show us the API."
This means discovery happens on your actual data, not a demo tenant. It means the connector handles your retry logic, your webhook shapes, your field mappings — not a lowest-common-denominator schema. And it means when something's non-standard — multi-branch, two-way sync, a courier with a quirky waybill format — we scope it, we don't refuse it.
The four stages
1. Discovery
We map your ERP or PMS — the order-of-record — against your Shopify catalogue and your channel rules: who's allowed to buy, at what tier, on what terms. This runs directly against your own data, not a sandbox stand-in. Discovery is where price levels, approval flows, and edge cases surface before a line of connector code ships.
2. Connector
System-of-record pull → cache → Shopify write, with webhooks handling the reverse flow back to your ERP or PMS. Every job is idempotent. Failures land in a dead-letter queue instead of silently vanishing. Retries and circuit breakers absorb upstream outages. Secrets are envelope-encrypted (AES-256-GCM) at rest. Shopify writes go through Admin GraphQL, pinned to a current API version — not whatever endpoint happened to work on the day we built it.
3. Dashboard
An operator surface for the humans who run this day to day: sync health, approval queues, price and tier matrices, inventory state, an audit log, and ops probes to check the pipeline is actually breathing. Where the engagement calls for it, we also build a customer-facing account hub — invoices, order history, statements — on the same data.
4. Managed service
Nightly reconcile jobs catch drift before it becomes a support ticket. We monitor staging discipline — nothing goes live without a rehearsal. This is the difference between "we shipped it" and "we still own it."
Whatever your system of record — PMS or ERP — Plekify is the Shopify commerce layer on top, with a custom dashboard where the two meet.
The engine under it all
The connector layer isn't a script that polls an API and hopes. It's built the way payment infrastructure is built:
- Postgres-backed queue — every job persisted, nothing lost to a process restart.
- Idempotent jobs — replay a job safely; no duplicate orders, no double-charged invoices.
- Dead-letter queue — failures are captured and visible, not swallowed.
- Retries with circuit breakers — upstream ERP or PMS outages don't cascade into your Shopify storefront.
- Envelope-encrypted secrets (AES-256-GCM) — API keys and tokens are never stored in plaintext.
- Fail-closed discipline — when a price or tier can't be verified, the system falls back to list price rather than guessing a discount.
- Shopify Admin GraphQL, pinned to a current version — no silent breakage when Shopify ships a new release.
This is the same pattern across every system we've connected. The API changes. The engine underneath doesn't.
Proven on three systems
NetSuite — LIVE
Every price level and per-item price subrecord synced to Shopify B2B catalogs as fixed prices. Trade approvals end-to-end. Pay-on-account. Per-line tier discounts with fail-safe to list price if a tier can't be verified. Nightly reconcile keeps Shopify and NetSuite in agreement. Engaged client: a UK film-distribution manufacturer on NetSuite.
Acumatica — LIVE
A cache-first pipeline pulls from Acumatica and writes to Shopify. A customer account hub gives buyers their invoices (with PDF), proof-of-delivery documents, statements, and support cases. Order write-back to the ERP is verified idempotent — no duplicate orders on retry. Engaged client: a South African industrial-safety distributor on Acumatica.
Xero — LIVE reference
Xero is the order-of-record. A roughly 30-minute sync pushes inventory into Shopify stock levels and the Xero sale price into variant metafields. Every Shopify draft order is accompanied by a Xero AUTHORISED tax invoice. A Xero PAID webhook drives the tag pipeline. An ops dashboard runs at api.iroll.co.za. Reference client: a South African e-mobility retailer.
RAM courier — in progress
Quote, consignment/waybill, label, and tracking endpoints are verified in UAT. Go-live is staged pending a rate cross-check. We're not calling this live end-to-end yet — and we won't, until it is.
Reporting you can trust
Alongside commerce integrations, we've built and proven internally: campaign and PMax asset-group reporting, search-term/device/daily breakdowns, and offline GCLID conversion upload wired to a payment webhook — plus executed campaign restructures. This is reporting and offline-conversion plumbing, proven internally. It is not a packaged ads product tier — it's the same engineering discipline applied to ad-platform data.
A dashboard that comes with it
Every integration ships with an operator dashboard, built from a proven shell: roughly fifteen operational screens covering reservations, guests, folios, night audit, housekeeping, rate plans, reports, audit, and setup — multi-tenant, with a super-admin switcher for managing multiple properties or entities from one place.
That shell is the starting point. Each engagement gets its own dashboard, shaped around what your system actually needs to expose: price matrices for a distributor, a customer account hub for an industrial supplier, sync health for an e-mobility retailer. The shell means we're not starting from a blank screen. The customisation means it fits.
Pricing
- Setup: from $4,000–$7,000 (most common range; scope varies with system complexity)
- Managed service: from $495–$895/month (most common range; covers reconcile, monitoring, staging discipline)
- Multi-branch, two-way sync, and other non-standard work: scoped per engagement — no fixed quote until we've seen your system
These are starting ranges, not quotes. What you pay depends on what you bring us.