Connect · Pillar 02
Integration, so the same data is never typed twice.
Nearly every business we meet is already paying for the systems it needs. What it is missing is the wiring between them — and the person currently acting as that wiring has better things to do.
What does system integration actually mean?
System integration is connecting separate business applications so that data entered in one appears correctly in the others, without anyone retyping it. In practice it means agreeing which system owns each piece of data, building a reliable transport between them — usually an API — and handling failures explicitly so nothing is silently lost.
- One system owns each field; the rest subscribe to it.
- Transfers are idempotent and retried, so a timeout cannot duplicate an order.
- Failures raise an alert to a person rather than disappearing into a log.
Why it matters
Most integration fails quietly, which is the problem.
A broken website is obvious within minutes. A broken integration is not: orders keep arriving, the sync has stopped, and nobody notices until a customer asks why their order was never despatched. By then there are four days of data to reconcile by hand.
So the engineering effort goes somewhere unglamorous. Not into the happy path, which is straightforward, but into what happens when the other end returns a 500, or times out after accepting the request, or changes a field type without notice. That is what separates an integration that lasts five years from one that needs babysitting.
What we build in from the start
How integrations fail
These are not extras, they are the integration. Any connection without them is a prototype that happens to be in production:
- The same order is keyed into two systems by two different people.
- A nightly CSV export and import holds the business together.
- When the sync fails, you find out from a customer.
- Two systems disagree about stock and nobody knows which to trust.
- An integration broke when a vendor updated their API and stayed broken.
- One person reconciles two systems manually every month end.
Scope
What integration work covers.
Whether we are building your API for others to consume or joining systems you own, the same disciplines apply.
-
API design & build
REST or GraphQL APIs over your own systems, versioned, documented with OpenAPI, authenticated and rate limited, so partners and your own apps can consume them safely.
-
Integration between systems
ERP to e-commerce, CRM to accounts, WMS to carrier, PIM to marketplace — with an explicit decision on which system owns each field and which way data flows.
-
Middleware & orchestration
A thin integration layer where point-to-point would create a tangle, so replacing one application later does not mean rebuilding six connections.
-
Reliability engineering
Idempotency keys, exponential backoff, dead-letter queues and circuit breakers. Dull, and the entire difference between reliable and nearly reliable.
-
Monitoring & alerting
Dashboards for throughput, latency and failures, with alerts that reach a human within minutes. Silent failure is the only failure mode that really costs money.
-
Documentation & contracts
A written data-ownership map and interface contracts, so the next developer can see what talks to what without reverse-engineering it.
Deliverables
What integration gives back.
The gain is partly hours saved and mostly errors prevented. The second is harder to see on a timesheet and usually worth more.
-
Data entered once
Keyed in at the point it originates and propagated from there. Both the duplicated effort and the transcription errors it introduces disappear together.
-
One answer to every question
A documented owner for every field, so stock, price and credit limit have one authoritative value. Reconciliation meetings stop being about whose number is right.
-
Failures that announce themselves
When something does break, and eventually it will, you know within minutes with a clear record of what did not get through, instead of discovering it days later.
-
Freedom to change suppliers
With integration through a documented layer rather than hard-wired point to point, replacing one system is a contained project instead of an argument for keeping it.
Is this the right answer?
When api development is worth doing — and when it is not.
We would rather lose a project at this stage than six weeks in. If the right-hand column describes you, say so and we will tell you what we would do instead.
Worth doing when
- The same information is typed into two or three systems every day.
- A nightly export and import is holding the business together.
- You find out the sync has broken from a customer, days later.
- Two systems disagree about stock and nobody knows which to trust.
Probably not when
- The underlying data is wrong, in which case integrating spreads the problem.
- You are about to replace one of the systems involved — wait.
- Nobody will decide which system owns which field.
- The volume is three records a week and a person doing it is genuinely cheaper.
How we deliver
How we approach an integration.
The first phase is a map, not code. Most integration disasters are a data-ownership question that was never asked.
-
Phase one
Map the data
Which system owns which field, where it is duplicated today, and which direction each flow should run. Output is a one-page ownership map that usually settles an argument that has been running for years.
-
Phase two
Build the hardest flow
We start with the connection that carries the most risk — normally orders or stock — because it proves the reliability design under real conditions.
-
Phase three
Extend & instrument
The remaining flows, reusing the same transport and error handling, with monitoring and alerting in place as each one goes live rather than afterwards.
-
Phase four
Document & hand over
Interface contracts, the ownership map, runbooks for the common failures, and a rehearsed procedure for when a vendor changes their API.
What you receive
The things that actually land.
Artefacts, not adjectives. Everything below is listed in the scope document before a phase starts, so “done” is a defined state rather than an opinion.
-
A data ownership map
One page showing which system owns which field and which way each flow runs. Usually settles an argument that has been running for years.
-
Working integrations
Built with idempotency, retries, backoff and dead-letter handling, so a timeout cannot create a duplicate order or lose one silently.
-
Interface contracts
What each endpoint accepts and returns, versioned and documented with OpenAPI where we are building the API.
-
Monitoring and alerting
Throughput, latency and failure dashboards with alerts that reach a person within minutes. Silent failure is the expensive failure.
-
A reconciliation report
A scheduled check that both ends agree, surfacing drift rather than waiting for a customer to find it.
-
Runbooks for the common failures
What to do when the other end is down, when a schema changes, and when a batch needs replaying.
Proof
Where this has been built before.
Each one describes what was actually built rather than how it felt, and says plainly where we do not have the figures to claim a result.
-
PaidDesk
A multi-tenant UK accounting platform and the site that sells it: invoicing, credit control, payroll, a customer portal, Stripe Connect and an in-app assistant, on a one-time licence.
Read it -
Tag N Tap
Tag N Tap
NFC tags for pets, luggage, medical ID and lost items: an owner’s app, the API underneath it, a full web client, and the public page a finder lands on without installing anything.
Read it
Golden Triangle
Integration in a logistics corridor.
The Golden Triangle’s systems landscape is shaped by freight, and freight integration has its own hard edges.
- Carrier networks Many APIs, one process Businesses here typically use several carriers with incompatible APIs and label formats. Normalising them behind one internal interface is among the highest-value integrations we build.
- Customer EDI Retailer mandates Supplying a national retailer or a tier-one manufacturer means meeting their EDI or portal requirements, not your preferences. We build to their spec and shield your systems from it.
- 3PL and warehouse Stock in two places Third-party logistics means stock you do not physically hold. Keeping availability honest across your WMS, your 3PL and your sales channels is a continuous integration problem, not a one-off project.
We integrate for distributors, manufacturers and e-commerce operations across Birmingham, Coventry, Leicester, Northampton, Nottingham and Derby, including sites at the major Triangle distribution parks.
Technology
Integration technology.
Queues and idempotency rather than cron jobs and hope. Most of what we replace is a scheduled script with no error handling.
- REST & GraphQL
- OpenAPI
- Message queues
- Webhooks & polling
- EDI
- OAuth 2.0
- Azure Service Bus
- AWS SQS / Lambda
- Observability
- Change data capture
Who this is for
API Development for any sector we work in.
The work is the same discipline everywhere; what changes is the systems it has to live with and the people it has to convince. Each sector page covers both.
- Logistics & 3PL Customer portals, booking systems, tracking, automation and APIs.
- Manufacturing Internal platforms, workflow automation, dashboards and integrations.
- Distribution & wholesale B2B portals, ordering systems and ERP integrations.
- Retail & e-commerce Commerce platforms, customer accounts and automation.
- Recruitment Candidate and client portals, CRM integrations and automation.
- Property Property platforms, portals and workflow systems.
- Professional services Client portals, document systems and automation.
- Automotive Supply-chain systems, dealer platforms and internal applications.
- Food & FMCG Supply-chain technology, ordering, inventory and dashboards.
- Healthcare Portals, workflow systems, scheduling and data platforms.
Where we deliver this
API Development across the Golden Triangle.
35 locations, each with a page written for it — the sectors it is actually built on, and what that means for this work. See all areas we serve.
Northamptonshire 10
Warwickshire 5
West Midlands 5
Buckinghamshire 4
Leicestershire 4
Staffordshire 4
Derbyshire 1
Greater London 1
Nottinghamshire 1
Questions
APIs and integration, answered plainly.
The questions that come up once two systems have to agree.
What is the difference between an API and an integration?
An API is an interface a system exposes so other software can read or change its data. An integration is the working connection built between two or more systems, which usually consumes APIs but also has to handle ownership of data, direction of flow, failures, retries and monitoring. Having an API available is not the same as being integrated.
Our software vendor says there is no API. Can you still integrate it?
Usually, yes. Options include a direct but read-only database connection, a scheduled file exchange, the vendor’s import and export routines driven automatically, or in constrained cases robotic automation of the interface. These are less elegant and we say so, but they are frequently enough to remove the manual rekeying, and they can be replaced later if a real API appears.
How do you stop duplicate orders when a sync fails?
Every transfer carries an idempotency key, so if a request is retried after a timeout the receiving system recognises it and does not create a second record. Combined with a dead-letter queue for anything that genuinely cannot be processed, that means a failure becomes a visible item to resolve rather than a duplicate or a gap.
Should we integrate point to point or use middleware?
Point to point is right for two or three connections and becomes unmanageable beyond that, because the number of links grows faster than the number of systems. Once you have four or more systems exchanging data, a thin integration layer costs less over five years and makes replacing any one application a contained piece of work.
How much does an integration project cost?
A single well-built, monitored connection is typically a low five-figure piece of work; a programme joining four or five systems with a middleware layer is larger and is phased. The data-ownership mapping phase is small and fixed-price, and it is where most of the cost of getting it wrong is avoided.
What happens when a vendor changes their API?
We version against their API and monitor for schema and behaviour changes, so a change surfaces as an alert rather than as missing data. Because the integration is documented and the transport is shared, adapting to a vendor change is normally hours of work rather than a rebuild.
How do you handle a vendor changing their API without warning?
We version against their API and monitor for schema and behaviour changes, so it surfaces as an alert rather than as missing data discovered a week later. Because the integration is documented and the transport is shared across flows, adapting is usually hours of work rather than a rebuild.
What happens to records that fail to transfer?
They go to a dead-letter queue and raise an alert, rather than disappearing into a log nobody reads. There is an interface to inspect what failed and why, and to replay it once the cause is fixed. A failure becomes a visible item to resolve instead of a gap you find at month end.
Do we need middleware or can you connect things directly?
Point to point is right for two or three connections and becomes unmanageable beyond that, because the number of links grows faster than the number of systems. Once four or more systems exchange data, a thin integration layer costs less over five years and makes replacing any one application a contained piece of work.
How much ongoing maintenance do integrations need?
Less than people expect if they are built properly, and considerably more if they are not. The ongoing work is responding to vendor changes and occasionally replaying a failed batch. What creates constant maintenance is missing error handling, no monitoring and no documentation — which is exactly what we are usually replacing.
Client voices
What clients say.
-
GTX Digital has been brilliant to work with. They took the time to understand what we needed and built a solution that actually works for the business. The communication has been excellent throughout and it’s clear they understand both the technology and the commercial side.
Tony ShinglerOmnia Resourcing -
Really impressed with GTX Digital. They took the time to understand how our business works before recommending a solution. The whole process was clear, professional and much easier than expected.
James Wilson -
GTX Digital helped us connect several systems that were previously working separately. It has saved our team a lot of manual work and made our processes much more efficient. Great experience overall.
Daniel Harris -
We needed a bespoke software solution for our business and GTX Digital understood exactly what we were looking for. The communication throughout the project was excellent and the finished system works really well.
Sophie Mitchell -
Very professional team. They took the time to understand the problem before suggesting a solution, which we really appreciated. Everything was explained clearly and the project was handled extremely well.
Michael Thompson -
GTX Digital made a complicated technology project feel very straightforward. They kept us updated throughout and were always available when we had questions. Very happy with the final result.
Oliver Bennett -
We approached GTX Digital to replace an outdated system and they handled the whole process brilliantly. The new platform is much easier for our team to use and has made our day-to-day work considerably smoother.
Emily Carter -
Really good experience from start to finish. The team listened to what we needed, explained the technical side in simple terms and delivered a solution that works perfectly for our business.
Ryan Edwards -
GTX Digital helped us automate several repetitive tasks that were taking up far too much of our team’s time. Their approach was practical and the improvements have made a noticeable difference.
Charlotte Morgan -
We had several systems and APIs that needed to work together, and GTX Digital handled the technical side extremely well. They were organised, responsive and professional throughout the project.
Thomas Cooper -
Very happy with the service from GTX Digital. They didn’t try to sell us things we didn’t need. Instead, they focused on understanding our business and finding the right solution.
George Richardson -
GTX Digital helped us turn an idea into a working digital platform. The team were knowledgeable and easy to communicate with, and they made sure we understood everything throughout the development process.
Hannah Walker -
Excellent experience with GTX Digital. The project was well organised and we always knew what was happening next. The final system has made our internal processes much more efficient.
Jack Anderson -
We needed a technology partner who could understand both our business requirements and the technical side of the project. GTX Digital were a great fit and delivered exactly what we needed.
Lauren Parker -
The team at GTX Digital were fantastic to work with. They took a complicated requirement and broke it down into manageable stages. The final solution has saved us a lot of time and reduced repetitive work.
Ben Foster -
Highly recommended. GTX Digital combines strong technical knowledge with a very practical approach to business problems. Communication was excellent and we were very pleased with the finished product.
Olivia Collins
Related services
Closely related.
-
Connect
ERP Integration
ERP connected to everything around it, without touching the core.
Explore -
Connect
CRM Integration
CRM joined to quoting, delivery and accounts, so the pipeline reflects reality.
Explore -
Automate
Data Pipelines
Data moved, cleaned and reconciled on a schedule, so reporting has one source.
Explore
Next step
Start with the data-ownership map.
One page showing which system owns what settles most integration arguments and is useful whatever you build next. It is a short, fixed-price piece of work.