Skip to Content

III. Enterprise Service Bus in Banking SOA Architecture

This blog is the third part of a series of four introducing the concepts and building blocks of a service oriented architecture in a banking environment.

Introduction to Service Oriented Architecture in Banking

II. SOA needs meaningful services – The provisioning platform

Part III – Enterprise Service Bus

Part IV –  SOA in practice – Banking Account Origination


In the previous blog of this series I have promised to come back to a more technical subject, and that’s what we will do today: Focusing on one of the most prominent and known building block of a SOA design: the Enterprise Service Bus. But before we start, let’s get one thing straight: we will not dive deep down into geek talk using numerous TLAs (three letter acronyms), web service standards and technology buzz words but rather consider the reasoning for introducing an ESB in our SOA Banking projects. 

Even in the old days when service orientation was not “en vogue”, a core banking implementation always had lots of integration aspects as part of the project scope. Anti Money Laundry(AML) systems had to be integrated as well as internal and external scoring engines, origination systems and so on. So, integration via interfaces was required, which was (if not done in the spaghetti fashion of point-to-point integration) usually approached by the concept of Enterprise Application Integration (EAI).  This concept essentially assumes that application systems will expose interfaces to their business objects and that a central middleware component will allow to connect the various interfaces to each other handling all the necessary data transformations (mappings) as well as protocol adjustments (one system exposes data as a file interface, another one can receiver data via an message queuing system).


Instead of middleware (or integration layer), today everybody talks about an ESB. This is true for “geeks” as well as “suits”: I have in fact been involved with customers, where the business users praised the benefits of “THE ESB” and how it solves all the integration challenges of their application landscape. Despite all the hype , for me the fundamental questions are 

  1. How is the ESB term defined in a particular project environment
  2. How does the ESB strategy differentiate from your former EAI strategy

If you have ever tried to find a definition on ESB, you will have noticed there is a common agreement that there is no industry wide accepted definition on what an ESB is. If you talk to your technology people, you will most likely get some answers on key capabilities that are to be expected from an ESB such as:


  • Support for synchronous and asynchronous messaging
  • Open Standards Support (usually here you get a TLA list thrown at you)
  • Ability to wrap non-WS enabled (legacy) applications and expose them as managed and reusable services
  • Mediation Capabilities
  • All routing patterns including dynamic routing, such as content-based routing
  • Data mapping and transformation
  • Interoperability between consumers and providers with different bindings, such as SOAP/http as well as proprietary protocols
  • Ability to add additional mediation capability for message enrichment
  • Support for message-level and transport-level policy-based security

Without discussing these statements in detail, I usually like to look at the different parts of the ESB acronym to give it some more “business” meaning and also like to understand what the implementation project likes to archive with introducing an ESB:


Enterprise: “got to be something big, relevant beyond departmental interests”.


Service: “is a set of benefits delivered from the accountable service provider, mostly in close coaction with his service suppliers, generated by the functions of technical systems and/or by distinct activities of individuals, respectively, commissioned according to the needs of his service consumers by the service customer from the accountable service provider, rendered individually to the authorized service consumers on their dedicated request, and, finally, utilized by the requesting service consumers for executing and/or supporting their day-to-day business tasks or private activities.” (Wikipedia – Economics)


Bus: “Bus services can fit into several classes. Local transit buses provide public transit within a city or one or more counties, usually for trips of only a few kilometers. Intercity, interstate or inter-provincial buses provide transit between cities, towns, rural areas and places usually tens or hundreds of kilometers away. They generally provide fewer bus stops than local bus routes do”. I know this comparison is not 100% technically adequate if we look at various computer bus technologies, but I believe offers a good picture of the idea of ESB as transportation means.


To put it simple, an ESB should provide some transportation mechanism to connect service providers (also known as capabilities) with service consumers (also known as needs) in an enterprise context. A Service provider could be e.g. a Banking Services 6.0 system as mentioned in the last blog, which exposes a service for bank account balance. On the other hand, a channel application (like an Internet Banking Application) might have the need of displaying an up to date account balance to a customer. The ESB connects needs with capabilities and routes the request accordingly.


In my opinion, the most important role of an ESB component in a SOA design is to decouple service provider and service consumer from each other. In the example above this would imply that the Internet Banking channel application sends the account balance inquiry not directly to an account management system such as SAP Banking Services 6.0, but to the ESB component. The ESB itself exposes a service to the channel that provides balance inquiry. Once the request hits the ESB, the bus will then determine which service provider to contact in order to retrieve the requested information. This can be a static routing, or a dynamic one based on some specific content of the request message. The later case is called content based routing. The routing to the provider system is done based on some content of the request message such as a bank key representing a certain branch- (just as an FYI).


Essentially, the service implementation in the backend systems can be done on another system or server tomorrow without impacting the channel application. It would just require a change in the routing logic of the ESB. But of course, this can only work efficiently, if the newly implemented service is semantically identical to the previous one.


