Skip to main content

STALLYONS TECHNOLOGIES

Innovating the future of digital with AI, design, and technology. From AI to Web — Stallyons transforms your ideas into digital reality. Building smarter digital experiences through AI, innovation, and technology. Innovating the future of digital with AI, design, and technology. From AI to Web — Stallyons transforms your ideas into digital reality. Building smarter digital experiences through AI, innovation, and technology.
EN
background

Blog

Dealer Finance Bank
SOAP API Integration

Dealer Finance Bank SOAP API Integration

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 Starting Point: A Desktop System That Could Not Speak SOAP

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.

  • A legacy-friendly link. The desktop software could not easily speak SOAP itself, so the integration had to meet it with something as simple as a database row.
  • Several bank operations. The bank offered a service check, a credit check, approve, cancel, and new agreement, and all of them had to be supported.
  • Bank-grade testing. Every scenario in the bank’s own test plan had to pass against its sandbox before the integration could go live.
  • Full traceability. Every request and every answer had to be kept, so support and the bank could audit exactly what was sent and received.
  • Client-controlled hosting. The whole thing had to run on the client’s own standard Linux hosting, with no special infrastructure.

The Build: The Database as the Hand-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:

  1. The client’s software inserts a row into a MySQL table with the SOAP method to call, the ready-made XML request, and a status of “Pending”.
  2. A scheduled job, running every minute, picks up any rows still marked pending so nothing waits long and nothing is sent twice.
  3. The worker reads the method name on the row and wraps the request for the matching bank endpoint.
  4. It authenticates with the bank and sends the SOAP call over an encrypted connection.
  5. The bank’s XML reply is written back into the same row, alongside the original request.
  6. The row’s status changes to “Processed”, which is the signal for the client’s software to read the answer.
  7. The client’s system picks up the reply and shows the dealer the approval or credit limit, with the full exchange kept on record.

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.

Technical Architecture

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.

  • SOAP over WSDL. The bank’s official interface, so the integration speaks exactly the protocol the bank supports rather than a workaround.
  • PHP worker. A light script that runs on standard Linux hosting, reads pending rows, and makes the right SOAP call for each.
  • MySQL hand-off table. The simple contract with the desktop software: method, XML request, XML response, status, and request time all live in one row.
  • Cron schedule. The worker runs every minute, so a pending request is usually answered within minutes without anyone triggering it.
  • Bank sandbox and SoapUI. Every operation was proven against the bank’s test environment before a single call went to production.
  • Client cPanel hosting. The whole set-up runs on the client’s own server, so it keeps full control of the integration and its data.

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.

Challenges Solved

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 Result

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.

Frequently Asked Questions

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.

Leave a Reply