Core Banking Integration: Questions to Ask a Digital Banking Vendor

By Eurisko Team · Last reviewed November 2026

Layers of connected nodes feeding a central processing core

Ask a digital banking vendor how its platform reaches your core, who builds and owns the adapters, where each balance on screen comes from, and what happens to a payment when the core times out halfway through. Those questions, answered in writing and shown working against a test instance of your core, tell you more than any feature demonstration. Integration is where digital banking projects tend to slip, and it is where sales answers are vaguest.

This guide groups the questions by topic and, for each, describes what a strong answer and a weak answer sound like. It names no products: the questions apply whichever core you run and whichever platform you are evaluating.

Which integration approach is proposed, and who owns the adapters?

There are three common routes. The platform calls the core’s own APIs directly; it goes through the enterprise service bus (ESB) or API gateway the bank already runs; or the vendor supplies its own integration layer between its channels and your systems. None is wrong. Direct calls are the quickest to build and the most tightly coupled. Going through the bank’s middleware reuses security and monitoring you already operate, but depends on that team’s backlog. A vendor layer moves fast when the vendor has done it before, and adds a component somebody must own.

Ask who writes each adapter, who maintains it when the core changes, and whether the bank receives the source code and the interface specifications. A strong answer names an owner for every interface and offers contracts in a machine-readable form such as the OpenAPI Specification, a standard, language-agnostic description of HTTP APIs. A weak answer is “our team handles integration”, with the adapters locked inside the licence.

What does “core agnostic” actually mean, and how do you test it?

A platform is core agnostic when its channels talk to a canonical data model (the vendor’s own stable definition of customer, account, transaction, card and payment) and only the adapters underneath know your core’s formats. The claim is weaker than it sounds if that model was shaped around one core, because every other core then needs awkward mapping.

Test it three ways. Ask to see the canonical model and how it is versioned; some vendors align theirs with the BIAN Service Landscape, a reference structure that organises banking service domains, which makes it easier to compare with your own architecture. Ask for a reference integration on a core different from the one in the vendor’s favourite case study. And ask which of your products do not fit the model today (profit-sharing accounts, multi-currency sub-accounts, joint mandates) and how the gap would be closed. A vendor who says everything fits has not looked.

What is really real time, and what does the customer see when the core is down?

Every screen has a data source, and “real time” hides the differences. For each journey, ask whether the platform reads live from the core, from a replica, or from its own cache, and how stale the figure can be. Ask how postings behave during the core’s end-of-day window: are they queued, rejected, or accepted against a shadow balance and posted later?

Then ask about the bad day. When the core is slow, a well-designed platform applies timeouts and circuit breakers, shows the last known balance clearly marked with its time, keeps login and read-only journeys working, and tells the customer plainly which services are paused. A weak answer treats the core as always available, which means your app can never be more available than your core.

How are failures, retries and reconciliation handled?

A transfer crosses several systems, and any hop can fail after the previous one succeeded. Ask how the platform guarantees that a payment is posted once and only once when the app retries on a poor connection. The answer you want is an idempotency key generated at the channel and honoured all the way to the core, with defined timeouts and a bounded retry policy.

Ask what happens when a multi-step operation fails in the middle. A strong design has compensating transactions (an automatic reversal with an audit entry) and a reconciliation job that compares the platform’s records with the core’s every day and raises breaks to operations. Ask to see a reconciliation report.

On events, ask whether the platform learns about changes by polling the core or by subscribing to events from it. That decides how quickly a salary credit becomes a push notification, and whether notifications fire for transactions that started in a branch.

How is the connection between layers secured?

Integration creates a new, privileged path into the core, so examine it as you would an external channel. Ask how services authenticate to each other. Good answers mention mutual TLS between components and OAuth 2.0 access tokens, which the framework (RFC 6749) describes as denoting a specific scope and lifetime, so each service can do only what its scope allows. For higher-risk APIs, ask whether the vendor follows the OpenID Foundation’s FAPI 2.0 Security Profile, which requires access tokens to be sender-constrained using mutual TLS or DPoP.

Ask where secrets and certificates are stored and how they are rotated, whether the integration account on the core has least-privilege rights, and whether every call is written to an audit log the bank can search. Use the OWASP API Security Top 10 as a checklist. Its 2023 edition leads with broken object level authorization and also covers unrestricted resource consumption, improper inventory management and unsafe consumption of APIs, all worth testing on internal integration APIs, not only public ones.

How will it be tested: capacity, environments and a mocked core?

Your core has limits: concurrent sessions, transaction throughput, licensed API calls, batch windows. Ask the vendor how its platform behaves at those limits, not at its own. A strong answer includes a load test plan run against a test instance of your core, with caching, throttling and queueing designed around the measured ceiling. A weak answer quotes benchmark figures from the vendor’s own laboratory.

Ask how many environments are needed and which of them require a live core. Projects stall when every developer waits for one shared core test environment, so ask for a mock or simulator of the core interfaces, built from the agreed contracts, and for realistic, anonymised test data. Ask who maintains the mock when an interface changes.

