From interface spaghetti to process coordination layer

Remember the old days of system integration?

Requirement: When we have done task X in application A, we need to send data to application B, so we can continue doing stuff.

Solution: we create a system to system interface.

Purely datadriven. As an example:

- We enter an order in our ordersystem

- During the night, a batchjob will wake up, and send the order data to the invoicing system

- The invoicing system will send an invoice and update general ledger

In diagram:

The results are known:

- Many interfaces, spaghetti

- Applications become coupled, having knowledge about eachother

- Many types of technologies for integration (file/FTP, messaging, API calls)

- A system is responsible for only part of a process (do + send).

- When exceptions arise - who will fix? Extra knowledge of system B in system A.

- Process understanding disappears from business to IT (and from IT to technical batch schedules, that no-one really oversees)

- Difficult to maintain, a change leads to changes in many systems

- Many different ways of reporting status and issues (leading to tons of paper output that no-one dares to read or check...)

And of course, we have tried. We invented EAI. Companies bought ESB's. The result: the same spaghetti, but now standards based.

The lesson: put the process back in the solution. E.g. don't let systems do hand-offs, but let a process coordination engine do this for us....

The solution now looks like this:

Advantages:

- Clear process

- Part of exceptions can be handled by process engine itself

- Other exceptions can be forwarded as manual tasks to business and IT without additional changes in systems

- Systems are decoupled and have no knowledge of each other

- Integrated, process based (in stead of integration based) reporting

- Information flow can be real time (or can still be done in batch)

Realize - this should change your thinking. Don't think interface, think process:

Requirement: we want to correctly sell and invoice our products (process). As a first step, we want to capture order data (step in process). After that, we want to generate and send an invoice (step) and update this correctly in our general ledger.

Solution: define the process, link the process and the solutions for the steps, and use a process coordination layer.