The Integration That Seemed Simple and Took Three Months
In the first meeting, the conclusion seemed obvious:
“The integration is straightforward. We just need to consume the service, send the transaction, and receive a response.”
The diagram showed two systems, an arrow between them, and a small box labeled API.
The initial estimate was just a few weeks.
There was technical documentation, testing environments, and experienced teams. There was no need to build a new product or replace the core system. Apparently, all that was required was to connect a digital platform to an existing banking system to execute a financial transaction.
Three months later, the integration finally went live.
Not because the team lacked technical capabilities.
Not because the technology was inadequate.
And not because there was one extraordinarily complex problem.
The project took three months because what appeared to be a connection between two systems was actually a connection between processes, business rules, operational teams, security controls, vendors, networks, and different interpretations of how a banking transaction should work.
At WAU, we have participated in various technology integration projects, particularly within the financial sector. These experiences have taught us that integrations that seem simplest in a presentation are often the ones hiding the most assumptions.
This project was one of those cases.
The First Mistake: Thinking Integration Was Just About Sending Data
During the initial sessions, the analysis focused on the message structure.
What fields did the request need to include?
What format did the response use?
What was the authentication mechanism?
How were error codes handled?
From a technical standpoint, everything seemed reasonable. However, we soon discovered that the actual workflow didn’t begin when one system sent a request or end when it received a response.
Before executing a transaction, the system had to validate limits, account status, fund availability, product restrictions, operating hours, and user permissions.
After execution, it had to record audit information, generate notifications, update balances, feed accounting processes, and make information available for reconciliation.
The API represented only one part of the process.
The mistake was estimating the integration based on the technical contract without first mapping the entire transaction lifecycle.
At WAU, we’ve learned that an API can accurately document how information is exchanged without necessarily explaining how the business operates around that information.
The Documentation Said One Thing, but the System Did Another
The team began development using the available documentation.
The first calls worked.
Then the exceptions started appearing.
A field described as optional was mandatory for certain products.
A response code could represent two different situations.
Some operations returned successfully but remained pending in internal processes.
Others returned a technical error even though the transaction had actually been processed.
We also found differences between the testing and production environments. The versions weren’t exactly the same, the catalogs had different configurations, and some validations existed only in production.
The documentation wasn’t necessarily wrong.
It simply didn’t contain all the operational knowledge that had accumulated around the system over the years.
Some of that knowledge was embedded in internal procedures.
Other parts existed in configurations.
And a significant portion lived only in the experience of certain individuals.
This is a common risk when working with banking systems that have evolved over many years. Actual system behavior isn’t always documented in a single place. It’s distributed across code, configurations, manuals, operational processes, and human knowledge.
The Integration Worked, but the Transaction Didn’t Always Complete
One of the most challenging moments came when we began running end-to-end tests.
From the source system, the request was sent successfully.
On the receiving system, the transaction appeared as processed.
But in some cases, the source system never received confirmation.
Should it resend the request?
If it did, it could duplicate the transaction.
If it didn’t, the customer might be left without an answer.
This is where one of the most important risks in any financial integration emerged: uncertainty about the final transaction status.
In banking systems, knowing that a request was sent isn’t enough. We need to determine with certainty whether the operation:
- Never reached the receiving system.
- Reached the system but wasn’t processed.
- Was processed, but the response wasn’t received.
- Remained pending.
- Was reversed.
- Or was successfully completed and posted.
The problem wasn’t purely technical. It had financial, operational, and customer experience implications.
We had to introduce unique identifiers, idempotency controls, status inquiries, retry policies, and reversal processes.
None of these were clearly included in the initial scope.
For the WAU team, this was one of the project’s most important lessons: a financial integration shouldn’t be designed only to process successful transactions. Above all, it must be designed to manage uncertainty when something goes wrong.
Testing Environments Didn’t Reflect Reality
Another assumption was that the testing environment would be sufficient to validate the entire system’s behavior.
It wasn’t.
Transaction volumes were lower.
The data was controlled.
The accounts used didn’t have all the restrictions of real-world products.
Operating windows didn’t match those in production.
Interruptions, network delays, timeouts, and overnight processes weren’t adequately simulated either.
The integration worked well when everything was available.
But banking systems must also work when a dependency takes too long to respond, when a response never arrives, or when a component is temporarily unavailable.
The most important test wasn’t whether the successful flow worked.
It was what happened when something failed.
Today, at WAU, we aim to ensure that integration testing goes beyond the so-called “happy path.” From the early stages, we include scenarios involving unavailability, duplication, delayed responses, reversals, and discrepancies between systems.
Security Was Also Part of the Timeline
Initially, we assumed security would involve exchanging certificates and configuring credentials.
In practice, we had to coordinate access lists, firewall rules, encryption, certificate renewals, secrets vaults, traceability, segregation of duties, and permissions across different environments.
Every change required validation from multiple teams.
A configuration could be correct on one end and blocked on the other.
A certificate could be valid but lack the complete chain of trust.
An address could be authorized for testing but not for production.
We also had to review what sensitive information could be recorded in logs. Logs were essential for investigating issues, but they couldn’t expose account numbers, credentials, or personal information.
Security wasn’t a task to be added at the end.
It was an entire workstream within the project.
Experiences like this have also led us at WAU to involve infrastructure, security, and operations teams from the very beginning. Bringing them in only after development is complete often leads to delays, redesigns, and risks that could have been identified much earlier.
Business Rules Were Distributed Across Teams
One of the biggest lessons was discovering that no single person knew the entire workflow.
The technical team understood the interface.
The business team understood the product rules.
Operations knew the exceptions.
Security understood the access restrictions.
Accounting knew how the transaction needed to be recorded.
The vendor understood the internal behavior of its platform.
And customer service knew what problems occurred in day-to-day operations.
Each team had part of the picture.
The project truly moved forward when we stopped asking only:
“How does the API work?”
And started asking:
“What needs to happen from the moment a customer initiates the transaction until every team can confirm that it has been completed successfully?”
Based on this and other projects, at WAU, we’ve reinforced the importance of approaching integrations as end-to-end processes rather than isolated development tasks.
An integration can be technically complete and still not be ready for production.
Reconciliation Entered the Conversation Too Late
During the first few weeks, the main objective was to get the transaction executed.
Later, a simple question came up:
“How will we verify at the end of the day that both systems have the same information?”
That question changed the project.
A financial integration doesn’t end when a transaction returns a successful response. There must be a way to compare records, identify discrepancies, and resolve them.
We had to define:
- Which system was the source of truth for each data element.
- Which fields would be used to match transactions.
- How duplicates would be identified.
- What would happen to pending transactions.
- Who would investigate discrepancies.
- And how they would be corrected without compromising traceability.
Without reconciliation, an integration can appear successful throughout the day and still generate financial discrepancies at closing.
Today, when we at WAU assess a transactional integration, reconciliation is no longer treated as a follow-up activity. It’s considered part of the initial design.
The question isn’t just how to move a transaction between two platforms.
We also need to determine how to prove that the transaction was correctly recorded across every system involved.
The Hardest Problem Wasn’t Technological
As the project progressed, coordination challenges also began to emerge.
Teams had different priorities.
Some dependencies belonged to third parties.
Change windows were limited.
Testing required the simultaneous participation of several teams.
When an error occurred, it wasn’t always clear who should investigate it first.
Each group analyzed only its own component and confirmed that it was working.
The problem, however, existed in the space between components.
In a complex integration, every system can work correctly on its own while the overall process still fails.
That’s why accountability can’t be divided solely by application. There must be someone responsible for the entire end-to-end workflow.
This was also a leadership lesson.
At several points, the most important role of the WAU team wasn’t writing code. It was bringing the right people together, translating technical and operational perspectives, organizing evidence, and keeping everyone’s attention on the complete workflow.
Technology solved one part.
Communication and collaboration solved the rest.
What Did We Underestimate?
When we reviewed the project, we identified seven main areas we had underestimated.
1. The Number of Hidden Business Rules
Many rules weren’t included in the technical documentation. They surfaced when testing different products, customers, and scenarios.
2. Error Handling and Uncertain Transaction States
We designed the successful path first and left exceptions for later.
3. Differences Between Environments
We assumed testing and production would have equivalent configurations.
4. Organizational Dependencies
We estimated development time but not the time required for coordination, approvals, and operational windows.
5. Security and Compliance
We treated security controls as additional requirements when they were actually a central part of the architecture.
6. Reconciliation and Post-Implementation Operations
We focused on getting the integration running without designing from the beginning how it would be monitored and operated.
7. Undocumented Knowledge
We relied too heavily on documents and not enough on the people who understood the actual process exceptions.
How Would We Identify These Issues Earlier Today?
If we were starting a similar integration project at WAU today, we wouldn’t begin by estimating based on the API documentation.
We would start by building a complete map of the operation.
1. Map the End-to-End Workflow
From the customer’s initial action to posting, reconciliation, and exception resolution.
Each step would have an accountable system, a responsible team, and an expected outcome.
2. Create a Scenario Catalog
Not just the successful case.
We would also include:
- Timeouts.
- Duplicate messages.
- Delayed responses.
- Insufficient funds.
- Blocked accounts.
- Exceeded limits.
- Reversals.
- Network interruptions.
- Operational cutoffs.
- Maintenance windows.
- Transactions processed without a response.
3. Validate the Integration Using Representative Data
Synthetic data is useful, but it rarely captures the full diversity of products, configurations, and exceptions found in a banking operation.
Whenever possible, and while complying with privacy controls, we would use anonymized data that reflects real-world scenarios.
4. Test Failure Handling First
Before celebrating that a successful transaction works, we would verify that the system can respond correctly when a dependency fails.
5. Build Idempotency Into the Design
Every financial operation should be able to identify retries and prevent duplicate transactions.
6. Involve Security, Infrastructure, and Operations From the Start
Not as reviewers at the end, but as active participants in the design process.
7. Design Reconciliation Before Development
The question wouldn’t simply be how to send the transaction, but how to prove afterward that it was correctly recorded across all systems.
8. Establish End-to-End Observability
Every operation would have a traceable identifier across all components.
Dashboards would show how many transactions were successful, rejected, pending, or reversed.
9. Run an Early, Controlled Test
A small technical test under the right conditions can reveal within days discrepancies that a testing environment might fail to expose over several weeks.
10. Account for Uncertainty in the Estimate
In legacy or poorly documented systems, not everything can be known upfront.
The timeline must include time to discover rules, resolve dependencies, and adjust the design.
The Real Lesson
The integration was ultimately successful.
But the project’s greatest value wasn’t simply connecting the systems.
It was understanding that, within a financial institution, an integration is never just an arrow between two applications.
It’s a chain of decisions, validations, controls, and responsibilities.
Every system has its own history.
Every process has exceptions.
Every team sees a different risk.
And every transaction must maintain consistency, security, and traceability, even when something goes wrong.
At WAU, this and other experiences have helped us evolve the way we approach integration projects.
Today, we know that the work doesn’t begin with development.
It begins with questions.
What happens if the response never arrives?
How do we prevent duplicates?
How do we reconcile?
Which system is the source of truth?
What differences exist between environments?
Who handles exceptions?
How will we know that the transaction has actually been completed?
Often, complexity isn’t hidden inside the technology.
It’s hidden inside the questions we haven’t asked yet.
And in banking integration projects, identifying those questions early can make the difference between an integration that takes a few weeks and one that takes three months.
At WAU, we continue learning from every implementation because integrating systems isn’t just about connecting technology.
It’s about connecting processes, teams, and responsibilities so the entire experience works as it should.
What’s the most unexpected risk you’ve encountered when integrating systems?