Will the channels survive a core upgrade, a core migration and new payment rails?

Cores get upgraded, and a core replacement can fall within the life of a channel contract. Ask how APIs are versioned, how long an old version is supported, and what a core upgrade has required at other clients. Then ask the migration question directly: if we move to a different core, what changes? The strong answer is that adapters are rewritten while channel APIs, apps and journeys stay as they are, and that the platform can route some products to the old core and some to the new one during the transition.

Check readiness for what is arriving around the core as well. The BIS Committee on Payments and Market Infrastructures describes ISO 20022 as a common international financial messaging standard, so ask whether the platform maps its payment model to ISO 20022 messages where the instant payment scheme in your market uses them. For open banking, ask which national standard the vendor has implemented. In Saudi Arabia, for example, the Saudi Central Bank’s Open Banking Framework includes technical standards with API specifications, its releases have covered account information and then payment initiation, and an Open Banking Lab lets participants test and certify their APIs against it.

Who does what, and what should you get in writing?

Integration effort is routinely underestimated because three parties each assume another will do the hard part. Before signing, agree a RACI across the bank, the core vendor and the platform vendor for each interface: who specifies it, who builds each side, who provides test environments, who tests, and who supports it in production. Ask the platform vendor what effort it has assumed from your own team and from your core vendor, because that assumption is where estimates break.

Request these artefacts during evaluation, not after contract. The table that follows summarises the questions to put beside them.

  • Interface specifications for every core-facing integration, in a machine-readable format.
  • Sequence diagrams for the main journeys, including the failure paths.
  • A reference integration you can inspect, ideally on a core like yours.
  • A sandbox with a mocked core where your team can call the APIs.
  • A sample reconciliation report and a draft RACI.
Core integration questions: strong answers and warning signs
QuestionStrong answerWarning sign
Who builds and owns the adapters?A named owner per interface; specifications handed to the bankAdapters are a black box inside the licence
How do you prove you are core agnostic?A canonical model plus a reference integration on another core“We integrate with anything”
Where does each balance come from?Stated per journey: live core, replica or cache, with freshness“Everything is real time”
What does the customer see when the core is down?A defined degraded mode per journeyA generic error screen
What stops a retry posting twice?Idempotency keys end to end, daily reconciliation“The core handles duplicates”
How do services authenticate to each other?Mutual TLS, scoped short-lived tokens, managed secretsOne shared service account
How was capacity tested?Load tests against your core’s measured limitsLaboratory benchmarks only
What changes if we replace the core?Adapters change; channel APIs and apps do notA re-implementation project

How Eurisko fits

Eurisko has delivered banking software since 2009, and Eurisko DXP, our digital banking platform, is designed to run in front of any core. It sits above the bank’s existing middleware and never takes direct core access, so a core upgrade or replacement is a connector change rather than a rebuild. Its integration service handles protocol translation, multi-step orchestration and compensating transactions across REST, SOAP, MQ, Kafka, ISO 8583 and ISO 20022, with OpenAPI contracts, sandboxes on synthetic data and idempotent payments. We are happy to be asked every question in this guide.

We are not the right choice if you want a single supplier accountable for both the core and the channels: in that case your core vendor’s own channel module is the simpler route.

FAQ

Frequently asked questions.

What is core banking integration in a digital banking project?

It is the set of interfaces that let mobile and internet banking channels read customer, account and transaction data from the core banking system and post payments and other instructions back to it. It includes the adapters, the data mapping, security between the layers, error handling and reconciliation. It usually determines the project timeline more than the channel features do.

What does “core agnostic” mean for a digital banking platform?

It means the channels depend on the platform’s own canonical data model and only the adapters know the formats of a specific core. The practical test is what changes when the core is upgraded or replaced: on a core-agnostic platform the adapters are rewritten and the apps, journeys and channel APIs stay as they are. Ask for a reference integration on a core different from the vendor’s usual one.

Should the platform connect directly to the core or through our ESB or API gateway?

Either can work. Going through middleware the bank already runs reuses existing security, monitoring and governance, and keeps the core shielded from channel traffic, but it depends on the middleware team’s capacity. Direct integration is faster to build and couples the channels tightly to one core. Decide per interface, and record who owns each adapter.

How long does core integration take?

It depends on the number of interfaces, the quality and documentation of your core’s APIs, and how quickly test environments and core vendor support are available. Ask each vendor for an estimate per interface with the effort it assumes from your team and from your core vendor, since those assumptions are where plans usually break.

Will we have to rebuild our digital channels if we replace the core later?

Not if the platform is properly decoupled. With a canonical data model and an integration layer between channels and core, a core migration means new adapters and routing rules, while customers keep the same apps. Ask the vendor to describe, in writing, what a core change required at another client.

Let’s build

Have something ambitious in mind?

Start a project →

Popular searches

Jump to