Having said this leads us directly to the question on how an ESB differs from the classical EAI approach we have used over the last years. In the EAI practice, we took each interface definition giving by various application systems for granted and made any effort needed on the middleware platform to make those applications “talk to each other”. This is commonly referred to as “Inside-Out” approach as the application systems expose their inner data structures and semantics to the outside world. Designing services via an ESB paradigm makes only sense if services are modeled according to a harmonized data model first before implementation takes place. This is called Outside-in approach, as the model that is developed outside an application context (such as the import and export parameters of that service, its communication patterns and so on) is afterwards propagated to the application systems for implementation. This approach will eventually result in no or only few data mapping requirements on the ESB as the semantically data model is harmonized across various provider and consumer applications based on a commonly shared service model. This is in fact one of the main differentiating factors between a classical EAI and an ESB approach: EAI will heavily depend on data transformations (mappings) on the middleware component; in a service oriented architecture, the ESB ideally does not perform tremendous amounts of data mappings.


To summarize the main take-aways for the ESB component in a SOA design:


  • An ESB strategy should primarily allow us to support our SOA deployment. It is not a new integration platform for all integration needs (even though the physical ESB product could support all of those requirements). Of course from an IT operational perspective, you might want to consolidate your various integration platforms to reduce total cost of ownership. However, don’t make this part of the deliverables of your ESB initiative.
  • Define your core goals and use case for ESB usage such as
    • decoupling service consumer from service provider
    • using routing capabilities
    • monitoring and runtime governance
  • When implementing an ESB, don’t consider only technology aspects. Introduce a solid governance model for modeling services in a canonical way via an outside-in approach. The predefined enterprise services in the SAP platform as well as the underlying Global Data Types (GDT) offer a great methodology for this (see the previous blog of this series).
  • Focus on strategic areas for your services provisioning via ESB. Not every new interface needs to be a service. Typical use cases are e.g. channel agnostic services you are going to provide to support your multi-channel strategy, or services you would like to harmonize across the application landscape. I have used the ESB approach e.g. to provide a generic scoring service for a global roll-out scenario. Within a given process step (during account origination) a customer scoring had to be executed. However, when we rolled out the process into various countries, each country had their own local scoring system. But this only meant to adjust the content based routing on the ESB and in this instance develop the mapping to the local scoring service. From an overall origination process, the process flow and process steps kept unchanged.
You must be Logged on to comment or reply to a post.
  • I found your analysis interesting and logical, I beleive doing these definitions and decisions of what should be in the ESB initiative and what should not is the key for the success of the overall SOA deployment.
  • Hello Thomas,

    I loved reading your blog. I especially found your comparison on EAI and ESB very interesting.

    Two questions

    1. "This is in fact one of the main differentiating factors between a classical EAI and an ESB approach: EAI will heavily depend on data transformations (mappings) on the middleware component; in a service oriented architecture, the ESB ideally does not perform tremendous amounts of data mappings."

    I agree with your point about having an harmonized data model. However, in real life scenarios you have a lot of existing applications which expose their functionality as "API" (or interfaces). These interfaces do not adhere to the harmonized metamodel and hence you will still have mappings to map the harmonized data model to the existing interface definitions. This is especially true for SOA by evolution model (where we "service enable" existing applications).

    Mappings would reduce only when you use the harmonized model to define and implement new functionality in which the interfaces are harmonize "by design".
    2. This difference you mention is also a difference in approach / methodology. However, from a feature / functionality perspective is there is much difference between EAI and ESB? Especially looking at the list of functionalities that you have mentioned above that constitutes an ESB.

    Would love to hear your thoughts regarding this!

    • Hi Rathish,

      thanks for the feedback. I fully agree with your statement that in a SOA by Design approach it is much more easy to introduce and adhere to a harmonized data model. However, if you think about an approach like SAP Global Data Types (GDT) the data objects are described in an implementation-independent meta data format like XSD.

      At the point of implementation, you have to transform the service contract from the meta format to the implementation platform specific data types (such as ABAP or Java) anyhow. So of course there is still some form of mapping. My take always is that the service provider systems shall provide service contracts consistent with a global data model, so that no/only limited semantical mappings have to happen on the bus component. This increases reusability and business relevance of a service. In comparison, the exposure of a system API will most likely be very specific to the provider system, so external mappings are always required, which make it harder to re-use this "service".

      Regarding your second comment: Yes, the main difference in my opinion is based on methodology, not as much on the feature side. There are often detailed discussions on e.g. WS-* standards, which I believe are important ones from the technology side. However, when we accept that SOA is an architectural style that often is but does not need to be neccessarily implemented via web service technologies, then the question on how we logically implement an ESB functionality becomes much more important that via which technologies this is provided.