Capability

Nobody typing the same number twice.

Node and Express services over Postgres, talking to the Shopify Admin API and whatever else is already in play. Scheduled syncs, webhooks, idempotent writes and submission that survives losing signal.No more copying stock into a spreadsheet, re-keying an order, or checking two screens before you can answer a customer. Service portals, stock feeds, supplier integrations and the internal tools nobody sells you.

We are not consultants describing this from the outside. We run three businesses of our own and do every one of these jobs in them, every week.

WYBBPlateSellerDrehwerks
The problem

Nobody buys four systems on purpose.

They arrive one at a time. Each one solved the problem in front of you that year, and none of them was built with the others in mind. So somebody becomes the integration: copying stock figures into a spreadsheet on a Monday, re-keying an order into the production system, checking two screens before answering a customer who is still on the phone.

It works, right up until the person who holds it together is on holiday. Then you find out how much of the business was running on their memory.

×Stock says four, the shelf says one
×An engineer arrives without the right part
×A price changes Monday, the site changes Thursday
×Two exports, three spreadsheets, one argument
What this looks like in practice

Four things we have built in the last two years. None of them existed as a product you could buy.

Field service

An engineer portal that works in a plant room

Per-engineer accounts, mobile-first service recording and submission that holds and completes when signal comes back. Site visits happen in basements. A form that loses the last twenty minutes of typing gets used once.

Stock feeds

A website that reads the Auto Trader feed

Vehicles appear, sell and disappear in one place instead of two. Nobody maintains the website listings, because there are no website listings to maintain.

Parts lookup

One spares list, three places to search it

Built from the master parts sheet and enriched with Shopify export data, so three identical-looking rows become three distinguishable variants. Rebuilt whenever the sheet changes, because the sheet always changes.

Manufacturing

Order in, production-ready artwork out

The manual step between a customer configuring something and the factory being able to make it, removed. That step was a person, and it was the bottleneck on every order.

How we work through it
01

Map what you actually have

Every system, every spreadsheet, every place a number gets typed a second time. It takes a day because we know where to look, and it almost always finds more than anyone expected, including two subscriptions nobody remembered buying.

A day
02

Decide what owns each fact

Stock level, price, product copy, order status. One system owns each one and everything else reads from it. Most integration pain is two systems that both believe they are right, and nobody ever decided which one wins.

A conversation, not a workshop
03

Build the joins, then the tools

Connections first, because a portal reading bad data is worse than no portal. Then the thing people actually open. Node, Express and Postgres unless there is a reason not to, with the Shopify Admin API and webhooks where the store is involved.

Shipping every two weeks
04

Make failure loud

A sync that fails quietly is worse than one that falls over, because the data drifts for weeks before anybody looks. Every run gets logged, every run counts what moved and somebody gets a message when the count is zero.

Built in, not added later
What you end up with
  • › Running software, on your infrastructure or ours, with the source in your repository
  • › A written map of which system owns which fact, which outlives us both
  • › Logging and alerting, so a broken sync announces itself
  • › Documentation written for whoever picks it up next, on the assumption that is not us
  • › A person who answers the phone and already knows your setup
What we will not do
  • × Build you something that an existing product does properly for sixty pounds a month
  • × Hold your code hostage. It is yours from the first commit
  • × Put a junior on it and bill you for a senior
  • × Start building before anyone has agreed what owns what
  • × Take the work on if we think somebody else is better placed for it
Scope and cost

We do not quote integration work off a brief, because the brief is always written before anyone has looked inside the systems. What we do instead is agree the map in step one at a fixed price. It is the document that tells you what you actually run, what owns which fact and where the duplication is costing you, and it is yours whether or not you carry on with us.

After that it is either a fixed-scope project with milestones, or a monthly retainer if the systems are going to keep moving. Most of this kind of work ends up retained, because integrations are not finished, they are maintained.

If your budget will not cover it, say so early and we will tell you honestly whether a smaller version is worth doing or whether you should wait.

Questions

What if the system has no API?

Then we find out what it does have. Most business software of a certain age will export on a schedule, write to a database, or send an email with a file attached. Those are all workable. What we will not do is screen-scrape a user interface and tell you it is an integration, because it breaks the first time somebody moves a button.

What happens when the vendor changes their API?

It breaks, and you find out from the alerting rather than from a customer. That is the point of the logging: a sync that stops announces itself. Fixing it is usually an hour. The version where nobody notices for three weeks is the expensive one, and that is the version you have now.

What if the two systems disagree about the same fact?

Then somebody has to decide which one is right, and that is a business decision rather than a technical one. It is also the single most useful hour of the whole job. Most integrations that fail do so because this conversation was skipped and both systems kept writing.

Can you integrate something we are planning to replace?

Often yes, and sometimes that is the right order: joining it up first tells you what the replacement actually needs to do. What we will not do is build a deep integration into something with a decision already made against it. We will say so if that is what you are asking for.

Tell us what is not joining up.

We will tell you whether we can help and roughly what it takes. No deck, no discovery fee, no two-week silence while somebody writes a proposal.