Blog
When a vehicle dealer wants to put a car on the lot, the money usually is not theirs yet. They buy stock on floorplan finance, which means asking the bank to approve credit against each vehicle before they take it. The bank answers with an approval or a credit limit, and only then does the deal go ahead. For a software company whose desktop product runs in dealerships all day, every one of those approvals has to flow through its system, fast and on the record.
The client is a South African software company whose system is used by vehicle dealers. The bank exposes its floorplan finance through a SOAP web service, and the client needed its software to use that service without rebuilding the desktop product around it. We built a Dealer Finance Bank Integration, a background PHP worker that sits between the two: the client’s software writes a finance request to a database, the worker sends it to the bank, and the bank’s answer is written straight back into the same record.
Put simply, the dealer’s software drops a request into a table and reads the answer back from the same row a moment later. It never has to speak SOAP, open a network connection, or know anything about the bank’s endpoints. The worker handles all of that in the background, keeps the full request and reply for every call, and the same pattern can be pointed at another bank later.
The client’s product was never built to make live SOAP calls to a bank, and rewriting it to do so would have been slow and risky. The sensible move was to leave the desktop software alone and give it a quiet helper. That set a clear list of what the integration had to deliver before the bank would sign it off.
The cleanest way to join a desktop product to a bank without rewiring either one is to let a database table be the contract between them, and designing that kind of bridge is squarely the work of SOAP API integration, where the real task is translating between two systems that were never meant to talk directly. The client prepares the request as XML and the worker does the networking. A finance request moves in order:
Because the client prepares the XML and only reads the answer back, its desktop software needed no new networking code at all, and the status column keeps the worker from ever submitting the same request twice. The worker itself is a focused piece of custom software built for one job, which is why the same pattern could later be aimed at a second bank with only its endpoints and methods swapped.
The integration is deliberately light. It uses the database as the hand-off, a single worker to do the talking, and a schedule tight enough that answers come back within minutes. The hard part is not any one SOAP call. It is making many different bank operations run through one reliable worker, with every exchange kept for audit. Each layer has one job.
The detail worth care is the method-driven routing. One worker handles the service check, credit check, approve, cancel, and new agreement calls, and the method name written on each row decides which bank endpoint it goes to. That keeps the code to a single path while still covering every operation, and it is what let the same worker be reused for a second bank afterwards.
The sharpest problems in a bank integration are the quiet ones that only show up under testing. During the bank’s test plan, one request type came back with no answer at all. We traced it not to our code but to a missing bracket in the XML supplied for that row, and showed the client exactly where the problem was so it could be fixed at the source. A second call would not route at all, and that turned out to be a spelling difference in a method name, which we matched to the bank’s own naming so the request went through straight away.
The other challenge was the clock. The bank only ran its test environment on fixed days, so there was no room to wait a quarter-hour between attempts and still get through the plan. We tightened the schedule so the worker picked up new test entries within a minute, which kept the testing moving at the pace the bank’s calendar demanded. All of the scenarios in the bank’s test plan, 81 in total, passed, and the client later came back for a second bank integration built on the same pattern.
The integration leaves the dealer’s software doing what it always did, with a quiet worker now carrying every finance request to the bank and the answer back within minutes. The client’s desktop product gained live bank credit checks without a single line of new networking code inside it, every request and reply is stored for audit and support, and the whole set-up runs on the client’s own hosting under its own control. Because the worker is driven by the method name on each row, adding the next bank meant reusing the pattern rather than rebuilding it.
It worked because the database hand-off kept both sides simple: the client owns the XML it knows, and the worker owns the bank talk it does not. If you need to connect existing software to a bank or payment service, you can hire PHP developers who have built this SOAP-worker pattern against a real bank test plan, or tell us which bank or service you need to integrate and our US-registered team will map your methods, your data, and your hosting. It fits lenders, dealers, and the vehicle and dealer finance businesses that run on bank approvals.
What does the Dealer Finance Bank Integration do?
It connects a vehicle dealer software product to a bank’s floorplan finance service. A background PHP worker takes finance requests the client’s software writes to a database, sends them to the bank over its SOAP web service, and writes the bank’s approval or credit answer back into the same record, all without the desktop software having to speak SOAP itself.
Why use a database table instead of calling the bank directly?
The desktop software could not easily make live SOAP calls, and rewriting it to do so was risky. Using a MySQL table as the hand-off means the client’s system just writes a request row and reads the answer back, while the worker handles all the networking. It also keeps a full record of every request and reply for audit.
How quickly does the bank’s answer come back?
The worker runs on a schedule, checking for pending requests every minute, so a request is typically answered within minutes of being written. During the bank’s testing, that schedule was tightened to pick up new entries within a minute so the fixed test days could be used fully.
Which bank operations are supported?
All the ones the bank exposes for floorplan finance: a service check to confirm the bank is up, a credit check for funds against a plan and amount, approve and cancel to reserve or release credit on a vehicle, and new agreement to add the loan and invoice details. One worker handles all of them, routed by the method named on each request.
Can the same approach connect a second bank?
Yes. Because the worker routes each request by the method name on its row and the client prepares the XML, the same pattern can be pointed at another bank by swapping its endpoints and methods. The client came back for a second bank integration built this way.