API integration services

Your two systems that have never talked. Our day job.

Two telegraph sounders on separate stands, the wire between them cut, its two ends almost touching

API integration services connect the systems your company already runs so a record entered in one place reaches every system that needs it, with nobody keying it in twice. Pentangle designs and builds those connections for companies whose technology arrived a piece at a time: specced in writing, built to your spec, and if we think the spec should change, we say why and you decide.

The connection you're running by hand

Somewhere in your company there is a person who is the integration. The order arrives in the store, gets keyed into the ERP, then keyed again into the accounting file, and the three copies drift apart until month end forces a reconciliation. Nobody chose this. The connection between systems stays on the someday list because it has always been someone's second job, carried on the side of their day.

What our API integration services include

Every engagement includes the spec, the build, and the follow-through with the people who use the connection, delivered as part of our custom software development services. The connection itself can run between your own systems, out to a third party's, or into a system that has no API yet. What the work includes:

  • A written spec before the build: which systems connect, what data moves, in which direction, and what happens when one side is down
  • Third party API integration: your systems tied to a vendor's, a platform's, or a customer's through the API they publish
  • Custom API integration between the systems you already run: the ERP, the CRM, the store, the accounting file
  • API development and integration for the system that has no interface: we build the API, then the connection
  • Data lake connections, data mapping, and webhook integrations: data from your different sources poured into one place, mapped so every system reads it the same way, and pushed the moment it changes
  • A first working version, then a constant feedback loop with the people who use it

Buyers also call this work systems integration services or IT integration, and underneath the names it is the same job: the software you already own, passing records back and forth without a person in the middle. When the center of the job is wiring your ERP to the systems around it, we treat that as its own practice.

How the build runs

You describe the problem, we spec the connection, we build it, and the people who use it shape the first working version. In that order:

  1. We hear the problem the way the people who run the work describe it, in their words.
  2. We write the spec: which systems, what data, which direction, and what happens when a call fails.
  3. If we think the spec should change, we say why.You decide, and your original path gets built if that is your call.
  4. A first working version goes in front of the people who use it, and the feedback loop runs from there.

That third step is personal. We have been on the other side: we handed a firm a spec and they came back saying that was not what we wanted, and would not spec the thing we asked for. So the rule here runs the other way: we say why we would change it, once, and then we build what you decided.

What changes when the systems talk

The record gets entered once. An order keyed in once that reaches every system that needs it. Our day job. The ERP and the accounting file agree because they are reading the same entry, month end stops hanging on a reconciliation, and the person who spent part of each day re-typing goes back to the job they were hired for. The same wiring carries the front of the process too: data flowing straight from intake forms into the record that needs it.

One hand pump feeding a manifold of pipes that branch out to four valves

Who you are buying from

Pentangle, with one accountable, domestic point of contact: our founder.

A large brass bell hung in an iron frame, its pull rope coiled below it

Our background is software development, architecture, and the CTO seat, and when a piece of the work needs a specialist, we bring in people we trust, as the work needs them. You hire one firm, and you know exactly who answers for the work.

One story from before Pentangle explains how we handle disagreement. A large flooring company was set on buying a bloated middleware package that did not connect natively to its ERP, and our founder offered to build a small integration, running on its own server, that would do the job. They went with the middleware, ended up spending far more in recurring costs, and still had to pay someone else to customize it. That is why, when we think a plan should change, we say so plainly and give the reason, and the decision stays yours.

Common questions about API integration

API stands for application programming interface: the doorway a piece of software publishes so other software can read and write its data. An API integration is a connection built through those doorways, so when a record changes in one system, every system that needs it gets it without a person re-typing it. Most modern platforms publish a REST API, a standard way to read and update records over the web; older systems might offer a file export, a database view, or nothing at all, and the connection is designed around what is really there.

Vendors version and retire their APIs, and a connection that lives in one developer's head breaks quietly when they do. That is why the spec is written down: which endpoints, what data, what happens when a call fails. A documented connection is one a developer can open and repair instead of rediscover.

Sometimes the connector is the right answer, and we say so; we do not custom-build what a solid existing tool already does without a strong reason. We also point out the other direction: where a per-seat license runs past the cost of building the connection once. And connectors assume both sides are modern. When one side is an older system nobody wants to touch, the first step is often opening up a legacy system without replacing it, so the rest of your tools can finally read from it.

We do. QuickBooks publishes an API, which means invoices, payments, and customers can land in the file the moment they exist in the ERP or the store, instead of in a batch somebody types in at month end. Like every connection we build, it is specced to your process, and you see the spec before the build starts.

It starts with you describing the two systems and the job stuck between them, in your own words. From there we write the spec for the connection and what building it involves. If we think your plan should change, we say why, and you decide; if you want your original path, that is what gets built.

Start with a scoping call

Bring us the two systems that have never talked, or the vendor API you have been asked to reach, and we will spec the connections you need: in writing, with our reasons anywhere we would do it differently, and the decision left with you. If what you actually need is a tool off the shelf, that is what the spec will say.